Bộ sưu tập trong Laravel 9

Thứ Tư, 12/04/2023

Tram Ho

Trong series tài liệu ôn thi Laravel Certification hôm nay mình xin phép giới thiệu về collections, mục đích để note lại những kiến thức để cho bản thân mình và các bạn theo dõi bài viết có một tài liệu “chi tiết”.

Bắt đầu nào!

I. Tổng quan về collections

Collection trong Laravel là một cấu trúc dữ liệu mạnh mẽ và linh hoạt, cho phép bạn làm việc với một tập hợp các phần tử dưới nhiều dạng khác nhau. Collection cung cấp cho bạn các phương thức để lọc, sắp xếp, biến đổi và xử lý dữ liệu trong tập hợp đó.

Collection được thiết kế để hoạt động hiệu quả với cơ sở dữ liệu và các hàm của PHP. Nó có thể được sử dụng để xử lý dữ liệu trả về từ các truy vấn cơ sở dữ liệu, hoặc để lọc, sắp xếp và hiển thị các bộ sưu tập phức tạp.

Một số tính năng của Collection trong Laravel bao gồm:

Các phương thức để lọc và sắp xếp các phần tử trong collection dựa trên các điều kiện khác nhau.
Các phương thức để biến đổi dữ liệu trong collection bằng cách thêm hoặc loại bỏ các phần tử.
Các phương thức để thực hiện các thao tác như map, reduce và filter trên collection.
Khả năng kết hợp các collection với nhau để tạo ra các collection mới.
Các phương thức để xử lý các phần tử trong collection theo cách linh hoạt.
Khả năng sử dụng collection với Eloquent để truy vấn và sắp xếp dữ liệu trong cơ sở dữ liệu.

Với Collection, bạn có thể thực hiện các thao tác phức tạp trên tập hợp các phần tử một cách dễ dàng và hiệu quả, giúp bạn tiết kiệm thời gian và tăng hiệu suất của ứng dụng Laravel của bạn.

II. Các hàm collections trong Laravel 9

Tổng sơ sơ là có gần 70 hàm collections trong Laravel và tôi xin phép được giải thích chi tiết từng hàm một. Bài này có thể sẽ khá dài nhưng cô đọng cực nhiều kiến thức

Tôi sẽ áp dụng collect mẫu này , ae hãy nhớ tới cuối bài viết.

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

1. Thêm phần tử trong collections

Thêm phần tử vào collection:

push($value): Thêm một phần tử vào cuối collection (1 phần tử hoặc 1 mảng các phần tử).

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à :

và

put($key, $value): Thêm hoặc cập nhật một phần tử hoặc một mảng với key tương ứng trong collection.
Nếu $key đã tồn tại thì put sẽ ghi đè value mới còn không thì sẽ thêm với key và value tương ứng.
Ví dụ: dd($countries->put(2, "American"))

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

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

prepend($value): Thêm một phần tử vào đầu collection.
Ví dụ: dd($countries->prepend(2, "American"))

2. Xóa phần tử trong collection

forget($key): Xóa phần tử với key tương ứng khỏi collection, nếu key không có thì k có chuyện gì xảy ra.
Ví dụ: dd($countries->forget(1))
pull($key, $default = null): Xóa phần tử với key tương ứng khỏi collection và trả về giá trị của phần tử đó, nếu key không tồn tại thì trả về null . Giả sử ta set biến $default = "ahihihi" thì hiển thị ahihihi thay vì null
pop(): Xóa phần tử cuối cùng khỏi collection và trả về giá trị của phần tử đó.
reject($callback): Xóa tất cả các phần tử trong collection không thỏa mãn điều kiện của hàm callback. (Đây cũng là 1 method để lọc phẩn tử không thỏa mãn điều kiện hàm callback trong collection , nhưng nếu có ai hỏi bạn liệt kê một số method để xóa thì method này cũng thỏa mãn điều kiện , rõ ràng là nó có xóa mà)
Ví dụ:

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

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

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

});

3. Chỉnh sửa phần tử trong collection

transform($key): Áp dụng hàm callback lên mỗi phần tử của collection và ghi đè các giá trị cũ bằng giá trị mới.

Ví dụ

    $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): Tạo ra một collection mới bằng cách áp dụng hàm callback lên mỗi phần tử của 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): Tạo ra một collection mới bằng cách kết hợp collection hiện tại với một collection khác hoặc một mảng.

Ví dụ ta có như sau :

      //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): Tạo ra một collection mới bằng cách thay thế tất cả các phần tử trong collection bằng các phần tử khác được cung cấp trong một mảng hoặc collection mới.

      //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. Sắp xếp phần tử trong collection

sort(): Sắp xếp một Collection theo thứ tự tăng dần của giá trị của phần tử.

    $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) : Sắp xếp một Collection bằng cách sử dụng một 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): Sắp xếp một Collection theo thứ tự giảm dần bằng cách sử dụng một 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(): Sắp xếp một Collection theo thứ tự tăng dần của key của các phần tử.

    $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);

Kết quả:

    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(): Sắp xếp một Collection theo thứ tự giảm dần của key của các phần tử.

    $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());

Kết quả:

    [
        ['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. Lọc phần tử trong collection

filter($callback): Lọc các phần tử của collection dựa trên điều kiện được chỉ định trong $callback và trả về một collection mới chứa các phần tử đã được lọc.

    $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): Tương tự như phương thức filter(), nhưng trả về các phần tử không thỏa điều kiện.

    $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): Lọc các phần tử của collection dựa trên giá trị của một thuộc tính nào đó. $key là tên thuộc tính, $operator là toán tử so sánh (ví dụ như =, >, <…), và $value là giá trị để so sánh. Nếu chỉ có 2 tham số trong function where => operator mặc định là “=”

    $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());

Kết quả:

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

[

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

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

]

whereStrict($key, $value): Tương tự như phương thức where(), nhưng so sánh giá trị của thuộc tính và $value theo kiểu so sánh chính xác (bao gồm kiểu dữ liệu). Ví dụ

    $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());

Kết quả:

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

[

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

]

whereIn($key, $values): Lọc các phần tử có giá trị của thuộc tính $key nằm trong một mảng $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());

Kết quả:

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

[

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

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

]

whereInStrict($key, $values): Tương tự whereIn nhưng sẽ set thêm cả kiểu dữ liệu nữa. Ví dụ:

    $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): Tương tự như phương thức whereIn(), nhưng lọc các phần tử không nằm trong mảng $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;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());

Kết quả:

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

[

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

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

]

whereNotInStrict($key, $values): Tương tự như phương thức whereNotIn(), nhưng lọc các phần tử không nằm trong mảng $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;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());

Kết quả:

    [
        ['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): Lọc các phần tử có giá trị của thuộc tính $key nằm trong khoảng giá trị từ $values[0] đến $values[1].

Ví dụ :

    $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());

Kết quả:

    [
        ['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): Lọc các phần tử có giá trị của thuộc tính $key là 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());

Kết quả:

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

[

['name' => null],

]

whereNotNull($key): Lọc các phần tử có giá trị của thuộc tính $key khác 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());

Kết quả:

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

[

['name' => 'Desk'],

['name' => 'Bookcase']

]

5. Collections hỗ trợ xử lý chuỗi, mảng

join($glue, $finalGlue = null): được sử dụng để kết hợp các phần tử của một collection thành một chuỗi duy nhất, với các phần tử được ngăn cách bằng một chuỗi xác định.

Trong đó :

$glue: là chuỗi ngăn cách giữa các phần tử.
$finalGlue: là chuỗi ngăn cách giữa phần tử cuối cùng và phần tử liền trước đó. Nếu bạn không muốn có chuỗi ngăn cách ở phần tử cuối cùng, thì giá trị của $finalGlue sẽ là null.

Ví dụ:

    $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): là một phương thức của Collection trong Laravel, nó được sử dụng để tính toán tất cả các tổ hợp của các giá trị trong các collection được cung cấp.

Ví dụ :

    $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);

Kết quả:

    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): Áp dụng một hàm lên mỗi phần tử trong collection và trả về một collection mới. Trong trường hợp này, ta có thể sử dụng phương thức map để xử lý các chuỗi trong 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): là một phương thức trong Collection của Laravel, được sử dụng để biến đổi các phần tử trong Collection bằng cách sử dụng một hàm callback, tuy nhiên với cách hoạt động khác so với các phương thức map() và mapWithKeys().

Điểm khác biệt của mapSpread() so với các phương thức map() và mapWithKeys() là tham số truyền vào hàm callback. Thay vì truyền vào một giá trị duy nhất cho mỗi phần tử trong Collection, mapSpread() sẽ truyền vào nhiều tham số tương ứng với các giá trị của từng phần tử trong Collection.

Ví dụ:

    $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) trong Laravel Collection được sử dụng để biến đổi một Collection thành một mảng được nhóm lại theo một thuộc tính cụ thể.

Ví dụ:

    $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());

Kết quả:

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): trong Laravel Collection cho phép biến đổi các giá trị của Collection thành một mảng kết hợp key-value mới. Nó sử dụng một callback function để thực hiện việc này và trả về một Collection mới với các cặp key-value được tạo ra bởi callback function.

Ví dụ :

    $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']];

});

Kết quả:

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

]

}

Chia sẻ bài viết ngay

Nguồn bài viết : Viblo

Bộ sưu tập trong Laravel 9

I. Tổng quan về collections

II. Các hàm collections trong Laravel 9

1. Thêm phần tử trong collections

2. Xóa phần tử trong collection

3. Chỉnh sửa phần tử trong collection

4. Sắp xếp phần tử trong collection

5. Lọc phần tử trong collection

5. Collections hỗ trợ xử lý chuỗi, mảng

TikTok trở thành nền tảng mảng xã hội lớn thứ hai ở Nam Phi

Mất giá nhanh nhất sau 9 tháng ra mắt, iPhone 14 Pro Max tiếp tục phá đáy tại Việt Nam

Hướng dẫn sử dụng ngôn ngữ R cho người mới bắt đầu

10 plugin cần thiết của SublimeText dành cho các lập trình viên JavaScript