PHP Collection::each方法代码示例

 public function getInitial()
 {
     $words = new Collection(explode(' ', $this->name));
     // if name contains single word, use first N character
     if ($words->count() === 1) {
         if ($this->name->length() >= $this->length) {
             return $this->name->substr(0, $this->length);
         }
         return (string) $words->first();
     }
     // otherwise, use initial char from each word
     $initials = new Collection();
     $words->each(function ($word) use($initials) {
         $initials->push(Stringy::create($word)->substr(0, 1));
     });
     return $initials->slice(0, $this->length)->implode('');
 }

 /**
  * На самом деле тут у меня фантация играет по полной, поймать мошеника это круто
  * можно было реализовать из hidden risk некую битовую маску и по ней уже обсчитывать мошеников
  * @param Collection $leaders
  * @param []Collection $prevLeaders
  * @return []Collection
  */
 public function __invoke(Collection $leaders, array $prevLeaders)
 {
     $leaders->each(function ($value) use($prevLeaders) {
         $id = object_get($value, 'id', null);
         $score = object_get($value, 'score', null);
         // Идем по списку лидеров
         foreach ($prevLeaders as $leaders) {
             $leaders->each(function ($leader) use($id, $score) {
                 // Если личдер найден
                 if ($leader->id === $id) {
                     // И он есть в  hidden risk
                     if (isset($this->hidRisk[$id])) {
                         // Удаляем его
                         unset($this->hidRisk[$id]);
                     }
                     // Если сейчас у него очков больше чем в прошлый раз
                     if ($leader->score < $score / static::RISK_GROWTH_SCOPE) {
                         $this->result[$id] = $leader;
                     } else {
                         $this->hidRisk[$id] = $leader;
                     }
                 }
             });
         }
         if (isset($this->hidRisk[$id])) {
             $this->result[$id] = $value;
         }
     });
     return $this->result;
 }

 /**
  * Start the site Scraping process.
  *
  * @return void
  */
 public function scrape()
 {
     $scrape = new Scrape(new Client());
     $this->list->each(function ($url) use($scrape) {
         $this->writePage($url, $scrape->run($url));
     });
 }

 /**
  * Set up test environment.
  */
 public function setUp()
 {
     parent::setUp();
     $this->company = factory(Company::class)->create();
     $this->users = factory(User::class, 5)->create(['company_id' => $this->company->id]);
     $this->users->each(function ($user) {
         factory(Task::class, 5)->create(['user_id' => $user->id]);
     });
 }

 public function tearDown()
 {
     $this->filesCreated->each(function ($file) {
         try {
             unlink($file);
         } catch (Exception $e) {
         }
     });
     parent::tearDown();
 }

 /**
  * @return void
  */
 public function placeWidgetsToLayoutBlocks()
 {
     $this->sortWidgets();
     $this->registeredWidgets->each(function (WidgetCollectionItem $widget) {
         if (method_exists($widget->getObject(), 'onLoad')) {
             app()->call([$widget->getObject(), 'onLoad']);
         }
     })->each(function (WidgetCollectionItem $widget) {
         if (method_exists($widget->getObject(), 'afterLoad')) {
             app()->call([$widget->getObject(), 'afterLoad']);
         }
     });
 }

 /**
  * @param \Illuminate\Support\Collection $files
  * @return string
  */
 public function compileLess($files)
 {
     $files->each(function ($value) {
         $this->less->parseFile($value);
     });
     return $this->less->getCss();
 }

 protected function cleanUp(Collection $cleanableModels)
 {
     $cleanableModels->each(function (string $modelClass) {
         $numberOfDeletedRecords = $modelClass::cleanUp($modelClass::query())->delete();
         event(new ModelWasCleanedUp($modelClass, $numberOfDeletedRecords));
         $this->info("Deleted {$numberOfDeletedRecords} record(s) from {$modelClass}.");
     });
 }

 /**
  * Execute the job.
  *
  * @return Collection
  */
 public function handle()
 {
     for ($i = 1; $i <= $this->amount; $i++) {
         $this->codes->push($this->generateCode());
     }
     $this->checkDatabase();
     /** @var \Illuminate\Database\Eloquent\Collection $products */
     $products = collect();
     /**
      * Now it is safe to add to the DB
      */
     $this->codes->each(function ($code) use($products) {
         $products->push(new Code(compact('code')));
     });
     $this->product->codes()->saveMany($products);
     return $products;
 }

 /**
  * Get the array representation of attributes
  * @return array Assoc array with attribute name in the key
  * @since 1.0
  */
 public function toArray()
 {
     $returnArr = [];
     $this->attributes->each(function ($attribute) use(&$returnArr) {
         /* @var ConfigurationAttribute $attribute **/
         $returnArr[$attribute->getName()] = $attribute->getValue();
     });
     return $returnArr;
 }

 public function run()
 {
     $this->backupDestinations->each(function (BackupDestination $backupDestination) {
         try {
             if (!$backupDestination->isReachable()) {
                 throw new Exception("Could not connect to disk {$backupDestination->diskName()} because: {$backupDestination->connectionError()}");
             }
             consoleOutput()->info("Cleaning backups of {$backupDestination->backupName()} on disk {$backupDestination->diskName()}...");
             $this->strategy->deleteOldBackups($backupDestination->backups());
             event(new CleanupWasSuccessful($backupDestination));
             $usedStorage = Format::humanReadableSize($backupDestination->usedStorage());
             consoleOutput()->info("Used storage after cleanup: {$usedStorage}.");
         } catch (Exception $exception) {
             consoleOutput()->error("Cleanup failed because: {$exception->getMessage()}.");
             event(new CleanupHasFailed($exception));
         }
     });
 }

 /**
  * @param Collection $leaders
  * @param []Collection $prevLeaders Массив ранее собраных списков
  * @return array
  */
 public function __invoke(Collection $leaders, array $prevLeaders)
 {
     $leaders->each(function ($value) use($prevLeaders) {
         $id = object_get($value, 'id', null);
         $place = object_get($value, 'place', null);
         $this->result[$id] = 0;
         foreach ($prevLeaders as $leaders) {
             $leaders->each(function ($value) use($id, $place) {
                 if ($value->id === $id) {
                     if ($value->place !== $place) {
                         $this->result[$id]++;
                     }
                 }
             });
         }
     });
     return $this->result;
 }

 public function saveChannels(Collection $data)
 {
     $data->each(function ($item, $key) {
         $item->persist();
         $game = $this->game->get($item->relatedGame);
         if (!is_null($game)) {
             $item->relatesToGame($game);
         }
     });
 }

 /**
  * Send the notification to devices.
  * Returns errors (APNs and GCM) and updated token (GCM).
  *
  * @return array [ 'errors': [ Device, ... ], 'updates' => [ [ 'device' => Device, 'token' => 'a-new-token' ], ... ] ]
  */
 public function send()
 {
     $apns = new Collection();
     $gcm = new Collection();
     $this->devices->each(function (Device $device) use(&$apns, &$gcm) {
         if ($device->isApns()) {
             $apns->push($this->merge($device));
         } elseif ($device->isGcm()) {
             $gcm->push($this->merge($device));
         }
     });
     $results = ['errors' => [], 'updates' => []];
     $this->mergeResults($results, $this->pushApns($apns));
     $this->mergeResults($results, $this->pushGcm($gcm));
     // Reset
     $apns = null;
     $gcm = null;
     $this->device = new Collection();
     return $results;
 }

 protected function removeBackupsForAllPeriodsExceptOne(Collection $backupsPerPeriod)
 {
     $backupsPerPeriod->each(function (Collection $groupedBackupsByDateProperty, string $periodName) {
         $groupedBackupsByDateProperty->each(function (Collection $group) {
             $group->shift();
             $group->each(function (Backup $backup) {
                 $backup->delete();
             });
         });
     });
 }