PHP Arrays::is方法代码示例

 private function format($text = '', $parameters = array())
 {
     if (!Arrays::is($parameters) && 'NONE' == $parameters) {
         return $text;
     }
     if (!Arrays::is($parameters) && isset($this->styles[$parameters])) {
         $parameters = $this->styles[$parameters];
     }
     $codes = array();
     $fg = isAke($parameters, 'fg', null);
     $bg = isAke($parameters, 'bg', null);
     if (!empty($fg)) {
         $codes[] = $this->foreground[$fg];
     }
     if (!empty($bg)) {
         $codes[] = $this->background[$bg];
     }
     foreach ($this->options as $option => $value) {
         $paramOpt = isAke($parameters, $option, null);
         if (!empty($paramOpt)) {
             $codes[] = $value;
         }
     }
     return "[" . implode(';', $codes) . 'm' . $text . "[0m";
 }

 public function orderBy($tab, $fieldOrder, $orderDirection = 'ASC')
 {
     $sortFunc = function ($key, $direction) {
         return function ($a, $b) use($key, $direction) {
             if ('ASC' == $direction) {
                 return $a[$key] > $b[$key];
             } else {
                 return $a[$key] < $b[$key];
             }
         };
     };
     if (Arrays::is($fieldOrder) && !Arrays::is($orderDirection)) {
         $t = array();
         foreach ($fieldOrder as $tmpField) {
             array_push($t, $orderDirection);
         }
         $orderDirection = $t;
     }
     if (!Arrays::is($fieldOrder) && Arrays::is($orderDirection)) {
         $orderDirection = Arrays::first($orderDirection);
     }
     if (Arrays::is($fieldOrder) && Arrays::is($orderDirection)) {
         for ($i = 0; $i < count($fieldOrder); $i++) {
             usort($tab, $sortFunc($fieldOrder[$i], $orderDirection[$i]));
         }
     } else {
         usort($tab, $sortFunc($fieldOrder, $orderDirection));
     }
     return $tab;
 }

 public function keys($pattern)
 {
     $keys = $this->session->getKeys();
     if (!empty($keys)) {
         $seg = isAke($keys, sha1($pattern));
         if (!empty($seg)) {
             return $seg;
         }
     }
     $this->call('keys', array("pattern" => $pattern));
     $tab = json_decode($this->response, true);
     $res = isAke($tab, 'message');
     $collection = array();
     if (Arrays::is($res)) {
         if (count($res)) {
             foreach ($res as $row) {
                 array_push($collection, $row);
             }
         }
     }
     if (empty($keys)) {
         $keys = array();
     }
     $keys[sha1($pattern)] = $collection;
     $this->session->setKeys($keys);
     return $collection;
 }

 public function __call($method, $args)
 {
     if (true === $this->__has($method)) {
         return $this->__fire($method, $args);
     }
     $reverse = strrev($method);
     $last = $reverse[0];
     if ('s' == $last) {
         if (!count($args)) {
             return isAke($this->values, $method);
         } else {
             $this->values[$method] = !Arrays::is($this->values[$method]) ? array() : $this->values[$method];
             foreach ($args as $arg) {
                 array_push($this->values[$method], $arg);
             }
         }
         return $this;
     } else {
         $method .= 's';
         if (!count($args)) {
             $val = isAke($this->values, $method);
             return count($val) ? Arrays::first($val) : null;
         } else {
             $this->values[$method] = !Arrays::is($this->values[$method]) ? array() : $this->values[$method];
             foreach ($args as $arg) {
                 array_push($this->values[$method], $arg);
             }
         }
         return $this;
     }
 }

 public static function send($arguments = array())
 {
     $response = static::request('messages/send', $arguments);
     if (false !== $response && Arrays::is($response)) {
         $response = Arrays::first($response);
         return $response['status'] == 'sent' ? true : $response['status'];
     }
     return false;
 }

 public function getHeader()
 {
     $this->rewind();
     $current = $this->current();
     if (Arrays::is($current)) {
         return $current;
     }
     return array();
 }

 public function make(array $array)
 {
     $return = array();
     foreach ($array as $k => $v) {
         if (Arrays::is($v)) {
             $o = new self();
             $return[$k] = $o->populate($v);
         } else {
             $return[$k] = $v;
         }
     }
     return $return;
 }

 public static function clean($data)
 {
     if (Arrays::is($data)) {
         foreach ($data as $key => $value) {
             unset($data[$key]);
             $data[static::clean($key)] = static::clean($value);
         }
     } else {
         if (ini_get('magic_quotes_gpc')) {
             $data = stripslashes($data);
         } else {
             $data = htmlspecialchars($data, ENT_QUOTES, 'UTF-8');
         }
     }
     return $data;
 }

 /**
  * Add file to the archive
  *
  * @param array/string $files
  * @param string $string
  * @return bool
  */
 public function add($files, $string = false)
 {
     if (true === $this->_enabled) {
         if (Arrays::is($files)) {
             foreach ($files as $file) {
                 $this->_addFile((string) $file);
             }
         } else {
             if (!empty($string) && is_string($string)) {
                 return $this->_zip->addFromString($files, $string);
             } else {
                 return $this->_addFile($files);
             }
         }
     }
     return false;
 }

 public function keys($pattern)
 {
     $collection = $this->data($pattern);
     if (!Arrays::is($collection)) {
         $oldPattern = $pattern;
         $pattern .= '*#*';
         $pattern = repl('**', '*', $pattern);
         $files = $this->glob($this->dir . DS . $pattern);
         $collection = array();
         if (count($files)) {
             foreach ($files as $row) {
                 array_push($collection, $row);
             }
         }
         $this->setData($oldPattern, $collection);
     }
     return $collection;
 }

 private static function dispatch()
 {
     $uri = str_replace(Config::get('application.base_uri'), '', isAke($_SERVER, 'REQUEST_URI', '/'));
     $method = strtolower(isAke($_SERVER, 'REQUEST_METHOD', 'get'));
     $routes = (include CONFIG_PATH . DS . 'routes.php');
     if (!empty($routes)) {
         foreach ($routes as $route) {
             $methodRoute = !isset($route->method) ? 'get' : strtolower($route->method);
             if ($route->path == $uri && $methodRoute == $method) {
                 return $route;
             }
             $match = static::match($route->path, $uri);
             if (false !== $match && $methodRoute == $method) {
                 if (!empty($match)) {
                     $args = $route->args;
                     if (Arrays::is($args)) {
                         if (count($match) == count($args)) {
                             $continue = false;
                             $i = 1;
                             foreach ($args as $key => $closure) {
                                 $val = $closure($match[$i]);
                                 if (false === $val) {
                                     $continue = true;
                                     break;
                                 }
                                 $_REQUEST[$key] = $val;
                                 $i++;
                             }
                             if (true === $continue) {
                                 continue;
                             }
                         }
                     }
                 }
                 return $route;
             }
         }
     }
     return static::route(['controller' => 'static', 'action' => 'is404']);
 }

 public static function configs($entity, $key, $value = null, $cb = null)
 {
     if (!strlen($entity)) {
         throw new Exception("An entity must be provided to use this method.");
     }
     if (!Arrays::exists($entity, static::$configs)) {
         self::$configs[$entity] = array();
     }
     if (empty($value)) {
         if (!strlen($key)) {
             throw new Exception("A key must be provided to use this method.");
         }
         return isAke(self::$configs[$entity], $key, null);
     }
     if (!strlen($key)) {
         throw new Exception("A key must be provided to use this method.");
     }
     $reverse = strrev($key);
     $last = $reverse[0];
     if ('s' == $last) {
         self::$configs[$entity][$key] = $value;
     } else {
         if (!Arrays::is(self::$configs[$entity][$key . 's'])) {
             self::$configs[$entity][$key . 's'] = array();
         }
         array_push(self::$configs[$entity][$key . 's'], $value);
     }
     return !is_callable($cb) ? true : $cb();
 }

 public static function mime($extension, $default = 'application/octet-stream')
 {
     Config::load('mimes');
     $mimes = null !== config::get('mimes') ? config::get('mimes') : [];
     if (!Arrays::exists($extension, $mimes)) {
         return $default;
     }
     return Arrays::is($mimes[$extension]) ? Arrays::first($mimes[$extension]) : $mimes[$extension];
 }

 /**
  * Check if the array is a multidimensional array
  *
  * @param  Array   $array The array to check
  * @return boolean
  */
 protected function isMulti(array $array)
 {
     $first = array_shift($array);
     return Arrays::is($first);
 }

 /**
  * Merges any number of arrays of any dimensions, the later overwriting
  * previous keys, unless the key is numeric, in whitch case, duplicated
  * values will not be added.
  *
  * The arrays to be merged are passed as arguments to the function.
  *
  * @return array Resulting array, once all have been merged
  */
 public function arrayMergeRecursiveReplace()
 {
     // Holds all the arrays passed
     $params = func_get_args();
     // First array is used as the base, everything else overwrites on it
     $return = array_shift($params);
     // Merge all arrays on the first array
     foreach ($params as $array) {
         foreach ($array as $key => $value) {
             // Numeric keyed values are added (unless already there)
             if (is_numeric($key) && !in_array($value, $return)) {
                 if (Arrays::is($value)) {
                     $return[] = $this->arrayMergeRecursiveReplace($return[$key], $value);
                 } else {
                     $return[] = $value;
                 }
                 // String keyed values are replaced
             } else {
                 if (isset($return[$key]) && Arrays::is($value) && Arrays::is($return[$key])) {
                     $return[$key] = $this->arrayMergeRecursiveReplace($return[$key], $value);
                 } else {
                     $return[$key] = $value;
                 }
             }
         }
     }
     return $return;
 }