PHP Collection::macro方法代码示例

 /**
  * Register bindings in the container.
  */
 public function register()
 {
     Collection::macro('clean', function ($class = null) {
         return $this->map(function ($item) use($class) {
             return $item->clean($class);
         });
     });
     $this->registerCommands();
 }

 /**
  * Register the service provider.
  *
  * @return void
  */
 public function register()
 {
     Collection::macro('pipe', function ($callback) {
         return $callback($this);
     });
     Collection::macro('dd', function () {
         dd($this);
     });
     Collection::macro('clear', function () {
         return [];
     });
     Collection::macro('recollect', function ($items) {
         return collect($items);
     });
 }

 public function boot()
 {
     Collection::macro('associate', function ($key = null, $value = null) {
         return $this->reduce(function ($items, $values) use($key, $value) {
             $values = collect($values);
             list($key, $value) = is_null($key) ? $values->take(2)->values()->toArray() : [$values->get($key), $values->get($value)];
             return $items->put($key, $value);
         }, new static());
     });
     Collection::macro('fail', function ($rules = []) {
         return $this->filter(function ($item) use($rules) {
             return validator()->make($item, $rules)->fails();
         });
     });
     Collection::macro('ifAny', function ($callback) {
         if (!$this->isEmpty()) {
             return $callback($this);
         }
         return $this;
     });
     Collection::macro('ifEmpty', function ($callback) {
         if ($this->isEmpty()) {
             return $callback($this);
         }
         return $this;
     });
     Collection::macro('pass', function ($rules = []) {
         return $this->filter(function ($item) use($rules) {
             return validator()->make($item, $rules)->passes();
         });
     });
     Collection::macro('then', function ($callback) {
         return $callback($this);
     });
     Collection::macro('transpose', function () {
         $items = array_map(function (...$items) {
             return $items;
         }, ...$this->values());
         return new static($items);
     });
     Collection::macro('validate', function ($rules = []) {
         return $this->each(function ($item) use($rules) {
             if (validator()->make($item, $rules)->fails()) {
                 throw new ValidationException($this);
             }
         });
     });
 }

 public function testMacroable()
 {
     // Foo() macro : unique values starting with A
     Collection::macro('foo', function () {
         return $this->filter(function ($item) {
             return strpos($item, 'a') === 0;
         })->unique()->values();
     });
     $c = new Collection(['a', 'a', 'aa', 'aaa', 'bar']);
     $this->assertSame(['a', 'aa', 'aaa'], $c->foo()->all());
 }

 /**
  * Register pagination macro.
  *
  * @return void
  */
 protected function registerMacro()
 {
     $name = $this->app['config']->get('lighthouse.pagination_macro') ?: 'toConnection';
     $decodeCursor = function (array $args) {
         return $this->decodeCursor($args);
     };
     Collection::macro($name, function (array $args) use($decodeCursor) {
         $first = isset($args['first']) ? $args['first'] : 15;
         $after = $decodeCursor($args);
         $currentPage = $first && $after ? floor(($first + $after) / $first) : 1;
         return new LengthAwarePaginator(collect($this->items)->forPage($currentPage, $first), count($this->items), $first, $currentPage);
     });
     Collection::macro('fetch', function ($relations) {
         if (count($this->items) > 0) {
             if (is_string($relations)) {
                 $relations = [$relations];
             }
             $query = $this->first()->newQuery()->with($relations);
             $this->items = app(QueryBuilder::class)->eagerLoadRelations($query, $this->items);
         }
         return $this;
     });
 }

     */
    Collection::macro('transpose', function () : Collection {
        $values = $this->values();
        $expectedLength = count($this->first());
        $diffLength = count(array_intersect_key(...$values));
        if ($expectedLength !== $diffLength) {
            throw new \LengthException("Element's length must be equal.");
        }
        $items = array_map(function (...$items) {
            return new static($items);
        }, ...$values);
        return new static($items);
    });
}
if (!Collection::hasMacro('partition')) {
    /*
     * Output a collection with two elements. Items in the first element did pass
     * the given $callback, items in the second element did not.
     *
     * @param callable $callback
     *
     * @return \Illuminate\Support\Collection
     */
    Collection::macro('partition', function (callable $callback) : Collection {
        $partitions = [new static(), new static()];
        foreach ($this->items as $item) {
            $partitions[!(int) $callback($item)][] = $item;
        }
        return new static($partitions);
    });
}

    });
}
if (!Collection::hasMacro('toEloquent')) {
    /**
     * Get a Database Eloquent collection instance from this collection.
     * Filters out any items that are not Models.
     *
     * @return \Illuminate\Database\Eloquent\Collection
     */
    Collection::macro('toEloquent', function () {
        return EloquentCollection::make($this->filter(function ($item) {
            return $item instanceof Model;
        })->all());
    });
}
if (!Collection::hasMacro('transpose')) {
    /**
     * Transpose a collection. Rows become columns, columns become rows.
     * E.g.     becomes
     *  [1,2]    [1,3]
     *  [3,4]    [2,4]
     *
     * @return \Illuminate\Support\Collection
     */
    Collection::macro('transpose', function () {
        $type = get_class($this);
        return $type::make(array_map(function (...$items) {
            return $items;
        }, ...$this->values()));
    });
}