PHP Utilities\Arrays类代码示例

 private function _parseUrlParams($url)
 {
     $urlComponents = parse_url($url);
     $query = Arrays::getValue($urlComponents, 'query', '');
     parse_str($query, $array);
     return $array;
 }

 /**
  * @return bool
  */
 public function isShittyRound()
 {
     $hitsInRound = Hit::where(['game_user_id' => $this->game->current_game_user_id, 'round' => $this->game->round])->fetchAll();
     return Arrays::all($hitsInRound, function ($hit) {
         return !$this->isScored($hit->field, $hit->multiplier);
     });
 }

 public static function newInstance($options)
 {
     if (Arrays::getValue($options, Options::EMULATE_PREPARES)) {
         return new EmulatedPDOPreparedStatementExecutor();
     }
     return new PDOPreparedStatementExecutor();
 }

 /**
  * Returns object from cache.
  * If there's no object for the given key and $functions is passed, $function result will be stored in cache under the given key.
  *
  * Example:
  * <code>
  * $countries = Cache::get("countries", function() {{
  *    //expensive computation that returns a list of countries
  *    return Country:all();
  * })
  * </code>
  *
  * @param $key
  * @param null $function
  * @return mixed|null
  */
 public static function get($key, $function = null)
 {
     if (!self::contains($key) && $function) {
         self::put($key, call_user_func($function));
     }
     return Arrays::getValue(self::$_cache, $key);
 }

 private static function newRelation($name, $localKey, $foreignKey, $collection, $params)
 {
     $class = $params['class'];
     $condition = Arrays::getValue($params, 'conditions', '');
     $order = Arrays::getValue($params, 'order', '');
     return new Relation($name, $class, $localKey, $foreignKey, $collection, $condition, $order);
 }

 public static function of(array $conditions)
 {
     if (Arrays::isAssociative($conditions)) {
         return new ArrayWhereClause($conditions, 'OR');
     }
     return new OrClause($conditions);
 }

 public function matches($argument)
 {
     if (get_class($this->expected) !== get_class($argument)) {
         return false;
     }
     $actualAttributes = Arrays::filterByAllowedKeys($argument->attributes(), $this->expected->getFields());
     return $this->expectedAttributes == $actualAttributes;
 }

 public function getRelation($name)
 {
     $value = Arrays::getValue($this->relations, $name);
     if (is_null($value)) {
         throw new Exception("Relation not found");
     }
     return $value;
 }

 private function _prepareParameters($uri)
 {
     preg_match_all('#:(\\w+)#', $uri, $matches);
     $parameters = Arrays::getValue($matches, 1, array());
     return Arrays::map($parameters, function ($parameter) {
         return '$' . $parameter;
     });
 }

 private function whereWithUsing()
 {
     $usingClauses = $this->_query->usingClauses;
     $whereClauses = Arrays::map($usingClauses, function (JoinClause $usingClause) {
         return WhereClause::create($usingClause->getJoinColumnWithTable() . ' = ' . $usingClause->getJoinedColumnWithTable());
     });
     return $this->_where(array_merge($whereClauses, $this->_query->whereClauses));
 }

 /**
  * Returns comparator which compares objects by using values computed using given expressions.
  * Expressions should comply with format accepted by <code>Functions::extractExpression</code>.
  * Comparator returns an integer less than, equal to, or greater than zero if the first argument is considered to be respectively less than, equal to, or greater than the second.
  *
  * @param mixed ...
  * @return callable
  */
 public static function compareBy()
 {
     $expressions = func_get_args();
     $comparators = Arrays::map($expressions, function ($expression) {
         return new EvaluatingComparator(Functions::extractExpression($expression));
     });
     return sizeof($comparators) == 1 ? $comparators[0] : new CompoundComparator($comparators);
 }

 public function contents()
 {
     $this->_setupTablePlaceholderReplacements();
     $this->classStub->addPlaceholderReplacement('class', $this->className);
     $this->classStub->addPlaceholderReplacement('namespace', $this->classNamespace);
     Arrays::map($this->tableInfo->tableColumns, array($this->classStub, 'addColumn'));
     return $this->classStub->contents();
 }

 public function __construct($httpCode, $errors, $headers = array())
 {
     $this->_httpCode = $httpCode;
     $this->_errors = Arrays::toArray($errors);
     $this->_headers = $headers;
     $firstError = Arrays::first($this->_errors);
     parent::__construct($firstError->getMessage(), $firstError->getCode());
 }

 private static function getViewPostfix($responseType)
 {
     $availableViewsMap = array('text/xml' => '.xml.phtml', 'application/json' => '.json.phtml', 'text/json' => '.json.phtml');
     $viewForType = Arrays::getValue($availableViewsMap, $responseType, false);
     if ($viewForType) {
         return $viewForType;
     }
     return Uri::isAjax() ? '.ajax.phtml' : '.phtml';
 }

 private static function extractParams($elements)
 {
     $params = array();
     foreach ($elements as $element) {
         list($name, $value) = Arrays::map(explode('=', $element), Functions::trim());
         $params[$name] = $value;
     }
     return $params;
 }