Eloquent: Collections

All collections also serve as iterators, allowing you to loop over them as if they were simple PHP arrays:

However, as previously mentioned, collections are much more powerful than arrays and expose a variety of map / reduce operations that may be chained using an intuitive interface. For example, we may remove all inactive models and then gather the first name for each remaining user:

  1. $names = User::all()->reject(function (User $user) {    return $user->active === false;})->map(function (User $user) {    return $user->name;});

Eloquent Collection Conversion

While most Eloquent collection methods return a new instance of an Eloquent collection, the collapse, flatten, flip, keys, pluck, and zip methods return a instance. Likewise, if a map operation returns a collection that does not contain any Eloquent models, it will be converted to a base collection instance.

All Eloquent collections extend the base object; therefore, they inherit all of the powerful methods provided by the base collection class.

In addition, the Illuminate\Database\Eloquent\Collection class provides a superset of methods to aid with managing your model collections. Most methods return Illuminate\Database\Eloquent\Collection instances; however, some methods, like modelKeys, return an instance.

append diff find intersect loadMissing makeVisible only setHidden unique

append($attributes)

The append method may be used to indicate that an attribute should be appended for every model in the collection. This method accepts an array of attributes or a single attribute:

    contains($key, $operator = null, $value = null)

    1. $users->contains(1); $users->contains(User::find(1));

    diff($items)

    The diff method returns all of the models that are not present in the given collection:

    1. use App\Models\User; $users = $users->diff(User::whereIn('id', [1, 2, 3])->get());

    except($keys)

    The except method returns all of the models that do not have the given primary keys:

    1. $users = $users->except([1, 2, 3]);

    find($key)

    The find method returns the model that has a primary key matching the given key. If $key is a model instance, find will attempt to return a model matching the primary key. If $key is an array of keys, find will return all models which have a primary key in the given array:

    fresh($with = [])

    The fresh method retrieves a fresh instance of each model in the collection from the database. In addition, any specified relationships will be eager loaded:

    1. $users = $users->fresh(); $users = $users->fresh('comments');

    intersect($items)

    The intersect method returns all of the models that are also present in the given collection:

    1. use App\Models\User; $users = $users->intersect(User::whereIn('id', [1, 2, 3])->get());

    load($relations)

    The load method eager loads the given relationships for all models in the collection:

    1. $users->load(['comments', 'posts']); $users->load('comments.author'); $users->load(['comments', 'posts' => fn ($query) => $query->where('active', 1)]);

    loadMissing($relations)

    The loadMissing method eager loads the given relationships for all models in the collection if the relationships are not already loaded:

    modelKeys()

    1. $users->modelKeys(); // [1, 2, 3, 4, 5]

    makeVisible($attributes)

    The makeVisible method that are typically “hidden” on each model in the collection:

    makeHidden($attributes)

    The makeHidden method that are typically “visible” on each model in the collection:

    1. $users = $users->makeHidden(['address', 'phone_number']);

    only($keys)

    The only method returns all of the models that have the given primary keys:

    1. $users = $users->only([1, 2, 3]);

    setVisible($attributes)

    The setVisible method temporarily overrides all of the visible attributes on each model in the collection:

    1. $users = $users->setVisible(['id', 'name']);

    setHidden($attributes)

    The setHidden method temporarily overrides all of the hidden attributes on each model in the collection:

    1. $users = $users->setHidden(['email', 'password', 'remember_token']);

    toQuery()

    The toQuery method returns an Eloquent query builder instance containing a whereIn constraint on the collection model’s primary keys:

      unique($key = null, $strict = false)

      The unique method returns all of the unique models in the collection. Any models of the same type with the same primary key as another model in the collection are removed:

      1. <?php namespace App\Models; use App\Support\UserCollection;use Illuminate\Database\Eloquent\Collection;use Illuminate\Database\Eloquent\Model; class User extends Model{    /**     * Create a new Eloquent Collection instance.     *     * @param  array<int, \Illuminate\Database\Eloquent\Model>  $models     * @return \Illuminate\Database\Eloquent\Collection<int, \Illuminate\Database\Eloquent\Model>     */    public function newCollection(array $models = []): Collection    {        return new UserCollection($models);    }}

      Once you have defined a newCollection method, you will receive an instance of your custom collection anytime Eloquent would normally return an Illuminate\Database\Eloquent\Collection instance. If you would like to use a custom collection for every model in your application, you should define the newCollection method on a base model class that is extended by all of your application’s models.