Collections in Laravel 9

Wednesday, 12/04/2023

Tram Ho

In today’s Laravel Certification exam review series, I would like to introduce collections, the purpose of which is to note down the knowledge for myself and you to follow the article with a “detailed” document.

Start!

I. Collections Overview

Collection in Laravel is a powerful and flexible data structure that allows you to work with a collection of elements in various forms. Collection provides you with methods to filter, sort, transform, and manipulate the data in that collection.

Collection is designed to work efficiently with PHP databases and functions. It can be used to process data returned from database queries, or to filter, sort, and display complex collections.

Some of the Collection features in Laravel include:

Methods to filter and sort the elements in the collection based on different conditions.
Methods to transform data in a collection by adding or removing elements.
Methods to perform operations like map, reduce, and filter on the collection.
The ability to combine collections together to create new collections.
Methods to handle collection elements in a flexible way.
Ability to use collections with Eloquent to query and sort data in the database.

With Collection, you can perform complex operations on a collection of elements easily and efficiently, saving you time and increasing the performance of your Laravel application.

II. Collections functions in Laravel 9

In summary, there are nearly 70 collections functions in Laravel and I would like to explain each function in detail. This post can be quite long, but it contains a lot of information

I will apply this collect pattern, please remember to the end of the article.

collect(['Vietnam', 'Japan', 'Korea', 'Thailand']);
1
2
collect(['Vietnam', 'Japan', 'Korea', 'Thailand']);

1. Add elements in collections

Add an element to the collection:

push($value) : Add an element to the end of the collection (1 element or an array of elements).

Ví dụ: `dd($countries-&gt;push("American"))` hoặc `dd($countries-&gt;push(["American"]))`

   =&gt; Kết quả lần lượt là :

Ví dụ: `dd($countries->push("American"))` hoặc `dd($countries->push(["American"]))`

=> Kết quả lần lượt là :

and

put($key, $value) : Add or update an element or an array with the corresponding key in the collection. If $key already exists, put will overwrite the new value ; otherwise, it will add the corresponding key and value .Example: dd($countries->put(2, "American"))

     Ví dụ: `dd($countries-&gt;put(6, "American"))`

1 2	Ví dụ: `dd($countries->put(6, "American"))`

prepend($value) : Add an element to the beginning of the collection.Example: dd($countries->prepend(2, "American"))

2. Delete an element in the collection

forget($key) : Remove the element with the corresponding key from the collection, if the key is not there, nothing will happen.Example: dd($countries->forget(1))
pull($key, $default = null) : Removes the element with the corresponding key from the collection and returns the value of that element, if the key does not exist, returns null . Suppose we set the variable $default = "ahihihi" then display ahihihi instead of null
pop() : Removes the last element from the collection and returns its value.
reject($callback) : Removes all elements in the collection that do not satisfy the callback function’s condition. (This is also a method to filter elements that do not satisfy the condition of the callback function in the collection, but if someone asks you to list some methods to delete, this method also satisfies the condition, obviously it deletes that)For example:

        $countries = $countries-&gt;reject(function($var) {
                return in_array($var, ['Vietnam', 'Japan']);
        });

$countries = $countries->reject(function($var) {

return in_array($var, ['Vietnam', 'Japan']);

});

3. Editing an element in a collection

transform($key) : Apply a callback function to each element of the collection and overwrite the old values with the new values.

For example

    $test = $countries-&gt;transform(function($country) {
        if (in_array($country, ["Vietnam", "Japan"])) {
            return $country . "ese";
        } else {
            return $country;
        }
    });

    dd($test, $countries);

$test = $countries->transform(function($country) {

if (in_array($country, ["Vietnam", "Japan"])) {

return $country . "ese";

} else {

return $country;

}

});

dd($test, $countries);

map($callback) : Creates a new collection by applying a callback function to each element of the collection.

    $test = $countries-&gt;map(function($country) {
        if (in_array($country, ["Vietnam", "Japan"])) {
            return $country . "ese";
        } else {
            return $country;
        }
    });

    dd($test, $countries);

$test = $countries->map(function($country) {

if (in_array($country, ["Vietnam", "Japan"])) {

return $country . "ese";

} else {

return $country;

}

});

dd($test, $countries);

merge($items) : Creates a new collection by combining the current collection with another collection or an array.

For example we have the following:

      //Tạo thêm 1 collect mới
      $countries2 = collect(['American', 'HongKong', 'China', 'Lao']);
      $test = $countries-&gt;merge($countries2);
      dd($test, $countries);

//Tạo thêm 1 collect mới

$countries2 = collect(['American', 'HongKong', 'China', 'Lao']);

$test = $countries->merge($countries2);

dd($test, $countries);

replace($items) : Creates a new collection by replacing all elements in the collection with other elements provided in a new array or collection.

      //Tạo thêm 1 collect mới
      $countries2 = collect(['American', 'HongKong', 'China', 'Lao']);
      $test = $countries-&gt;replace($countries2);
      dd($test, $countries);

//Tạo thêm 1 collect mới

$countries2 = collect(['American', 'HongKong', 'China', 'Lao']);

$test = $countries->replace($countries2);

dd($test, $countries);

4. Sort the elements in the collection

sort() : Sorts a Collection in ascending order of the element’s value.

    $collection = collect([3, 2, 1, 5, 4]);
    $sorted = $collection-&gt;sort();
    // Kết quả: [1, 2, 3, 4, 5]

$collection = collect([3, 2, 1, 5, 4]);

$sorted = $collection->sort();

// Kết quả: [1, 2, 3, 4, 5]

sortBy($key) : Sorts a Collection using a key .

    $collection = collect([
        ['name' =&gt; 'John', 'age' =&gt; 22],
        ['name' =&gt; 'Bob', 'age' =&gt; 25],
        ['name' =&gt; 'Jane', 'age' =&gt; 20],
    ]);

    $sorted = $collection-&gt;sortBy('age');

    // Kết quả:
    /*
    collect([
        ['name' =&gt; 'Jane', 'age' =&gt; 20],
        ['name' =&gt; 'John', 'age' =&gt; 22],
        ['name' =&gt; 'Bob', 'age' =&gt; 25],
    ]);
    */

$collection = collect([

['name' => 'John', 'age' => 22],

['name' => 'Bob', 'age' => 25],

['name' => 'Jane', 'age' => 20],

]);

$sorted = $collection->sortBy('age');

// Kết quả:

collect([

['name' => 'Jane', 'age' => 20],

['name' => 'John', 'age' => 22],

['name' => 'Bob', 'age' => 25],

]);

sortByDesc($key) : Sorts a Collection in descending order using a key .

    $collection = collect([
        ['name' =&gt; 'John', 'age' =&gt; 22],
        ['name' =&gt; 'Bob', 'age' =&gt; 25],
        ['name' =&gt; 'Jane', 'age' =&gt; 20],
    ]);

    $sorted = $collection-&gt;sortByDesc('age');

    // Kết quả:
    /*
    collect([
        ['name' =&gt; 'Bob', 'age' =&gt; 25],
        ['name' =&gt; 'John', 'age' =&gt; 22],
        ['name' =&gt; 'Jane', 'age' =&gt; 20],
    ]);
    */

$collection = collect([

['name' => 'John', 'age' => 22],

['name' => 'Bob', 'age' => 25],

['name' => 'Jane', 'age' => 20],

]);

$sorted = $collection->sortByDesc('age');

// Kết quả:

collect([

['name' => 'Bob', 'age' => 25],

['name' => 'John', 'age' => 22],

['name' => 'Jane', 'age' => 20],

]);

sortKeys() : Sorts a Collection in ascending order of the key of the elements.

    $collection = collect([
        'product_3' =&gt; ['name' =&gt; 'Product 3', 'price' =&gt; 300],
        'product_1' =&gt; ['name' =&gt; 'Product 1', 'price' =&gt; 100],
        'product_2' =&gt; ['name' =&gt; 'Product 2', 'price' =&gt; 200],
    ]);

    $sorted = $collection-&gt;sortKeys();
    dd($sorted);

$collection = collect([

'product_3' => ['name' => 'Product 3', 'price' => 300],

'product_1' => ['name' => 'Product 1', 'price' => 100],

'product_2' => ['name' => 'Product 2', 'price' => 200],

]);

$sorted = $collection->sortKeys();

dd($sorted);

Result:

    collect([
        'product_1' =&gt; ['name' =&gt; 'Product 1', 'price' =&gt; 100],
        'product_2' =&gt; ['name' =&gt; 'Product 2', 'price' =&gt; 200],
        'product_3' =&gt; ['name' =&gt; 'Product 3', 'price' =&gt; 300],
    ]);

collect([

'product_1' => ['name' => 'Product 1', 'price' => 100],

'product_2' => ['name' => 'Product 2', 'price' => 200],

'product_3' => ['name' => 'Product 3', 'price' => 300],

]);

sortKeysDesc() : Sorts a Collection in descending order of the key of the elements.

    $data = collect([
        ['name' =&gt; 'Alice', 'age' =&gt; 25],
        ['name' =&gt; 'Bob', 'age' =&gt; 20],
        ['name' =&gt; 'Charlie', 'age' =&gt; 30]
    ]);
    
    $result = $data-&gt;sortKeysDesc();

    dd($result-&gt;all());

$data = collect([

['name' => 'Alice', 'age' => 25],

['name' => 'Bob', 'age' => 20],

['name' => 'Charlie', 'age' => 30]

]);

$result = $data->sortKeysDesc();

dd($result->all());

Result:

    [
        ['name' =&gt; 'Charlie', 'age' =&gt; 30],
        ['name' =&gt; 'Bob', 'age' =&gt; 20],
        ['name' =&gt; 'Alice', 'age' =&gt; 25]
    ]

[

['name' => 'Charlie', 'age' => 30],

['name' => 'Bob', 'age' => 20],

['name' => 'Alice', 'age' => 25]

]

5. Filter elements in the collection

filter($callback) : Filters the elements of the collection based on the condition specified in $callback and returns a new collection containing the filtered elements.

    $collection = collect([1, 2, 3, 4]);

    $filtered = $collection-&gt;filter(function ($value, $key) {
        return $value &gt; 2;
    });

    $filtered-&gt;all();
    
    // Kết quả
    // [3, 4]

$collection = collect([1, 2, 3, 4]);

$filtered = $collection->filter(function ($value, $key) {

return $value > 2;

});

$filtered->all();

// Kết quả

// [3, 4]

reject($callback) : Similar to the filter() method, but returns the elements that do not satisfy the condition.

    $collection = collect([1, 2, 3, 4]);

    $filtered = $collection-&gt;filter(function ($value, $key) {
        return $value &gt; 2;
    });

    $filtered-&gt;all();

    // Kết quả
    // [1, 2]

$collection = collect([1, 2, 3, 4]);

$filtered = $collection->filter(function ($value, $key) {

return $value > 2;

});

$filtered->all();

// Kết quả

// [1, 2]

where($key, $operator, $value = null) : Filters the elements of the collection based on the value of an attribute. $key is the property name, $operator is the comparison operator (eg =, >, <…), and $value is the value to compare. If there are only 2 parameters in function where => default operator is “=”

    $collection = collect([
        ['product' =&gt; 'Desk', 'price' =&gt; 200],
        ['product' =&gt; 'Chair', 'price' =&gt; 100],
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150],
        ['product' =&gt; 'Door', 'price' =&gt; 100],
    ]);

    $filtered = $collection-&gt;where('price', '&gt;', 100);

    dd($filtered-&gt;all());

$collection = collect([

['product' => 'Desk', 'price' => 200],

['product' => 'Chair', 'price' => 100],

['product' => 'Bookcase', 'price' => 150],

['product' => 'Door', 'price' => 100],

]);

$filtered = $collection->where('price', '>', 100);

dd($filtered->all());

Result:

    [
        ['product' =&gt; 'Desk', 'price' =&gt; 200],
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150]
    ]

[

['product' => 'Desk', 'price' => 200],

['product' => 'Bookcase', 'price' => 150]

]

whereStrict($key, $value) : Similar to the where() method, but compares the value of the attribute and $value by the exact comparison type (including data type). For example

    $products = collect([
        ['id' =&gt; 1, 'name' =&gt; 'Product A'],
        ['id' =&gt; '1', 'name' =&gt; 'Product B'],
        ['id' =&gt; 2, 'name' =&gt; 'Product C'],
    ]);

    $filtered = $products-&gt;whereStrict('id', 1);
    
    dd($filtered-&gt;all());

$products = collect([

['id' => 1, 'name' => 'Product A'],

['id' => '1', 'name' => 'Product B'],

['id' => 2, 'name' => 'Product C'],

]);

$filtered = $products->whereStrict('id', 1);

dd($filtered->all());

Result:

    [
        ['id' =&gt; 1, 'name' =&gt; 'Product A']
    ]

[

['id' => 1, 'name' => 'Product A']

]

whereIn($key, $values) : Filters elements with a value of the $key attribute in an array of $values.

    $collection = collect([
        ['product' =&gt; 'Desk', 'price' =&gt; 200],
        ['product' =&gt; 'Chair', 'price' =&gt; 100],
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150],
        ['product' =&gt; 'Door', 'price' =&gt; 100],
    ]);

    $filtered = $collection-&gt;whereIn('price', [150, 200]);

    dd($filtered-&gt;all());

$collection = collect([

['product' => 'Desk', 'price' => 200],

['product' => 'Chair', 'price' => 100],

['product' => 'Bookcase', 'price' => 150],

['product' => 'Door', 'price' => 100],

]);

$filtered = $collection->whereIn('price', [150, 200]);

dd($filtered->all());

Result:

    [
        ['product' =&gt; 'Desk', 'price' =&gt; 200],
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150],
    ]

[

['product' => 'Desk', 'price' => 200],

['product' => 'Bookcase', 'price' => 150],

]

whereInStrict($key, $values) : Similar to whereIn but will set additional data types. For example:

    $collection = collect([
        ['product' =&gt; 'Desk', 'price' =&gt; '200'],
        ['product' =&gt; 'Chair', 'price' =&gt; 100],
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150],
        ['product' =&gt; 'Door', 'price' =&gt; 100],
    ]);

    $filtered = $collection-&gt;whereInStrict('price', [150, 200]);

    $filtered-&gt;all();
    
    /* Kết quả
    [
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150],
    ]
    */

$collection = collect([

['product' => 'Desk', 'price' => '200'],

['product' => 'Chair', 'price' => 100],

['product' => 'Bookcase', 'price' => 150],

['product' => 'Door', 'price' => 100],

]);

$filtered = $collection->whereInStrict('price', [150, 200]);

$filtered->all();

/* Kết quả

[

['product' => 'Bookcase', 'price' => 150],

]

whereNotIn($key, $values) : Similar to whereIn() method, but filters elements that are not in the $values array.

    $collection = collect([
        ['product' =&gt; 'Desk', 'price' =&gt; 200],
        ['product' =&gt; 'Chair', 'price' =&gt; 100],
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150],
        ['product' =&gt; 'Door', 'price' =&gt; 100],
    ]);

    $filtered = $collection-&gt;whereNotIn('price', [150, 200]);

    dd($filtered-&gt;all());

$collection = collect([

['product' => 'Desk', 'price' => 200],

['product' => 'Chair', 'price' => 100],

['product' => 'Bookcase', 'price' => 150],

['product' => 'Door', 'price' => 100],

]);

$filtered = $collection->whereNotIn('price', [150, 200]);

dd($filtered->all());

Result:

    [
        ['product' =&gt; 'Chair', 'price' =&gt; 100],
        ['product' =&gt; 'Door', 'price' =&gt; 100],
    ]

[

['product' => 'Chair', 'price' => 100],

['product' => 'Door', 'price' => 100],

]

whereNotInStrict($key, $values) : Similar to the whereNotIn() method, but filters elements that are not in the $values array.

    $collection = collect([
        ['product' =&gt; 'Desk', 'price' =&gt; '200'],
        ['product' =&gt; 'Chair', 'price' =&gt; 100],
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150],
        ['product' =&gt; 'Door', 'price' =&gt; 100],
    ]);

    $filtered = $collection-&gt;whereNotIn('price', [150, 200]);

    dd($filtered-&gt;all());

$collection = collect([

['product' => 'Desk', 'price' => '200'],

['product' => 'Chair', 'price' => 100],

['product' => 'Bookcase', 'price' => 150],

['product' => 'Door', 'price' => 100],

]);

$filtered = $collection->whereNotIn('price', [150, 200]);

dd($filtered->all());

Result:

    [
        ['product' =&gt; 'Desk', 'price' =&gt; '200'],
        ['product' =&gt; 'Chair', 'price' =&gt; 100],
        ['product' =&gt; 'Door', 'price' =&gt; 100]
    ]

[

['product' => 'Desk', 'price' => '200'],

['product' => 'Chair', 'price' => 100],

['product' => 'Door', 'price' => 100]

]

whereBetween($key, $values) : Filters elements where the value of the $key attribute ranges from $values[0] to $values[1].

For example :

    $collection = collect([
        ['product' =&gt; 'Desk', 'price' =&gt; 200],
        ['product' =&gt; 'Chair', 'price' =&gt; 80],
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150],
        ['product' =&gt; 'Pencil', 'price' =&gt; 30],
        ['product' =&gt; 'Door', 'price' =&gt; 100],
    ]);

    $filtered = $collection-&gt;whereBetween('price', [100, 200]);

    dd($filtered-&gt;all());

$collection = collect([

['product' => 'Desk', 'price' => 200],

['product' => 'Chair', 'price' => 80],

['product' => 'Bookcase', 'price' => 150],

['product' => 'Pencil', 'price' => 30],

['product' => 'Door', 'price' => 100],

]);

$filtered = $collection->whereBetween('price', [100, 200]);

dd($filtered->all());

Result:

    [
        ['product' =&gt; 'Desk', 'price' =&gt; 200],
        ['product' =&gt; 'Bookcase', 'price' =&gt; 150],
        ['product' =&gt; 'Door', 'price' =&gt; 100]
    ]

[

['product' => 'Desk', 'price' => 200],

['product' => 'Bookcase', 'price' => 150],

['product' => 'Door', 'price' => 100]

]

whereNull($key) : Filters elements where the value of $key attribute is null .

    $collection = collect([
        ['name' =&gt; 'Desk'],
        ['name' =&gt; null],
        ['name' =&gt; 'Bookcase'],
    ]);
 
    $filtered = $collection-&gt;whereNull('name');

    dd($filtered-&gt;all());

$collection = collect([

['name' => 'Desk'],

['name' => null],

['name' => 'Bookcase'],

]);

$filtered = $collection->whereNull('name');

dd($filtered->all());

Result:

    [
        ['name' =&gt; null],
    ]

[

['name' => null],

]

whereNotNull($key) : Filters elements whose value of the $key attribute is null .

    $collection = collect([
        ['name' =&gt; 'Desk'],
        ['name' =&gt; null],
        ['name' =&gt; 'Bookcase'],
    ]);
 
    $filtered = $collection-&gt;whereNull('name');
 
    dd($filtered-&gt;all());

$collection = collect([

['name' => 'Desk'],

['name' => null],

['name' => 'Bookcase'],

]);

$filtered = $collection->whereNull('name');

dd($filtered->all());

Result:

    [
        ['name' =&gt; 'Desk'],
        ['name' =&gt; 'Bookcase']
    ]

[

['name' => 'Desk'],

['name' => 'Bookcase']

]

5. Collections support handling strings, arrays

join($glue, $finalGlue = null) : used to combine the elements of a collection into a single string, with the elements separated by a specified string.

In there :

$glue : is the string that separates the elements.
$finalGlue : is the string separating the last element and the preceding element. If you don’t want a string separator on the last element, the value of $finalGlue will be null.

For example:

    $collection = collect(['apple', 'banana', 'cherry']);

    $joined = $collection-&gt;join(', ', ' and ');

    // Kết quả: "apple, banana, and cherry"

$collection = collect(['apple', 'banana', 'cherry']);

$joined = $collection->join(', ', ' and ');

// Kết quả: "apple, banana, and cherry"

crossJoin(…$collections) : is a Collection method in Laravel, it is used to calculate all combinations of values in the provided collections.

For example :

    $colors = collect(['red', 'green']);
    $sizes = collect(['S', 'M', 'L']);
    $materials = collect(['cotton', 'polyester']);
    
    $combinations = $colors-&gt;crossJoin($sizes, $materials);

$colors = collect(['red', 'green']);

$sizes = collect(['S', 'M', 'L']);

$materials = collect(['cotton', 'polyester']);

$combinations = $colors->crossJoin($sizes, $materials);

Result:

    Collection [
      ["red", "S", "cotton"],
      ["red", "S", "polyester"],
      ["red", "M", "cotton"],
      ["red", "M", "polyester"],
      ["red", "L", "cotton"],
      ["red", "L", "polyester"],
      ["green", "S", "cotton"],
      ["green", "S", "polyester"],
      ["green", "M", "cotton"],
      ["green", "M", "polyester"],
      ["green", "L", "cotton"],
      ["green", "L", "polyester"],
    ]

Collection [

["red", "S", "cotton"],

["red", "S", "polyester"],

["red", "M", "cotton"],

["red", "M", "polyester"],

["red", "L", "cotton"],

["red", "L", "polyester"],

["green", "S", "cotton"],

["green", "S", "polyester"],

["green", "M", "cotton"],

["green", "M", "polyester"],

["green", "L", "cotton"],

["green", "L", "polyester"],

]

mapInto(string $class) : Apply a function to each element in the collection and return a new collection. In this case, we can use the map method to process the strings in the collection.

    $collection = collect([1, 2, 3, 4, 5]);

    $multiplied = $collection-&gt;map(function ($item, $key) {
        return $item * 2;
    });

    dd($multiplied-&gt;all());

    //Kết quả: [2, 4, 6, 8, 10]

$collection = collect([1, 2, 3, 4, 5]);

$multiplied = $collection->map(function ($item, $key) {

return $item * 2;

});

dd($multiplied->all());

//Kết quả: [2, 4, 6, 8, 10]

mapSpread($callback) : is a collection method in Laravel, used to transform elements in the Collection using a callback function, but with a different behavior than the map() and mapWithKeys() .

The difference of mapSpread() from map() and mapWithKeys() methods is the parameter passed to the callback function. Instead of passing a single value for each element in the Collection, mapSpread() will pass in multiple arguments corresponding to the values of each element in the Collection.

For example:

    $users = collect([    
        ['name' =&gt; 'John', 'age' =&gt; 25],
        ['name' =&gt; 'Mary', 'age' =&gt; 30],
        ['name' =&gt; 'Bob', 'age' =&gt; 35],
    ]);

    $users = $users-&gt;mapSpread(function ($name, $age) {
        return "{$name} is {$age} years old.";
    });
    $users-&gt;all();

    //Kết quả 
    [    
            [0] =&gt; John is 25 years old.
            [1] =&gt; Mary is 30 years old.
            [2] =&gt; Bob is 35 years old.
    ]

$users = collect([

['name' => 'John', 'age' => 25],

['name' => 'Mary', 'age' => 30],

['name' => 'Bob', 'age' => 35],

]);

$users = $users->mapSpread(function ($name, $age) {

return "{$name} is {$age} years old.";

});

$users->all();

//Kết quả

[

[0] => John is 25 years old.

[1] => Mary is 30 years old.

[2] => Bob is 35 years old.

]

mapToGroups($callback) in Laravel Collection is used to transform a Collection into an array grouped by a specific property.

For example:

    $students = collect([
        ['name' =&gt; 'John', 'gender' =&gt; 'male', 'class' =&gt; 'A'],
        ['name' =&gt; 'Jane', 'gender' =&gt; 'female', 'class' =&gt; 'A'],
        ['name' =&gt; 'Bob', 'gender' =&gt; 'male', 'class' =&gt; 'B'],
        ['name' =&gt; 'Alice', 'gender' =&gt; 'female', 'class' =&gt; 'B']
    ]);
    
    $studentsByClass = $students-&gt;mapToGroups(function ($item, $key) {
        return [$item['class'] =&gt; $item];
    });

    dd($studentsByClass-&gt;all());

$students = collect([

['name' => 'John', 'gender' => 'male', 'class' => 'A'],

['name' => 'Jane', 'gender' => 'female', 'class' => 'A'],

['name' => 'Bob', 'gender' => 'male', 'class' => 'B'],

['name' => 'Alice', 'gender' => 'female', 'class' => 'B']

]);

$studentsByClass = $students->mapToGroups(function ($item, $key) {

return [$item['class'] => $item];

});

dd($studentsByClass->all());

Result:

IlluminateSupportCollection {#1419 ▼
  #items: array:2 [▼
    "A" =&gt; IlluminateSupportCollection {#1331 ▼
      #items: array:2 [▼
        0 =&gt; array:3 [▼
          "name" =&gt; "John"
          "gender" =&gt; "male"
          "class" =&gt; "A"
        ]
        1 =&gt; array:3 [▼
          "name" =&gt; "Jane"
          "gender" =&gt; "female"
          "class" =&gt; "A"
        ]
      ]
    }
    "B" =&gt; IlluminateSupportCollection {#1330 ▼
      #items: array:2 [▼
        0 =&gt; array:3 [▼
          "name" =&gt; "Bob"
          "gender" =&gt; "male"
          "class" =&gt; "B"
        ]
        1 =&gt; array:3 [▼
          "name" =&gt; "Alice"
          "gender" =&gt; "female"
          "class" =&gt; "B"
        ]
      ]
    }
  ]
}

IlluminateSupportCollection {#1419 ▼

#items: array:2 [▼

"A" => IlluminateSupportCollection {#1331 ▼

#items: array:2 [▼

0 => array:3 [▼

"name" => "John"

"gender" => "male"

"class" => "A"

]

1 => array:3 [▼

"name" => "Jane"

"gender" => "female"

"class" => "A"

]

}

"B" => IlluminateSupportCollection {#1330 ▼

#items: array:2 [▼

0 => array:3 [▼

"name" => "Bob"

"gender" => "male"

"class" => "B"

]

1 => array:3 [▼

"name" => "Alice"

"gender" => "female"

"class" => "B"

]

}

]

}

mapWithKeys($callback) : in Laravel Collection allows to transform Collection values into a new key-value associative array. It uses a callback function to do this and returns a new Collection with the key-value pairs generated by the callback function.

For example :

    $products = collect([
        ['name' =&gt; 'Iphone 11', 'price' =&gt; 999],
        ['name' =&gt; 'Samsung Galaxy S10', 'price' =&gt; 899],
        ['name' =&gt; 'Google Pixel 4', 'price' =&gt; 799],
    ]);
    
    $newArray = $products-&gt;mapWithKeys(function ($item) {
        return [$item['name'] =&gt; $item['price']];
    });

$products = collect([

['name' => 'Iphone 11', 'price' => 999],

['name' => 'Samsung Galaxy S10', 'price' => 899],

['name' => 'Google Pixel 4', 'price' => 799],

]);

$newArray = $products->mapWithKeys(function ($item) {

return [$item['name'] => $item['price']];

});

Result:

IlluminateSupportCollection {#1329 ▼
  #items: array:3 [▼
    "Iphone 11" =&gt; 999
    "Samsung Galaxy S10" =&gt; 899
    "Google Pixel 4" =&gt; 799
  ]
}

IlluminateSupportCollection {#1329 ▼

#items: array:3 [▼

"Iphone 11" => 999

"Samsung Galaxy S10" => 899

"Google Pixel 4" => 799

]

}

Share the news now

Source : Viblo

Collections in Laravel 9

I. Collections Overview

II. Collections functions in Laravel 9

1. Add elements in collections

2. Delete an element in the collection

3. Editing an element in a collection

4. Sort the elements in the collection

5. Filter elements in the collection

5. Collections support handling strings, arrays

TikTok becomes the second largest social platform in South Africa

The fastest depreciating after 9 months of launch, iPhone 14 Pro Max continues to break the bottom in Vietnam

Beginner's guide to R: Introduction

10 essential SublimeText plugins for JavaScript developers