PHP Collection::transform方法代码示例

 /**
  * @param array|Arrayable $data
  * @return $this
  */
 public function fill($data)
 {
     $this->data = new Collection($data);
     $this->data->transform(function ($record) {
         return $record instanceof Arrayable ? $record->toArray() : $record;
     });
     return $this;
 }

 /**
  * Get the fields of the type.
  *
  * @return array
  */
 public function getFields()
 {
     $collection = new Collection($this->fields());
     return $collection->transform(function ($field, $name) {
         if (is_string($field)) {
             $field = app($field);
             $field->name = $name;
             return $field->toArray();
         } else {
             $resolver = $this->getFieldResolver($name, $field);
             if ($resolver) {
                 $field['resolve'] = $resolver;
             }
             return $field;
         }
     })->toArray();
 }

 public function testTransform()
 {
     $data = new Collection(['first' => 'taylor', 'last' => 'otwell']);
     $data->transform(function ($item, $key) {
         return $key . '-' . strrev($item);
     });
     $this->assertEquals(['first' => 'first-rolyat', 'last' => 'last-llewto'], $data->all());
 }

 /**
  * @param Collection $data
  * @return mixed
  */
 private function formatData(Collection $data)
 {
     return $data->transform(function ($item) {
         return $this->data_provider->transform($item);
     });
 }

 /**
  * Generate a unique suffix for the given slug (and list of existing, "similar" slugs.
  *
  * @param string $slug
  * @param string $separator
  * @param \Illuminate\Support\Collection $list
  * @return string
  */
 protected function generateSuffix($slug, $separator, Collection $list)
 {
     $len = strlen($slug . $separator);
     // If the slug already exists, but belongs to
     // our model, return the current suffix.
     if ($list->search($slug) === $this->model->getKey()) {
         $suffix = explode($separator, $slug);
         return end($suffix);
     }
     $list->transform(function ($value, $key) use($len) {
         return intval(substr($value, $len));
     });
     // find the highest value and return one greater.
     return $list->max() + 1;
 }

 protected function transformAnnotationAddon(Collection $collection)
 {
     return $collection->transform(function ($item, $class) {
         return "{$item['name']}({$class}::class)";
     })->implode("\n");
 }

 /**
  * Generate type from collection of fields.
  *
  * @param  Collection $fields
  * @param  array     $options
  * @return \GraphQL\Type\Definition\ObjectType
  */
 public function generateType(Collection $fields, $options = [])
 {
     $typeFields = $fields->transform(function ($field) {
         if (is_string($field)) {
             return app($field)->toArray();
         }
         return $field;
     })->toArray();
     return new ObjectType(array_merge(['fields' => $typeFields], $options));
 }

 /**
  * Create new tags from a string "group:tag_name" and fetch tag from a tag id.
  *
  * @param array $tags
  * @param bool  $isAdmin
  *
  * @return Collection
  */
 protected function createTags(array $tags, $isAdmin = false)
 {
     $newTags = new Collection($tags);
     // Transform the user input tags into tag objects
     $newTags->transform(function ($tagNameOrId) use($isAdmin) {
         if (strpos($tagNameOrId, ':') !== false && $isAdmin) {
             return (new Tag())->createTagFromString($tagNameOrId);
         } else {
             return Tag::find($tagNameOrId);
         }
     });
     // Filter out invalid tags entered by the user
     $newTags = $newTags->filter(function ($tag) {
         return $tag instanceof Tag;
     });
     return $newTags;
 }

 public function createImageDerivatives(Collection $collection)
 {
     $collection->transform(function ($item, $key) {
         $image_styles = collect($this->getImageStyles());
         $image_derivatives = collect($this->getImageDerivatives());
         $fields = $image_derivatives->keys()->intersect($item->attributeKeys());
         foreach ($fields->all() as $field) {
             $styles = collect($image_derivatives->get($field))->intersect($image_styles->keys());
             foreach ($styles->all() as $style) {
                 // Create image derivative and add it to $item.
                 if ($new_image = $this->generateImageDerivative($item->{$field}, $style)) {
                     // We have to deal with the attribute indirectly
                     // because it is an overloaded property.
                     if ($item->hasAttribute('image_derivatives')) {
                         $item_image_derivatives = (array) $item->image_derivatives;
                     } else {
                         $item_image_derivatives = [];
                     }
                     $item_image_derivatives[$style] = $new_image;
                     $item->image_derivatives = $item_image_derivatives;
                 }
             }
         }
         return $item;
     });
 }