Collections

Introduction

Class Illuminate\Support\Collection cung cấp một gói làm việc dễ dàng, thuận lợi với các mảng dữ liệu. Ví dụ, hãy xem qua đoạn code sau. Chúng ta sẽ sử dụng helper collect để tạo mới một collection instance từ mảng, chạy hàm strtoupper trên mỗi phần tử, và sau đó xóa tất cả các phần tử trống:

$collection = collect(['taylor', 'abigail', null])->map(function ($name) {
    return strtoupper($name);
})
->reject(function ($name) {
    return empty($name);
});

Như bạn có thể thấy, class Collection cho phép bạn đính kèm các phương thức để dễ dàng thực hiện xử lý và xóa phần từ mảng. Nói chung, mỗi phương thức Collection trả về một instance Collection.

Tạo Collections

Như đã đề cập bên trên, helper collect trả về một instance Illuminate\Support\Collection mới cho một mảng. Do đó, tạo một collection đơn giản như sau:

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

Các kết quả truy vấn Eloquent luôn trả về một Collection instances.

Các phương thức tồn tại

Trong tài liệu này, chúng ta sẽ thảo luận về từng phương thức có sẵn trong class Collection. Nhớ rằng tất cả những phương thức có thể được liên kết cho việc xử lý mảng một cách thuận lợi nhất. Hơn nữa, hầu hết mỗi phương thức đều trả về một instance Collection mới, cho phép bạn giữ lại bản gốc của collection khi cần thiết:

Danh sách phương thức

all()

Hàm all đơn giản trả về mảng cơ bản được miêu tả bởi collection:

collect([1, 2, 3])->all();

// [1, 2, 3]

avg()

Hàm avg trả về trung bình tất cả các item trong collection

collect([1, 2, 3, 4, 5])->avg();

// 3

Nếu collection bao gồm nhiều mảng hoặc đối tượng lồng nhau, bạn có thể truyền vào 1 key để phân biết giá trị nào dùng để tính trung bình:

$collection = collect([
    ['name' => 'JavaScript: The Good Parts', 'pages' => 176],
    ['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096],
]);

$collection->avg('pages');

// 636

chunk()

Hàm chunk chia collection thành nhiều phần, các collection nhỏ hơn với kích thước đã cho:

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

$chunks = $collection->chunk(4);

$chunks->toArray();

// [[1, 2, 3, 4], [5, 6, 7]]

Hàm này đặc biệt hữu ích trong views khi làm việc với grid system như Bootstrap. Tưởng tượng bạn có 1 collectioni của các model Eloquent mà bạn muốn hiển thị dạng lưới:

@foreach ($products->chunk(3) as $chunk)
    <div class="row">
        @foreach ($chunk as $product)
            <div class="col-xs-4">{{ $product->name }}</div>
        @endforeach
    </div>
@endforeach

collapse()

Hàm collapse gộp một mảng collection thành một collection:

$collection = collect([[1, 2, 3], [4, 5, 6], [7, 8, 9]]);

$collapsed = $collection->collapse();

$collapsed->all();

// [1, 2, 3, 4, 5, 6, 7, 8, 9]

combine()

Hàm combine hợp nhất key của một collection với value của một mảng hoặc collection khác:

$collection = collect(['name', 'age']);

$combined = $collection->combine(['George', 29]);

$combined->all();

// ['name' => 'George', 'age' => 29]

contains()

Hàm contains xác định xem colletion có bao gồm item đã cho hay không:

$collection = collect(['name' => 'Desk', 'price' => 100]);

$collection->contains('Desk');

// true

$collection->contains('New York');

// false

Bạn cũng có thể truyền 1 cặp key / value vào phương thức contains , nó sẽ xác định sự tồn tại cặp đó trong collection:

$collection = collect([
    ['product' => 'Desk', 'price' => 200],
    ['product' => 'Chair', 'price' => 100],
]);

$collection->contains('product', 'Bookcase');

// false

Cuối cùng, nó sẽ xác định sự tồn tại cặp đó trong collection contains để thực hiện test kiểm tra:

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

$collection->contains(function ($value, $key) {
    return $value > 5;
});

// false

count()

Hàm count trả về tổng số phần tử trong collection:

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

$collection->count();

// 4

diff()

Hàm diff method compares the collection against another collection or a plain PHPso sánh collection với một collection khác hoặc array đơn giản dựa trên value của nó. Hàm này sẽ trả về các giá trị trong collection gốc và không xuất hiện trong collection đã cho:

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

$diff = $collection->diff([2, 4, 6, 8]);

$diff->all();

// [1, 3, 5]

diffKeys()

Hàm diffKeys so sánh collection với một collection khác hoặc array php đơn giản dựa trên key của nó. Hàm này sẽ trả về cặp key / value trong collection gốc và không xuất hiện trong collection đã cho:

$collection = collect([
    'one' => 10,
    'two' => 20,
    'three' => 30,
    'four' => 40,
    'five' => 50,
]);

$diff = $collection->diffKeys([
    'two' => 2,
    'four' => 4,
    'six' => 6,
    'eight' => 8,
]);

$diff->all();

// ['one' => 10, 'three' => 30, 'five' => 50]

each()

Hàm each lặp qua các phần tử trong collection và truyền mỗi phần tử vào trong 1 callback:

$collection = $collection->each(function ($item, $key) {
    //
});

Nếu bạn muốn dừng tương tác với các items, bản phải trả về false từ callback:

$collection = $collection->each(function ($item, $key) {
    if (/* some condition */) {
        return false;
    }
});

every()

Hàm every tạo ra 1 collection mới bao gồm mỗi phần tử thứ n:

$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);

$collection->every(4);

// ['a', 'e']

Bạn có thể tùy chọn truyền offset(phần bỏ qua) như là tham số thứ 2:

$collection->every(4, 1);

// ['b', 'f']

except()

Hàm except trả về toàn bộ phần tử trọng collection trừ những phần từ với key đã được chỉ định:

$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);

$filtered = $collection->except(['price', 'discount']);

$filtered->all();

// ['product_id' => 1]

Trái ngược với except, xem hàm only.

filter()

Hàm filter ọc qua collection bằng một callback, chỉ giữ lại những phần tử mà thông qua điều kiện đã cho:

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

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

$filtered->all();

// [3, 4]

Trái ngược với filter, xem hàm reject.

first()

Hàm first trả về phần từ đầu tiên trong collection với việc truyền vào một hàm điều kiện:

collect([1, 2, 3, 4])->first(function ($value, $key) {
    return $value > 2;
});

// 3

Ngoài ra bạn có thể gọi hàm first không có tham số để trả về phần tử đầu tiên của collection. nếu collection rỗng, null sẽ được trả về:

collect([1, 2, 3, 4])->first();

// 1

flatMap()

Hàm flatMap lặp qua collection và truyền từng value vào callback. Callback sẽ thay đổi và trả lại nó, do vậy tạo ra 1 collection mới từ các phần tử được thay đổi. Sau đó mảng sẽ bị flatten bởi 1 level:

$collection = collect([
    ['name' => 'Sally'],
    ['school' => 'Arkansas'],
    ['age' => 28]
]);

$flattened = $collection->flatMap(function ($values) {
    return array_map('strtoupper', $values);
});

$flattened->all();

// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];

flatten()

Hàm flatten làm phẳng một collection nhiều chiều thành một chiều:

$collection = collect(['name' => 'taylor', 'languages' => ['php', 'javascript']]);

$flattened = $collection->flatten();

$flattened->all();

// ['taylor', 'php', 'javascript'];

Bạn có thể tùy chọn truyền vào hàm một tham số "depth":

$collection = collect([
    'Apple' => [
        ['name' => 'iPhone 6S', 'brand' => 'Apple'],
    ],
    'Samsung' => [
        ['name' => 'Galaxy S7', 'brand' => 'Samsung']
    ],
]);

$products = $collection->flatten(1);

$products->values()->all();

/*
    [
        ['name' => 'iPhone 6S', 'brand' => 'Apple'],
        ['name' => 'Galaxy S7', 'brand' => 'Samsung'],
    ]
*/

Trong ví dụ này, nếu gọi flatten mà không cung cấp "depth" (độ sau) có thể cũng sẽ flatten cả những mảng lồng nhau, kết quả là ['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']. ung cấp "depth" cho phép bạn hạn chế mức độ của các mảng lồng nhau mà sẽ bị flatten.

flip()

Hàm flip đảo ngược vị trí key và value của collection:

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$flipped = $collection->flip();

$flipped->all();

// ['taylor' => 'name', 'laravel' => 'framework']

forget()

Hàm forget xóa một phần từ từ collection bởi key:

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$collection->forget('name');

$collection->all();

// ['framework' => 'laravel']

Không như một số hàm collection, forget không trả về về một collection mới; nó thanh đổi chính collection mà nó được gọi tới.

forPage()

Hàm forPage trả về một collection mới bao gồm các phần tử mà sẽ được xuất hiện với số trang đa cho. Hàm này nhận số trang là đối số thứ nhất và items để hiển thị lên một trang là tham số thứ hai:

$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);

$chunk = $collection->forPage(2, 3);

$chunk->all();

// [4, 5, 6]

get()

Hàm get trả về phần tử tại key đã cho. Nếu key không tồn tại, trả về null:

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$value = $collection->get('name');

// taylor

Bạn có thể tùy chọn truyền vào một giá trị mặc định như là tham số thứ 2:

$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);

$value = $collection->get('foo', 'default-value');

// default-value

Bạn có thể truyền một callback như là giá trị mặc định. Giá trị của callback sẽ được trả về nếu key chỉ định không tồn tại:

$collection->get('email', function () {
    return 'default-value';
});

// default-value

groupBy()

Hàm groupBy nhóm các phần tử của collection bởi một key:

$collection = collect([
    ['account_id' => 'account-x10', 'product' => 'Chair'],
    ['account_id' => 'account-x10', 'product' => 'Bookcase'],
    ['account_id' => 'account-x11', 'product' => 'Desk'],
]);

$grouped = $collection->groupBy('account_id');

$grouped->toArray();

/*
    [
        'account-x10' => [
            ['account_id' => 'account-x10', 'product' => 'Chair'],
            ['account_id' => 'account-x10', 'product' => 'Bookcase'],
        ],
        'account-x11' => [
            ['account_id' => 'account-x11', 'product' => 'Desk'],
        ],
    ]
*/

Thêm vào đó để truyền một key là chuỗi, bạn cũng có thể truyền vào một callback. Callback sẽ trả về giá trị bạn muốn làm key để nhóm:

$grouped = $collection->groupBy(function ($item, $key) {
    return substr($item['account_id'], -3);
});

$grouped->toArray();

/*
    [
        'x10' => [
            ['account_id' => 'account-x10', 'product' => 'Chair'],
            ['account_id' => 'account-x10', 'product' => 'Bookcase'],
        ],
        'x11' => [
            ['account_id' => 'account-x11', 'product' => 'Desk'],
        ],
    ]
*/

has()

Hàm has xác định nếu key đã cho tồn tại trong collectio:

$collection = collect(['account_id' => 1, 'product' => 'Desk']);

$collection->has('email');

// false

implode()

Hàm implode nối các phần tử thành trong collection. Tham số của nó dựa trên kiểu của các phần tử trong collection. Nếu collection chứa mảng hoặc object, bạn nên truyền key của các thuộc tính bạn muốn join, và string "glue" bạn muốn đặt giữa giá trị:

$collection = collect([
    ['account_id' => 1, 'product' => 'Desk'],
    ['account_id' => 2, 'product' => 'Chair'],
]);

$collection->implode('product', ', ');

// Desk, Chair

Nếu collection chỉ đơn giản bao gồm các chuỗi hoặc giá trị số, chỉ cần truyền "glue" như là tham số duy nhất cho phương thức:

collect([1, 2, 3, 4, 5])->implode('-');

// '1-2-3-4-5'

intersect()

Hàm intersect xóa các giá trị mà không xuất hiện trong array hoặc collection đã cho. Giá trị collection trả về sẽ giữ nguyên key của collection cũ:

$collection = collect(['Desk', 'Sofa', 'Chair']);

$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);

$intersect->all();

// [0 => 'Desk', 2 => 'Chair']

isEmpty()

Hàm isEmpty trả về true nếu collection là rỗng, ngược lại trả về false:

collect([])->isEmpty();

// true

keyBy()

Hàm keyBy Tạo key cho collection bởi key đã cho. Nếu nhiều phần từ có chung key, chỉ có phần từ cuối cùng sẽ xuất hiện trong collection mới:

$collection = collect([
    ['product_id' => 'prod-100', 'name' => 'desk'],
    ['product_id' => 'prod-200', 'name' => 'chair'],
]);

$keyed = $collection->keyBy('product_id');

$keyed->all();

/*
    [
        'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
        'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]
*/

Bạn cũng có thể truyền vào một callback, cái mà sẽ trả về giá trị để làm khóa cho collection:

$keyed = $collection->keyBy(function ($item) {
    return strtoupper($item['product_id']);
});

$keyed->all();

/*
    [
        'PROD-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
        'PROD-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
    ]
*/

keys()

The keys method returns all of the collection's keys:

$collection = collect([
    'prod-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
    'prod-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
]);

$keys = $collection->keys();

$keys->all();

// ['prod-100', 'prod-200']

last()

Hàm last trả về phần thử cuối cùng trong collection mà thông qua điều kiện đã cho:

collect([1, 2, 3, 4])->last(function ($value, $key) {
    return $value < 3;
});

// 2

Bạn có thể dùng hàm last trả về phần thử cuối cùng trong collection mà thông qua điều kiện đã cho. INếu collection rỗng, null sẽ được trả về:

collect([1, 2, 3, 4])->last();

// 4

map()

Hàm map lặp qua collection và truyền từng giá trị vào callback. Callback thay đổi phần từ và trả về, do vậy hình thành một collection mới từ các phần tử đã được thay đổi:

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

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

$multiplied->all();

// [2, 4, 6, 8, 10]

Giống như các phương thức khác, map trả về một instance collection mới; nó không thay đổi collection mà nó được gọi, Nếu bạn muốn thay đổi collection gốc, sử dụng phương thức transform.

mapWithKeys()

Hàm mapWithKeys lặp qua collection và truyền mỗi giá trị vào hàm callback. Hàm callback trả về một mảng associative chứa một cặp key / value:

$collection = collect([
    [
        'name' => 'John',
        'department' => 'Sales',
        'email' => 'john@example.com'
    ],
    [
        'name' => 'Jane',
        'department' => 'Marketing',
        'email' => 'jane@example.com'
    ]
]);

$keyed = $collection->mapWithKeys(function ($item) {
    return [$item['email'] => $item['name']];
});

$keyed->all();

/*
    [
        'john@example.com' => 'John',
        'jane@example.com' => 'Jane',
    ]
*/

max()

The max method returns the maximum value of a given key:

$max = collect([['foo' => 10], ['foo' => 20]])->max('foo');

// 20

$max = collect([1, 2, 3, 4, 5])->max();

// 5

merge()

Hàm merge gộp mảng đã cho vào collection. Bất kì string key trong mảng trùng với string key trong collection sẽ bị ghi đè bởi giá trị của collection:

$collection = collect(['product_id' => 1, 'price' => 100]);

$merged = $collection->merge(['price' => 200, 'discount' => false]);

$merged->all();

// ['product_id' => 1, 'price' => 200, 'discount' => false]

Nếu key của mảng đã cho là số, giá trị sẽ được xuất hiện tại cuối collection:

$collection = collect(['Desk', 'Chair']);

$merged = $collection->merge(['Bookcase', 'Door']);

$merged->all();

// ['Desk', 'Chair', 'Bookcase', 'Door']

min()

Hàm min trả về giá trị nhỏ nhất của key đã cho:

$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');

// 10

$min = collect([1, 2, 3, 4, 5])->min();

// 1

only()

Hàm only trả về các phần từ trong collection với key xác định:

$collection = collect(['product_id' => 1, 'name' => 'Desk', 'price' => 100, 'discount' => false]);

$filtered = $collection->only(['product_id', 'name']);

$filtered->all();

// ['product_id' => 1, 'name' => 'Desk']

ngược với hàm only, xem hàm except.

pipe()

Hàm pipe truyền vào một collection vào hàm callback và nhận lại kết quả:

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

$piped = $collection->pipe(function ($collection) {
    return $collection->sum();
});

// 6

pluck()

Hàm pluck lấy toàn bộ các value của collection cho một key cho trước:

$collection = collect([
    ['product_id' => 'prod-100', 'name' => 'Desk'],
    ['product_id' => 'prod-200', 'name' => 'Chair'],
]);

$plucked = $collection->pluck('name');

$plucked->all();

// ['Desk', 'Chair']

Bạn cũng có thể chỉ định bạn muốn collection kết quả được chỉ mục như thế nào::

$plucked = $collection->pluck('name', 'product_id');

$plucked->all();

// ['prod-100' => 'Desk', 'prod-200' => 'Chair']

pop()

Hàm pop xóa và trả lại phần tử cuối cùng từ collection:

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

$collection->pop();

// 5

$collection->all();

// [1, 2, 3, 4]

prepend()

Hàm prepend thêm một phân từ vào đầu của collection:

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

$collection->prepend(0);

$collection->all();

// [0, 1, 2, 3, 4, 5]

Bạn có thể tùy chọn truyền tham số thứ 2 để set key cho giá trị được thêm:

$collection = collect(['one' => 1, 'two', => 2]);

$collection->prepend(0, 'zero');

$collection->all();

// ['zero' => 0, 'one' => 1, 'two', => 2]

pull()

Hàm pull xóa và trả về một giá trị từ collection bởi key của nó:

$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);

$collection->pull('name');

// 'Desk'

$collection->all();

// ['product_id' => 'prod-100']

push()

The push method appends an item to the end of the collection:

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

$collection->push(5);

$collection->all();

// [1, 2, 3, 4, 5]

put()

Hàm put thên key và value vào trong collection:

$collection = collect(['product_id' => 1, 'name' => 'Desk']);

$collection->put('price', 100);

$collection->all();

// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]

random()

Hàm random trả về ngẫu nhiên 1 phần tử từ collection::

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

$collection->random();

// 4 - (retrieved randomly)

Bạn có thể tùy chọn truyền vào 1 số nguyên trong random. Nếu số nguyên đó lớn hơn 1, 1 collection sẽ được trả về:

$random = $collection->random(3);

$random->all();

// [2, 4, 5] - (retrieved randomly)

reduce()

Hàm reduce biến collection thành một giá trị duy nhất, truyền kết quả của mỗi lần lặp vào lần lặp tiếp theo:

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

$total = $collection->reduce(function ($carry, $item) {
    return $carry + $item;
});

// 6

Giá trị của $carry trong lần lặp đầu tiên là null; tuy nhiên bạn có thể chỉ định giá trị khởi tạo bằng cách truyền môt tham số thứ 2 vào reduce:

$collection->reduce(function ($carry, $item) {
    return $carry + $item;
}, 4);

// 10

reject()

Hàm reject lọc collection thông qua callback. Callback sẽ return true cho bất kì phần tử nào nó muốn xóa khỏi collection:

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

$filtered = $collection->reject(function ($value, $key) {
    return $value > 2;
});

$filtered->all();

// [1, 2]

Ngược lại với phương thức reject, xem hàm filter.

reverse()

Hàm reverse đảo ngược thứ tự các phần tử trong collection:

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

$reversed = $collection->reverse();

$reversed->all();

// [5, 4, 3, 2, 1]

search()

Hàm search tìm kiếm giá trị trong collection và trả về key của nó nếu tìm thấy. Nếu không tìm thấy, trả về false.

$collection = collect([2, 4, 6, 8]);

$collection->search(4);

// 1

Việc tìm kiếm sử dụng so sánh lỏng lẻo. Để sử dụng so sánh chặt chẽ, truyền true như là tham số thứ 2 vào phương thức:

$collection->search('4', true);

// false

Ngoài ra, bạn có thể truyền vào callback để tìm kiếm giá trị đầu tiên thỏa mãn điều kiện:

$collection->search(function ($item, $key) {
    return $item > 5;
});

// 2

shift()

Hàm shift xóa và trả về giá trị đầu tiên trong collection:

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

$collection->shift();

// 1

$collection->all();

// [2, 3, 4, 5]

shuffle()

Hàm shuffle đảo ngẫu nhiên các phần tử trong collection:

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

$shuffled = $collection->shuffle();

$shuffled->all();

// [3, 2, 5, 1, 4] // (generated randomly)

slice()

Hàm slice trả về một phần của collection bắt đầu từ vị trí đã cho:

$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);

$slice = $collection->slice(4);

$slice->all();

// [5, 6, 7, 8, 9, 10]

Nếu bạn muốn giới hạn kích thước của collection trả về, truyền kích thước vào tham số thứ 2 trong phương thức:

$slice = $collection->slice(4, 2);

$slice->all();

// [5, 6]

Collection trả về từ slice là tạo mới, các key được đánh số theo thứ tự. Nếu bạn muốn giữ nguyên các key, truyền vào tham số thứ 3 là values vào phương thức.

sort()

Hàm sort sắp xếp collection. Sắp xếp collection giữ nguyên mảng key, vì vậy trong ví dụ dưới, chúng ta sử dụng values để reset lại các key để đánh số liên tiếp:

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

$sorted = $collection->sort();

$sorted->values()->all();

// [1, 2, 3, 4, 5]

Nếu bạn muốn sắp xếp nâng cao hơn, bạn có thể truyền một callback vào sort với thuật toán của mình. Tham khảo tài liệu PHP tại usort, đây chính là cái mà phương thức sort gọi tới.

Nếu chúng ta cần sort một collection của mảng hoặc object lồng, xem hàm sortBysortByDesc.

sortBy()

Hàm sortBy sắp xếp collection bởi key. Collection được sắp xếp giữ nguyên mảng key. Trong ví dụ này chúng ta sử dụng phương thức values để reset key để đánh số liên tiếp:

$collection = collect([
    ['name' => 'Desk', 'price' => 200],
    ['name' => 'Chair', 'price' => 100],
    ['name' => 'Bookcase', 'price' => 150],
]);

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

$sorted->values()->all();

/*
    [
        ['name' => 'Chair', 'price' => 100],
        ['name' => 'Bookcase', 'price' => 150],
        ['name' => 'Desk', 'price' => 200],
    ]
*/

Bạn cũng có thể truyền vào callback để xách định sắp xếp giá trị collection như thế nào:

$collection = collect([
    ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
    ['name' => 'Chair', 'colors' => ['Black']],
    ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
]);

$sorted = $collection->sortBy(function ($product, $key) {
    return count($product['colors']);
});

$sorted->values()->all();

/*
    [
        ['name' => 'Chair', 'colors' => ['Black']],
        ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
        ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
    ]
*/

sortByDesc()

Hàm này giống với hàm sortBy , nhưng nó sẽ sắp xếp collection theo thứ tự ngược lại.

splice()

Hàm splice xóa và trả về một collection các phần từ bắt đầu từ chỉ mục xác định:

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

$chunk = $collection->splice(2);

$chunk->all();

// [3, 4, 5]

$collection->all();

// [1, 2]

Bạn có thể truyền tham số thứ 2 để giới hạn kích thước của phần kết quả:

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

$chunk = $collection->splice(2, 1);

$chunk->all();

// [3]

$collection->all();

// [1, 2, 4, 5]

Thêm vào đó bạn có thể truyền 1 tham số thứ 3 bao gồm các phần tử mới để thay thế các phần tử bị xóa khỏi collection:

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

$chunk = $collection->splice(2, 1, [10, 11]);

$chunk->all();

// [3]

$collection->all();

// [1, 2, 10, 11, 4, 5]

split()

Hàm split cắt collection thành các groups:

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

$groups = $collection->split(3);

$groups->toArray();

// [[1, 2], [3, 4], [5]]

sum()

Hàm sum trả về tổng của tất cả phần từ trong collection:

collect([1, 2, 3, 4, 5])->sum();

// 15

Nếu collection bao gồm nhiều mảng hoặc object lồng nhau, bạn phải truyền vào một key xác định giá trị nào cần tính tổng:

$collection = collect([
    ['name' => 'JavaScript: The Good Parts', 'pages' => 176],
    ['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096],
]);

$collection->sum('pages');

// 1272

Thêm nữa, bạn có thể truyền vào callback để xác định các giá trị nào của collection dùng để tính tổng:

$collection = collect([
    ['name' => 'Chair', 'colors' => ['Black']],
    ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
    ['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
]);

$collection->sum(function ($product) {
    return count($product['colors']);
});

// 6

take()

Hàm take trả về một collection mới với số lượng phần tử chỉ định:

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

$chunk = $collection->take(3);

$chunk->all();

// [0, 1, 2]

Bạn cũng có thể truyền vào 1 số nguyên âm để lấy các phần tử từ cuối của collection:

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

$chunk = $collection->take(-2);

$chunk->all();

// [4, 5]

toArray()

Hàm toArray convert collection thành một plain PHP array. Nếu các giá trị của collection là Eloquent models, các model cũng sẽ được convert sang mảng:

$collection = collect(['name' => 'Desk', 'price' => 200]);

$collection->toArray();

/*
    [
        ['name' => 'Desk', 'price' => 200],
    ]
*/

toArray cũng convert toàn bộ các object lồng trong nó thành một mảng. If you want to get the underlying array as is, thay vào đó sử dụng phương thức all.

toJson()

Hàm toJson convert collection thành JSON:

$collection = collect(['name' => 'Desk', 'price' => 200]);

$collection->toJson();

// '{"name":"Desk", "price":200}'

transform()

Hàm transform lặp quan collection và gọi callback với mỗi phần tử trong collection. Các phần tử trong collection sẽ được thay thế bởi giá trị trả về của callback:

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

$collection->transform(function ($item, $key) {
    return $item * 2;
});

$collection->all();

// [2, 4, 6, 8, 10]

hông giống như hầu hết các phương thức khác transform thay đổi chính collection. Nếu bạn muốn tạo một collection mới, sử dụng hàm map.

union()

Hàm union thêm một mảng đã cho vào collection. Nếu mảng đã cho bao gồm key đã xuất hiện trong collection, giá trị collection sẽ được ưu tiên hơn:

$collection = collect([1 => ['a'], 2 => ['b']]);

$union = $collection->union([3 => ['c'], 1 => ['b']]);

$union->all();

// [1 => ['a'], 2 => ['b'], [3 => ['c']]

unique()

Hàm unique trả về toàn bộ các phần tử duy nhất trong collection. Collection trả về giữ nguyên mảng key. Trong ví dụ này chúng ta sử dụng values để reset key để đánh số thứ tự liên tiếp:

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

$unique = $collection->unique();

$unique->values()->all();

// [1, 2, 3, 4]

Khi làm việc với các mảng hoặc object lồng nhau, bạn có thể chỉ định key để xác định tính duy nhất:

$collection = collect([
    ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
    ['name' => 'iPhone 5', 'brand' => 'Apple', 'type' => 'phone'],
    ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'watch'],
    ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
    ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'watch'],
]);

$unique = $collection->unique('brand');

$unique->values()->all();

/*
    [
        ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
        ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
    ]
*/

Bạn cũng có thể truyền vào callback để xác định phần tử có tính duy nhất:

$unique = $collection->unique(function ($item) {
    return $item['brand'].$item['type'];
});

$unique->values()->all();

/*
    [
        ['name' => 'iPhone 6', 'brand' => 'Apple', 'type' => 'phone'],
        ['name' => 'Apple Watch', 'brand' => 'Apple', 'type' => 'watch'],
        ['name' => 'Galaxy S6', 'brand' => 'Samsung', 'type' => 'phone'],
        ['name' => 'Galaxy Gear', 'brand' => 'Samsung', 'type' => 'watch'],
    ]
*/

values()

Hàm values trả về collection mới với key được reset về các số nguyên liên tiếp:

$collection = collect([
    10 => ['product' => 'Desk', 'price' => 200],
    11 => ['product' => 'Desk', 'price' => 200]
]);

$values = $collection->values();

$values->all();

/*
    [
        0 => ['product' => 'Desk', 'price' => 200],
        1 => ['product' => 'Desk', 'price' => 200],
    ]
*/

where()

Hàm where lọc collection bởi cặp key / value:

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

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

$filtered->all();

/*
[
    ['product' => 'Chair', 'price' => 100],
    ['product' => 'Door', 'price' => 100],
]
*/

Hàm where sử dụng so sánh chặt chẽ khi kiểm tra giá trị. Sử dụng whereStrict method để lọc với so sánh lỏng lẻo hơn.

whereStrict()

Hàm này giống với hàm where ; tuy nhiên, tất cả giá trị được so sánh lỏng lẻo.

whereIn()

Hàm whereInlọc collection bằng 1 cặp key / value bao gồm trong mảng đã cho.

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

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

$filtered->all();

/*
[
    ['product' => 'Bookcase', 'price' => 150],
    ['product' => 'Desk', 'price' => 200],
]
*/

Hàm whereIn sử dụng so sánh chặt chẽ khi kiểm tra giá trị phần tử. Sử dụng phương thức whereInLoose để lọc với so sánh lỏng lẻo.

whereInLoose()

Hàm này giống với hàm whereIn tuy nhiên toàn bộ giá trị được so sánh lỏng lẻo.

zip()

Hàm zip gộp các giá trị trong mảng đã cho với giá trị của collection tại chỉ mục tương ứng:

$collection = collect(['Chair', 'Desk']);

$zipped = $collection->zip([100, 200]);

$zipped->all();

// [['Chair', 100], ['Desk', 200]]
Nguồn: https://laravel.com/docs/5.3/collections