PHP Collection::filter方法代码示例

 /**
  * Get an attribute by name
  * @param string $name Attribute name
  * @return ConfigurationAttribute|null
  * @since 1.0
  */
 public function getAttribute($name, $returnValue = true)
 {
     $attribute = $this->attributes->filter(function ($attr) use($name) {
         /** @var ConfigurationAttribute $attr */
         return $attr->getName() == $name;
     })->first();
     return $returnValue && $attribute ? $attribute->getValue() : $attribute;
 }

 protected function filterColumns($filters)
 {
     foreach ($filters as $key => $filter) {
         $this->collection = $this->collection->filter(function ($row) use($key, $filter) {
             return strpos(Str::lower($row[$key]), Str::lower($filter)) !== false;
         });
     }
 }

 /**
  * @param Account    $account
  * @param Collection $startSet
  * @param Collection $endSet
  * @param Collection $backupSet
  *
  * @return Account
  */
 public static function reportFilter(Account $account, Collection $startSet, Collection $endSet, Collection $backupSet)
 {
     // The balance for today always incorporates transactions made on today. So to get todays "start" balance, we sub one day.
     $account->startBalance = '0';
     $account->endBalance = '0';
     $currentStart = $startSet->filter(function (Account $entry) use($account) {
         return $account->id == $entry->id;
     });
     $currentBackup = $backupSet->filter(function (Account $entry) use($account) {
         return $account->id == $entry->id;
     });
     // first try to set from backup
     if (!is_null($currentBackup->first())) {
         $account->startBalance = $currentBackup->first()->balance;
     }
     // overrule with data from start
     if (!is_null($currentStart->first())) {
         $account->startBalance = $currentStart->first()->balance;
     }
     $currentEnd = $endSet->filter(function (Account $entry) use($account) {
         return $account->id == $entry->id;
     });
     if (!is_null($currentEnd->first())) {
         $account->endBalance = $currentEnd->first()->balance;
     }
     return $account;
 }

 /**
  * Perform column search.
  *
  * @return void
  */
 public function columnSearch()
 {
     $columns = $this->request->get('columns');
     for ($i = 0, $c = count($columns); $i < $c; $i++) {
         if ($this->request->isColumnSearchable($i)) {
             $this->isFilterApplied = true;
             $regex = $this->request->isRegex($i);
             $column = $this->getColumnName($i);
             $keyword = $this->request->columnKeyword($i);
             $this->collection = $this->collection->filter(function ($row) use($column, $keyword, $regex) {
                 $data = $this->serialize($row);
                 $value = Arr::get($data, $column);
                 if ($this->isCaseInsensitive()) {
                     if ($regex) {
                         return preg_match('/' . $keyword . '/i', $value) == 1;
                     } else {
                         return strpos(Str::lower($value), Str::lower($keyword)) !== false;
                     }
                 } else {
                     if ($regex) {
                         return preg_match('/' . $keyword . '/', $value) == 1;
                     } else {
                         return strpos($value, $keyword) !== false;
                     }
                 }
             });
         }
     }
 }

 /**
  * @param $name
  * @return Collection
  */
 public function getGroup($name)
 {
     $group = $this->collection->filter(function ($widget) use($name) {
         return $widget->group == $name;
     });
     return $group->sortBy('order');
 }

 /**
  * @return Collection
  */
 public function generateMenu()
 {
     $menu = new Collection();
     if (!$this->auth->getUser()) {
         return $menu;
     }
     if (config('shapeshifter.menu')) {
         foreach (config('shapeshifter.menu') as $item) {
             $item = $this->parseItem($item);
             $menu->push($item);
         }
     } else {
         foreach ($this->modules->getOrdered() as $module) {
             $attributes = $module->json()->getAttributes();
             $item = $this->parseItem($attributes);
             $menu->push($item);
         }
     }
     return $menu->filter(function ($item) {
         return $this->hasAccessToRoute($item['route']);
     })->map(function ($item) {
         $item['children'] = array_filter($item['children'], function ($item) {
             return $this->hasAccessToRoute($item['route']);
         });
         return $item;
     })->filter(function ($item) {
         return $this->hasAccessToRoute('superuser') || count($item['children']) === 0 && $item['route'] !== null;
     });
 }

 /**
  * Apply given filters on media.
  *
  * @param \Illuminate\Support\Collection $media
  * @param array|callable                 $filter
  *
  * @return Collection
  */
 protected function applyFilterToMediaCollection(Collection $media, $filter) : Collection
 {
     if (is_array($filter)) {
         $filter = $this->getDefaultFilterFunction($filter);
     }
     return $media->filter($filter);
 }

 /**
  * Delete all elements which are all keys is null
  * 
  * @return void
  */
 private function cleanCollection()
 {
     $this->collection = $this->collection->filter(function (Element $item) {
         if (!$item->allKeyNull()) {
             return true;
         }
     });
 }

 /**
  * @param string $needleClass
  *
  * @return string|null
  */
 public function getTypeByClassName($needleClass)
 {
     $type = $this->types->filter(function (\KodiCMS\Widgets\Contracts\WidgetType $type) use($needleClass) {
         return $type->getClass() == $needleClass or $this->isCorrupt($type->getClass());
     })->first();
     if ($type) {
         return $type->getType();
     }
 }

 /**
  * Return a Collection of all Commands that have not running the undo action
  * @return static
  */
 protected function getNotUndoRunningCommandCollection()
 {
     return $this->commands->filter(function ($item) {
         $value = $item->isUndoRun();
         if ($value === false) {
             return $item;
         }
     });
 }

 /**
  * Show the application welcome screen to the user.
  *
  * @return mixed
  */
 public function index()
 {
     $name = app('orchestra.app')->installed() ? 'welcome' : 'hello';
     $packages = new Collection(config('website.packages', []));
     $components = $packages->filter(function ($package) {
         return in_array('component', $package['type']);
     });
     return view($name, compact('packages', 'components'));
 }

 /**
  * Activate a boolean property for the given fields.
  * @param $property string fillable|guarded|in_table, etc
  * @param $arguments array|string - * if all fields
  * @return $this
  */
 protected function updateFieldProperty($property, $arguments)
 {
     $fields = $arguments == "*" ? $this->fields : $this->fields->filter(function (FieldBlueprint $field) use($arguments) {
         return in_array($field->getName(), $arguments);
     });
     $fields->each(function (FieldBlueprint $field) use($property) {
         $field->setProperty($property, true);
     });
     return $this;
 }

 protected function directoriesUsedByBackupJob() : array
 {
     return $this->backupDestinations->filter(function (BackupDestination $backupDestination) {
         return $backupDestination->filesystemType() === 'local';
     })->map(function (BackupDestination $backupDestination) {
         return $backupDestination->disk()->getDriver()->getAdapter()->applyPathPrefix('');
     })->each(function (string $localDiskRootDirectory) {
         $this->fileSelection->excludeFilesFrom($localDiskRootDirectory);
     })->push($this->temporaryDirectory->path())->toArray();
 }

 /**
  * Search for any prefixes attached to this route.
  *
  * @return string
  */
 protected function getPrefixes()
 {
     $router = app(\Illuminate\Routing\Router::class);
     $this->prefixes = collect(explode('/', $router->getCurrentRoute()->getPrefix()));
     // Remove the last prefix if it matches the controller.
     $this->prefixes = $this->removeControllerFromPrefixes($this->prefixes);
     if ($this->prefixes->count() > 0) {
         $this->prefix = $this->prefixes->filter()->implode('.');
     }
 }

 private function doInternalSearch(Collection $columns, array $searchColumns)
 {
     if (is_null($this->search) or empty($this->search)) {
         return;
     }
     $value = $this->search;
     $caseSensitive = $this->options['caseSensitive'];
     $toSearch = array();
     // Map the searchColumns to the real columns
     $ii = 0;
     foreach ($columns as $i => $col) {
         if (in_array($columns->get($i)->getName(), $searchColumns)) {
             $toSearch[] = $ii;
         }
         $ii++;
     }
     $self = $this;
     $this->workingCollection = $this->workingCollection->filter(function ($row) use($value, $toSearch, $caseSensitive, $self) {
         for ($i = 0; $i < count($row); $i++) {
             if (!in_array($i, $toSearch)) {
                 continue;
             }
             $column = $i;
             if ($self->getAliasMapping()) {
                 $column = $self->getNameByIndex($i);
             }
             if ($self->getOption('stripSearch')) {
                 $search = strip_tags($row[$column]);
             } else {
                 $search = $row[$column];
             }
             if ($caseSensitive) {
                 if ($self->exactWordSearch) {
                     if ($value === $search) {
                         return true;
                     }
                 } else {
                     if (str_contains($search, $value)) {
                         return true;
                     }
                 }
             } else {
                 if ($self->getExactWordSearch()) {
                     if (strtolower($value) === strtolower($search)) {
                         return true;
                     }
                 } else {
                     if (str_contains(strtolower($search), strtolower($value))) {
                         return true;
                     }
                 }
             }
         }
     });
 }