Collections
Introduction
这Illuminate\Support\Collection 类为处理数据数组提供了一个流畅、方便的包装器。例如，查看以下代码。我们将使用collect 帮助程序从数组创建一个新的集合实例，运行strtoupper 在每个元素上运行，然后删除所有空元素：
$collection = collect(['taylor', 'abigail', null])->map(function (string $name) {
return strtoupper($name);
})->reject(function (string $name) {
return empty($name);
});
如您所见，Collection 类允许您链接其方法以执行底层数组的流畅映射和减少。一般来说，集合是不可变的，这意味着每个Collection 方法返回一个全新的Collection 实例。
创建集合
如上所述，collect 助手返回一个新的Illuminate\Support\Collection 给定数组的实例。因此，创建一个集合非常简单：
$collection = collect([1, 2, 3]);
Note
结果Eloquent 查询总是返回为Collection实例。
扩展集合
集合是“可宏化的”，它允许您向集合添加额外的方法Collection 运行时的类。这Illuminate\Support\Collection 班级'macro 方法接受一个将在调用宏时执行的闭包。宏闭包可以通过访问集合的其他方法$this，就好像它是集合类的一个真正的方法一样。例如，下面的代码添加了一个toUpper 方法到Collection 班级：
use Illuminate\Support\Collection;
use Illuminate\Support\Str;
Collection::macro('toUpper', function () {
return $this->map(function (string $value) {
return Str::upper($value);
});
});
$collection = collect(['first', 'second']);
$upper = $collection->toUpper();
// ['FIRST', 'SECOND']
通常，您应该在boot 一个方法服务提供者.
宏参数
如有必要，您可以定义接受额外参数的宏：
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Lang;
Collection::macro('toLocale', function (string $locale) {
return $this->map(function (string $value) use ($locale) {
return Lang::get($value, [], $locale);
});
});
$collection = collect(['first', 'second']);
$translated = $collection->toLocale('es');
可用方法
对于大部分剩余的集合文档，我们将讨论Collection 班级。请记住，所有这些方法都可以链接起来以流畅地操作底层数组。此外，几乎每个方法都会返回一个新的Collection 例如，允许您在必要时保留集合的原始副本：
all average avg chunk chunkWhile collapse collect combine concat contains containsOneItem containsStrict count countBy crossJoin dd diff diffAssoc diffKeys doesntContain dump duplicates duplicatesStrict each eachSpread every except filter first firstOrFail firstWhere flatMap flatten flip forget forPage get groupBy has hasAny implode intersect intersectByKeys isEmpty isNotEmpty join keyBy keys last lazy macro make map mapInto mapSpread mapToGroups mapWithKeys max median merge mergeRecursive min mode nth only pad partition pipe pipeInto pipeThrough pluck pop prepend pull push put random range reduce reduceSpread reject replace replaceRecursive reverse search shift shuffle skip skipUntil skipWhile slice sliding sole some sort sortBy sortByDesc sortDesc sortKeys sortKeysDesc sortKeysUsing splice split splitIn sum take takeUntil takeWhile tap times toArray toJson transform undot union unique uniqueStrict unless unlessEmpty unlessNotEmpty unwrap value values when whenEmpty whenNotEmpty where whereStrict whereBetween whereIn whereInStrict whereInstanceOf whereNotBetween whereNotIn whereNotInStrict whereNotNull whereNull wrap zip
方法列表
all()
这all 方法返回由集合表示的基础数组：
collect([1, 2, 3])->all();
// [1, 2, 3]
average()
的别名avg 方法。
avg()
这avg 方法返回平均值 给定键的：
$average = collect([
['foo' => 10],
['foo' => 10],
['foo' => 20],
['foo' => 40]
])->avg('foo');
// 20
$average = collect([1, 1, 2, 4])->avg();
// 2
chunk()
这chunk 方法将集合分成多个给定大小的较小集合：
$collection = collect([1, 2, 3, 4, 5, 6, 7]);
$chunks = $collection->chunk(4);
$chunks->all();
// [[1, 2, 3, 4], [5, 6, 7]]
这种方法特别有用views 使用网格系统时，例如Bootstrap.例如，假设您有一个集合Eloquent 要在网格中显示的模型：
@foreach ($products->chunk(3) as $chunk)
<div class="row">
@foreach ($chunk as $product)
<div class="col-xs-4">{{ $product->name }}</div>
@endforeach
</div>
@endforeach
chunkWhile()
这chunkWhile 方法根据给定回调的评估将集合分成多个较小的集合。这$chunk 传递给闭包的变量可用于检查前一个元素：
$collection = collect(str_split('AABBCCCD'));
$chunks = $collection->chunkWhile(function (string $value, int $key, Collection $chunk) {
return $value === $chunk->last();
});
$chunks->all();
// [['A', 'A'], ['B', 'B'], ['C', 'C', 'C'], ['D']]
collapse()
这collapse 方法将数组集合折叠成一个单一的平面集合：
$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]
collect()
这collect 方法返回一个新的Collection 当前在集合中的项目的实例：
$collectionA = collect([1, 2, 3]);
$collectionB = $collectionA->collect();
$collectionB->all();
// [1, 2, 3]
这collect 方法主要用于转换惰性集合 成标准Collection 实例：
$lazyCollection = LazyCollection::make(function () {
yield 1;
yield 2;
yield 3;
});
$collection = $lazyCollection->collect();
get_class($collection);
// 'Illuminate\Support\Collection'
$collection->all();
// [1, 2, 3]
Note
这collect当你有一个实例时，方法特别有用Enumerable并且需要一个非惰性集合实例。自从collect()是的一部分Enumerable合同，你可以安全地使用它来获得Collection实例。
combine()
这combine 方法将集合的值作为键与另一个数组或集合的值组合：
$collection = collect(['name', 'age']);
$combined = $collection->combine(['George', 29]);
$combined->all();
// ['name' => 'George', 'age' => 29]
concat()
这concat 方法附加给定的array 或集合的值到另一个集合的末尾：
$collection = collect(['John Doe']);
$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);
$concatenated->all();
// ['John Doe', 'Jane Doe', 'Johnny Doe']
这concat 方法以数字方式重新索引连接到原始集合的项目的键。要维护关联集合中的键，请参阅merge 方法。
contains()
这contains 方法确定集合是否包含给定的项目。您可以将闭包传递给contains 确定集合中是否存在与给定真值测试匹配的元素的方法：
$collection = collect([1, 2, 3, 4, 5]);
$collection->contains(function (int $value, int $key) {
return $value > 5;
});
// false
或者，您可以将字符串传递给contains 判断集合是否包含给定项值的方法：
$collection = collect(['name' => 'Desk', 'price' => 100]);
$collection->contains('Desk');
// true
$collection->contains('New York');
// false
您还可以将键/值对传递给contains 方法，它将确定给定对是否存在于集合中：
$collection = collect([
['product' => 'Desk', 'price' => 200],
['product' => 'Chair', 'price' => 100],
]);
$collection->contains('product', 'Bookcase');
// false
这contains 方法在检查项目值时使用“松散”比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。使用containsStrict使用“严格”比较进行过滤的方法。
对于的倒数contains, 看到doesntContain 方法。
containsOneItem()
这containsOneItem 方法确定集合是否包含单个项目：
collect([])->containsOneItem();
// false
collect(['1'])->containsOneItem();
// true
collect(['1', '2'])->containsOneItem();
// false
containsStrict()
此方法具有与contains 方法;但是，所有值都使用“严格”比较进行比较。
Note
使用时修改此方法的行为雄辩的收藏.
count()
这count 方法返回集合中的项目总数：
$collection = collect([1, 2, 3, 4]);
$collection->count();
// 4
countBy()
这countBy 方法计算集合中值的出现次数。默认情况下，该方法计算每个元素的出现次数，允许您计算集合中某些“类型”的元素：
$collection = collect([1, 2, 2, 2, 3]);
$counted = $collection->countBy();
$counted->all();
// [1 => 1, 2 => 3, 3 => 1]
您将闭包传递给countBy 按自定义值计算所有项目的方法：
$collection = collect(['alice@gmail.com', 'bob@yahoo.com', 'carlos@gmail.com']);
$counted = $collection->countBy(function (string $email) {
return substr(strrchr($email, "@"), 1);
});
$counted->all();
// ['gmail.com' => 2, 'yahoo.com' => 1]
crossJoin()
这crossJoin 方法交叉连接给定数组或集合中的集合值，返回具有所有可能排列的笛卡尔积：
$collection = collect([1, 2]);
$matrix = $collection->crossJoin(['a', 'b']);
$matrix->all();
/*
[
[1, 'a'],
[1, 'b'],
[2, 'a'],
[2, 'b'],
]
*/
$collection = collect([1, 2]);
$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);
$matrix->all();
/*
[
[1, 'a', 'I'],
[1, 'a', 'II'],
[1, 'b', 'I'],
[1, 'b', 'II'],
[2, 'a', 'I'],
[2, 'a', 'II'],
[2, 'b', 'I'],
[2, 'b', 'II'],
]
*/
dd()
这dd 方法转储集合的项目并结束脚本的执行：
$collection = collect(['John Doe', 'Jane Doe']);
$collection->dd();
/*
Collection {
#items: array:2 [
0 => "John Doe"
1 => "Jane Doe"
]
}
*/
如果不想停止执行脚本，请使用dump 方法代替。
diff()
这diff 方法将集合与另一个集合或纯 PHP 进行比较array 基于它的值。此方法将返回原始集合中不存在于给定集合中的值：
$collection = collect([1, 2, 3, 4, 5]);
$diff = $collection->diff([2, 4, 6, 8]);
$diff->all();
// [1, 3, 5]
Note
使用时修改此方法的行为雄辩的收藏.
diffAssoc()
这diffAssoc 方法将集合与另一个集合或纯 PHP 进行比较array 基于它的键和值。此方法将返回原始集合中给定集合中不存在的键/值对：
$collection = collect([
'color' => 'orange',
'type' => 'fruit',
'remain' => 6,
]);
$diff = $collection->diffAssoc([
'color' => 'yellow',
'type' => 'fruit',
'remain' => 3,
'used' => 6,
]);
$diff->all();
// ['color' => 'orange', 'remain' => 6]
diffKeys()
这diffKeys 方法将集合与另一个集合或纯 PHP 进行比较array 基于它的键。此方法将返回原始集合中给定集合中不存在的键/值对：
$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]
doesntContain()
这doesntContain 方法确定集合是否不包含给定的项目。您可以将闭包传递给doesntContain 确定集合中是否不存在与给定真值测试匹配的元素的方法：
$collection = collect([1, 2, 3, 4, 5]);
$collection->doesntContain(function (int $value, int $key) {
return $value < 5;
});
// false
或者，您可以将字符串传递给doesntContain 判断集合是否不包含给定项值的方法：
$collection = collect(['name' => 'Desk', 'price' => 100]);
$collection->doesntContain('Table');
// true
$collection->doesntContain('Desk');
// false
您还可以将键/值对传递给doesntContain 方法，它将确定集合中是否不存在给定对：
$collection = collect([
['product' => 'Desk', 'price' => 200],
['product' => 'Chair', 'price' => 100],
]);
$collection->doesntContain('product', 'Bookcase');
// true
这doesntContain 方法在检查项目值时使用“松散”比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。
dump()
这dump 方法转储集合的项目：
$collection = collect(['John Doe', 'Jane Doe']);
$collection->dump();
/*
Collection {
#items: array:2 [
0 => "John Doe"
1 => "Jane Doe"
]
}
*/
如果要在转储集合后停止执行脚本，请使用dd 方法代替。
duplicates()
这duplicates 方法从集合中检索并返回重复值：
$collection = collect(['a', 'b', 'a', 'c', 'b']);
$collection->duplicates();
// [2 => 'a', 4 => 'b']
如果集合包含数组或对象，您可以传递要检查重复值的属性的键：
$employees = collect([
['email' => 'abigail@example.com', 'position' => 'Developer'],
['email' => 'james@example.com', 'position' => 'Designer'],
['email' => 'victoria@example.com', 'position' => 'Developer'],
]);
$employees->duplicates('position');
// [2 => 'Developer']
duplicatesStrict()
此方法具有与duplicates 方法;但是，所有值都使用“严格”比较进行比较。
each()
这each 方法迭代集合中的项目并将每个项目传递给闭包：
$collection = collect([1, 2, 3, 4]);
$collection->each(function (int $item, int $key) {
// ...
});
如果您想停止遍历项目，您可以返回false 从你的关闭：
$collection->each(function (int $item, int $key) {
if (/* condition */) {
return false;
}
});
eachSpread()
这eachSpread 方法遍历集合的项目，将每个嵌套的项目值传递给给定的回调：
$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);
$collection->eachSpread(function (string $name, int $age) {
// ...
});
您可以通过返回来停止迭代项目false 从回调：
$collection->eachSpread(function (string $name, int $age) {
return false;
});
every()
这every 方法可用于验证集合的所有元素是否通过给定的真值测试：
collect([1, 2, 3, 4])->every(function (int $value, int $key) {
return $value > 2;
});
// false
如果集合为空，则every 方法将返回 true：
$collection = collect([]);
$collection->every(function (int $value, int $key) {
return $value > 2;
});
// true
except()
这except 方法返回集合中的所有项目，但具有指定键的项目除外：
$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
$filtered = $collection->except(['price', 'discount']);
$filtered->all();
// ['product_id' => 1]
对于的倒数except, 看到only 方法。
Note
使用时修改此方法的行为雄辩的收藏.
filter()
这filter 方法使用给定的回调过滤集合，只保留那些通过给定真值测试的项目：
$collection = collect([1, 2, 3, 4]);
$filtered = $collection->filter(function (int $value, int $key) {
return $value > 2;
});
$filtered->all();
// [3, 4]
如果未提供回调，则集合中的所有条目都等同于false 将被删除：
$collection = collect([1, 2, 3, null, false, '', 0, []]);
$collection->filter()->all();
// [1, 2, 3]
对于的倒数filter, 看到reject 方法。
first()
这first 方法返回集合中通过给定真值测试的第一个元素：
collect([1, 2, 3, 4])->first(function (int $value, int $key) {
return $value > 2;
});
// 3
您也可以致电first 不带参数的方法获取集合中的第一个元素。如果集合为空，null返回：
collect([1, 2, 3, 4])->first();
// 1
firstOrFail()
这firstOrFail 方法与first 方法;然而，如果没有找到结果，一个Illuminate\Support\ItemNotFoundException 将抛出异常：
collect([1, 2, 3, 4])->firstOrFail(function (int $value, int $key) {
return $value > 5;
});
// Throws ItemNotFoundException...
您也可以致电firstOrFail 不带参数的方法获取集合中的第一个元素。如果集合为空，则Illuminate\Support\ItemNotFoundException 将抛出异常：
collect([])->firstOrFail();
// Throws ItemNotFoundException...
firstWhere()
这firstWhere 方法返回集合中具有给定键/值对的第一个元素：
$collection = collect([
['name' => 'Regena', 'age' => null],
['name' => 'Linda', 'age' => 14],
['name' => 'Diego', 'age' => 23],
['name' => 'Linda', 'age' => 84],
]);
$collection->firstWhere('name', 'Linda');
// ['name' => 'Linda', 'age' => 14]
您也可以致电firstWhere 带有比较运算符的方法：
$collection->firstWhere('age', '>=', 18);
// ['name' => 'Diego', 'age' => 23]
像where 方法，您可以将一个参数传递给firstWhere 方法。在这种情况下，firstWhere 方法将返回给定项键值为“truthy”的第一个项：
$collection->firstWhere('age');
// ['name' => 'Linda', 'age' => 14]
flatMap()
这flatMap 方法遍历集合并将每个值传递给给定的闭包。闭包可以自由修改项并返回，从而形成一个新的修改项集合。然后，数组被展平一层：
$collection = collect([
['name' => 'Sally'],
['school' => 'Arkansas'],
['age' => 28]
]);
$flattened = $collection->flatMap(function (array $values) {
return array_map('strtoupper', $values);
});
$flattened->all();
// ['name' => 'SALLY', 'school' => 'ARKANSAS', 'age' => '28'];
flatten()
这flatten 方法将多维集合展平为一个维度：
$collection = collect([
'name' => 'taylor',
'languages' => [
'php', 'javascript'
]
]);
$flattened = $collection->flatten();
$flattened->all();
// ['taylor', 'php', 'javascript'];
如有必要，您可以通过flatten 方法“深度”参数：
$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'],
]
*/
在这个例子中，调用flatten 如果不提供深度也会使嵌套数组变平，从而导致['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung'].提供深度允许您指定嵌套数组将被展平的级别数。
flip()
这flip 方法将集合的键与其相应的值交换：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$flipped = $collection->flip();
$flipped->all();
// ['taylor' => 'name', 'laravel' => 'framework']
forget()
这forget 方法通过其键从集合中删除一个项目：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$collection->forget('name');
$collection->all();
// ['framework' => 'laravel']
Warning
与大多数其他收集方法不同，forget不返回新修改的集合；它修改调用它的集合。
forPage()
这forPage 方法返回一个新集合，其中包含将出现在给定页码上的项目。该方法接受页码作为第一个参数，每页显示的项目数作为第二个参数：
$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
$chunk = $collection->forPage(2, 3);
$chunk->all();
// [4, 5, 6]
get()
这get 方法返回给定键处的项目。如果密钥不存在，null 返回：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$value = $collection->get('name');
// taylor
您可以选择将默认值作为第二个参数传递：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$value = $collection->get('age', 34);
// 34
您甚至可以将回调作为方法的默认值传递。如果指定的键不存在，将返回回调结果：
$collection->get('email', function () {
return 'taylor@example.com';
});
// taylor@example.com
groupBy()
这groupBy 方法按给定键对集合的项目进行分组：
$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->all();
/*
[
'account-x10' => [
['account_id' => 'account-x10', 'product' => 'Chair'],
['account_id' => 'account-x10', 'product' => 'Bookcase'],
],
'account-x11' => [
['account_id' => 'account-x11', 'product' => 'Desk'],
],
]
*/
而不是传递一个字符串key，你可以传递一个回调。回调应该返回您希望通过以下方式对组进行键控的值：
$grouped = $collection->groupBy(function (array $item, int $key) {
return substr($item['account_id'], -3);
});
$grouped->all();
/*
[
'x10' => [
['account_id' => 'account-x10', 'product' => 'Chair'],
['account_id' => 'account-x10', 'product' => 'Bookcase'],
],
'x11' => [
['account_id' => 'account-x11', 'product' => 'Desk'],
],
]
*/
多个分组标准可以作为数组传递。每个数组元素将应用于多维数组中的相应级别：
$data = new Collection([
10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
]);
$result = $data->groupBy(['skill', function (array $item) {
return $item['roles'];
}], preserveKeys: true);
/*
[
1 => [
'Role_1' => [
10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
],
'Role_2' => [
20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']],
],
'Role_3' => [
10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
],
],
2 => [
'Role_1' => [
30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']],
],
'Role_2' => [
40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']],
],
],
];
*/
has()
这has 方法确定集合中是否存在给定键：
$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
$collection->has('product');
// true
$collection->has(['product', 'amount']);
// true
$collection->has(['amount', 'price']);
// false
hasAny()
这hasAny 方法确定集合中是否存在任何给定键：
$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
$collection->hasAny(['product', 'price']);
// true
$collection->hasAny(['name', 'price']);
// false
implode()
这implode 方法连接集合中的项目。它的参数取决于集合中项目的类型。如果集合包含数组或对象，您应该传递您希望加入的属性的键，以及您希望放置在值之间的“胶水”字符串：
$collection = collect([
['account_id' => 1, 'product' => 'Desk'],
['account_id' => 2, 'product' => 'Chair'],
]);
$collection->implode('product', ', ');
// Desk, Chair
如果集合包含简单的字符串或数值，则应将“胶水”作为唯一参数传递给该方法：
collect([1, 2, 3, 4, 5])->implode('-');
// '1-2-3-4-5'
您可以将闭包传递给implode 方法，如果你想格式化被内爆的值：
$collection->implode(function (array $item, int $key) {
return strtoupper($item['product']);
}, ', ');
// DESK, CHAIR
intersect()
这intersect 方法从原始集合中删除给定中不存在的任何值array 或收藏。生成的集合将保留原始集合的键：
$collection = collect(['Desk', 'Sofa', 'Chair']);
$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
$intersect->all();
// [0 => 'Desk', 2 => 'Chair']
Note
使用时修改此方法的行为雄辩的收藏.
intersectByKeys()
这intersectByKeys 方法从原始集合中删除给定中不存在的任何键及其对应值array 或收藏：
$collection = collect([
'serial' => 'UX301', 'type' => 'screen', 'year' => 2009,
]);
$intersect = $collection->intersectByKeys([
'reference' => 'UX404', 'type' => 'tab', 'year' => 2011,
]);
$intersect->all();
// ['type' => 'screen', 'year' => 2009]
isEmpty()
这isEmpty 方法返回true 如果集合为空；否则，false 返回：
collect([])->isEmpty();
// true
isNotEmpty()
这isNotEmpty 方法返回true 如果集合不为空；否则，false 返回：
collect([])->isNotEmpty();
// false
join()
这join 方法将集合的值与字符串连接起来。使用此方法的第二个参数，您还可以指定如何将最终元素附加到字符串：
collect(['a', 'b', 'c'])->join(', '); // 'a, b, c'
collect(['a', 'b', 'c'])->join(', ', ', and '); // 'a, b, and c'
collect(['a', 'b'])->join(', ', ' and '); // 'a and b'
collect(['a'])->join(', ', ' and '); // 'a'
collect([])->join(', ', ' and '); // ''
keyBy()
这keyBy 方法通过给定的键对集合进行键控。如果多个项目具有相同的键，则只有最后一个项目会出现在新集合中：
$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'],
]
*/
您还可以将回调传递给该方法。回调应该通过以下方式将值返回到集合中：
$keyed = $collection->keyBy(function (array $item, int $key) {
return strtoupper($item['product_id']);
});
$keyed->all();
/*
[
'PROD-100' => ['product_id' => 'prod-100', 'name' => 'Desk'],
'PROD-200' => ['product_id' => 'prod-200', 'name' => 'Chair'],
]
*/
keys()
这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()
这last 方法返回集合中通过给定真值测试的最后一个元素：
collect([1, 2, 3, 4])->last(function (int $value, int $key) {
return $value < 3;
});
// 2
您也可以致电last 不带参数的方法获取集合中的最后一个元素。如果集合为空，null 返回：
collect([1, 2, 3, 4])->last();
// 4
lazy()
这lazy 方法返回一个新的LazyCollection 来自底层项目数组的实例：
$lazyCollection = collect([1, 2, 3, 4])->lazy();
get_class($lazyCollection);
// Illuminate\Support\LazyCollection
$lazyCollection->all();
// [1, 2, 3, 4]
当您需要对一个巨大的对象执行转换时，这尤其有用Collection 其中包含许多项目：
$count = $hugeCollection
->lazy()
->where('country', 'FR')
->where('balance', '>', '100')
->count();
通过将集合转换为LazyCollection，我们避免分配大量额外的内存。虽然原始收藏仍然保留its 内存中的值，后续过滤器将不会。因此，在过滤集合的结果时，实际上不会分配额外的内存。
macro()
静态的macro 方法允许您将方法添加到Collection 运行时的类。请参阅文档扩展集合 了解更多信息。
make()
静态的make 方法创建一个新的集合实例。见创建集合 部分。
map()
这map 方法遍历集合并将每个值传递给给定的回调。回调可以自由修改item并返回，这样就形成了一个新的修改item的集合：
$collection = collect([1, 2, 3, 4, 5]);
$multiplied = $collection->map(function (int $item, int $key) {
return $item * 2;
});
$multiplied->all();
// [2, 4, 6, 8, 10]
Warning
与大多数其他收集方法一样，map返回一个新的集合实例；它不会修改调用它的集合。如果要转换原始集合，请使用transform方法。
mapInto()
这mapInto() 方法遍历集合，通过将值传递给构造函数来创建给定类的新实例：
class Currency
{
/**
* Create a new currency instance.
*/
function __construct(
public string $code
) {}
}
$collection = collect(['USD', 'EUR', 'GBP']);
$currencies = $collection->mapInto(Currency::class);
$currencies->all();
// [Currency('USD'), Currency('EUR'), Currency('GBP')]
mapSpread()
这mapSpread 方法遍历集合的项目，将每个嵌套的项目值传递到给定的闭包中。闭包可以自由修改项并返回，从而形成一个新的修改项集合：
$collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
$chunks = $collection->chunk(2);
$sequence = $chunks->mapSpread(function (int $even, int $odd) {
return $even + $odd;
});
$sequence->all();
// [1, 5, 9, 13, 17]
mapToGroups()
这mapToGroups 方法通过给定的闭包对集合的项目进行分组。闭包应该返回一个包含单个键/值对的关联数组，从而形成一个新的分组值集合：
$collection = collect([
[
'name' => 'John Doe',
'department' => 'Sales',
],
[
'name' => 'Jane Doe',
'department' => 'Sales',
],
[
'name' => 'Johnny Doe',
'department' => 'Marketing',
]
]);
$grouped = $collection->mapToGroups(function (array $item, int $key) {
return [$item['department'] => $item['name']];
});
$grouped->all();
/*
[
'Sales' => ['John Doe', 'Jane Doe'],
'Marketing' => ['Johnny Doe'],
]
*/
$grouped->get('Sales')->all();
// ['John Doe', 'Jane Doe']
mapWithKeys()
这mapWithKeys 方法遍历集合并将每个值传递给给定的回调。回调应该返回一个包含单个键/值对的关联数组：
$collection = collect([
[
'name' => 'John',
'department' => 'Sales',
'email' => 'john@example.com',
],
[
'name' => 'Jane',
'department' => 'Marketing',
'email' => 'jane@example.com',
]
]);
$keyed = $collection->mapWithKeys(function (array $item, int $key) {
return [$item['email'] => $item['name']];
});
$keyed->all();
/*
[
'john@example.com' => 'John',
'jane@example.com' => 'Jane',
]
*/
max()
这max 方法返回给定键的最大值：
$max = collect([
['foo' => 10],
['foo' => 20]
])->max('foo');
// 20
$max = collect([1, 2, 3, 4, 5])->max();
// 5
median()
这median 方法返回中值 给定键的：
$median = collect([
['foo' => 10],
['foo' => 10],
['foo' => 20],
['foo' => 40]
])->median('foo');
// 15
$median = collect([1, 1, 2, 4])->median();
// 1.5
merge()
这merge 方法将给定的数组或集合与原始集合合并。如果给定项中的字符串键与原始集合中的字符串键匹配，则给定项的值将覆盖原始集合中的值：
$collection = collect(['product_id' => 1, 'price' => 100]);
$merged = $collection->merge(['price' => 200, 'discount' => false]);
$merged->all();
// ['product_id' => 1, 'price' => 200, 'discount' => false]
如果给定项的键是数字，则值将附加到集合的末尾：
$collection = collect(['Desk', 'Chair']);
$merged = $collection->merge(['Bookcase', 'Door']);
$merged->all();
// ['Desk', 'Chair', 'Bookcase', 'Door']
mergeRecursive()
这mergeRecursive 方法将给定的数组或集合递归地与原始集合合并。如果给定项中的字符串键与原始集合中的字符串键匹配，则这些键的值将合并到一个数组中，这是递归完成的：
$collection = collect(['product_id' => 1, 'price' => 100]);
$merged = $collection->mergeRecursive([
'product_id' => 2,
'price' => 200,
'discount' => false
]);
$merged->all();
// ['product_id' => [1, 2], 'price' => [100, 200], 'discount' => false]
min()
这min 方法返回给定键的最小值：
$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');
// 10
$min = collect([1, 2, 3, 4, 5])->min();
// 1
mode()
这mode 方法返回模式值 给定键的：
$mode = collect([
['foo' => 10],
['foo' => 10],
['foo' => 20],
['foo' => 40]
])->mode('foo');
// [10]
$mode = collect([1, 1, 2, 4])->mode();
// [1]
$mode = collect([1, 1, 2, 2])->mode();
// [1, 2]
nth()
这nth 方法创建一个由每个第 n 个元素组成的新集合：
$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
$collection->nth(4);
// ['a', 'e']
您可以选择将起始偏移量作为第二个参数传递：
$collection->nth(4, 1);
// ['b', 'f']
only()
这only 方法返回集合中具有指定键的项目：
$collection = collect([
'product_id' => 1,
'name' => 'Desk',
'price' => 100,
'discount' => false
]);
$filtered = $collection->only(['product_id', 'name']);
$filtered->all();
// ['product_id' => 1, 'name' => 'Desk']
对于的倒数only, 看到except 方法。
Note
使用时修改此方法的行为雄辩的收藏.
pad()
这pad 方法将用给定的值填充数组，直到数组达到指定的大小。此方法的行为类似于array_pad PHP函数。
要向左填充，您应该指定负数。如果给定大小的绝对值小于或等于数组的长度，则不会进行填充：
$collection = collect(['A', 'B', 'C']);
$filtered = $collection->pad(5, 0);
$filtered->all();
// ['A', 'B', 'C', 0, 0]
$filtered = $collection->pad(-5, 0);
$filtered->all();
// [0, 0, 'A', 'B', 'C']
partition()
这partition 方法可以与 PHP 数组解构相结合，以将通过给定真值测试的元素与未通过给定真值测试的元素分开：
$collection = collect([1, 2, 3, 4, 5, 6]);
[$underThree, $equalOrAboveThree] = $collection->partition(function (int $i) {
return $i < 3;
});
$underThree->all();
// [1, 2]
$equalOrAboveThree->all();
// [3, 4, 5, 6]
pipe()
这pipe 方法将集合传递给给定的闭包并返回执行闭包的结果：
$collection = collect([1, 2, 3]);
$piped = $collection->pipe(function (Collection $collection) {
return $collection->sum();
});
// 6
pipeInto()
这pipeInto 方法创建给定类的新实例并将集合传递给构造函数：
class ResourceCollection
{
/**
* Create a new ResourceCollection instance.
*/
public function __construct(
public Collection $collection,
) {}
}
$collection = collect([1, 2, 3]);
$resource = $collection->pipeInto(ResourceCollection::class);
$resource->collection->all();
// [1, 2, 3]
pipeThrough()
这pipeThrough 方法将集合传递给给定的闭包数组并返回执行闭包的结果：
use Illuminate\Support\Collection;
$collection = collect([1, 2, 3]);
$result = $collection->pipeThrough([
function (Collection $collection) {
return $collection->merge([4, 5]);
},
function (Collection $collection) {
return $collection->sum();
},
]);
// 15
pluck()
这pluck 方法检索给定键的所有值：
$collection = collect([
['product_id' => 'prod-100', 'name' => 'Desk'],
['product_id' => 'prod-200', 'name' => 'Chair'],
]);
$plucked = $collection->pluck('name');
$plucked->all();
// ['Desk', 'Chair']
您还可以指定您希望结果集合的键控方式：
$plucked = $collection->pluck('name', 'product_id');
$plucked->all();
// ['prod-100' => 'Desk', 'prod-200' => 'Chair']
这pluck 方法还支持使用“点”表示法检索嵌套值：
$collection = collect([
[
'name' => 'Laracon',
'speakers' => [
'first_day' => ['Rosa', 'Judith'],
],
],
[
'name' => 'VueConf',
'speakers' => [
'first_day' => ['Abigail', 'Joey'],
],
],
]);
$plucked = $collection->pluck('speakers.first_day');
$plucked->all();
// [['Rosa', 'Judith'], ['Abigail', 'Joey']]
如果存在重复的键，最后一个匹配的元素将被插入到 plucked 集合中：
$collection = collect([
['brand' => 'Tesla', 'color' => 'red'],
['brand' => 'Pagani', 'color' => 'white'],
['brand' => 'Tesla', 'color' => 'black'],
['brand' => 'Pagani', 'color' => 'orange'],
]);
$plucked = $collection->pluck('color', 'brand');
$plucked->all();
// ['Tesla' => 'black', 'Pagani' => 'orange']
pop()
这pop 方法从集合中删除并返回最后一项：
$collection = collect([1, 2, 3, 4, 5]);
$collection->pop();
// 5
$collection->all();
// [1, 2, 3, 4]
您可以将一个整数传递给pop 从集合末尾删除和返回多个项目的方法：
$collection = collect([1, 2, 3, 4, 5]);
$collection->pop(3);
// collect([5, 4, 3])
$collection->all();
// [1, 2]
prepend()
这prepend 方法将一个项目添加到集合的开头：
$collection = collect([1, 2, 3, 4, 5]);
$collection->prepend(0);
$collection->all();
// [0, 1, 2, 3, 4, 5]
您还可以传递第二个参数来指定前置项的键：
$collection = collect(['one' => 1, 'two' => 2]);
$collection->prepend(0, 'zero');
$collection->all();
// ['zero' => 0, 'one' => 1, 'two' => 2]
pull()
这pull 方法通过其键从集合中删除并返回一个项目：
$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);
$collection->pull('name');
// 'Desk'
$collection->all();
// ['product_id' => 'prod-100']
push()
这push 方法将一个项目附加到集合的末尾：
$collection = collect([1, 2, 3, 4]);
$collection->push(5);
$collection->all();
// [1, 2, 3, 4, 5]
put()
这put 方法在集合中设置给定的键和值：
$collection = collect(['product_id' => 1, 'name' => 'Desk']);
$collection->put('price', 100);
$collection->all();
// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]
random()
这random 方法从集合中返回一个随机项：
$collection = collect([1, 2, 3, 4, 5]);
$collection->random();
// 4 - (retrieved randomly)
您可以将整数传递给random 指定要随机检索的项目数。当显式传递您希望接收的项目数时，总是返回项目集合：
$random = $collection->random(3);
$random->all();
// [2, 4, 5] - (retrieved randomly)
如果集合实例中的项少于请求的项，则random 方法将抛出一个InvalidArgumentException.
这random 方法还接受一个闭包，它将接收当前的集合实例：
use Illuminate\Support\Collection;
$random = $collection->random(fn (Collection $items) => min(10, count($items)));
$random->all();
// [1, 2, 3, 4, 5] - (retrieved randomly)
range()
这range 方法返回包含指定范围内的整数的集合：
$collection = collect()->range(3, 6);
$collection->all();
// [3, 4, 5, 6]
reduce()
这reduce 方法将集合缩减为单个值，将每次迭代的结果传递给后续迭代：
$collection = collect([1, 2, 3]);
$total = $collection->reduce(function (int $carry, int $item) {
return $carry + $item;
});
// 6
的价值$carry 第一次迭代是null;但是，您可以通过将第二个参数传递给reduce:
$collection->reduce(function (int $carry, int $item) {
return $carry + $item;
}, 4);
// 10
这reduce 方法还将关联集合中的数组键传递给给定的回调：
$collection = collect([
'usd' => 1400,
'gbp' => 1200,
'eur' => 1000,
]);
$ratio = [
'usd' => 1,
'gbp' => 1.37,
'eur' => 1.22,
];
$collection->reduce(function (int $carry, int $value, int $key) use ($ratio) {
return $carry + ($value * $ratio[$key]);
});
// 4264
reduceSpread()
这reduceSpread 方法将集合缩减为值数组，将每次迭代的结果传递给后续迭代。这种方法类似于reduce 方法;但是，它可以接受多个初始值：
[$creditsRemaining, $batch] = Image::where('status', 'unprocessed')
->get()
->reduceSpread(function (int $creditsRemaining, Collection $batch, Image $image) {
if ($creditsRemaining >= $image->creditsRequired()) {
$batch->push($image);
$creditsRemaining -= $image->creditsRequired();
}
return [$creditsRemaining, $batch];
}, $creditsAvailable, collect());
reject()
这reject 方法使用给定的闭包过滤集合。闭包应该返回true 如果该项目应该从结果集合中删除：
$collection = collect([1, 2, 3, 4]);
$filtered = $collection->reject(function (int $value, int $key) {
return $value > 2;
});
$filtered->all();
// [1, 2]
对于的倒数reject 方法，见filter 方法。
replace()
这replace 方法的行为类似于merge;然而，除了覆盖具有字符串键的匹配项之外，replace 方法还将覆盖集合中具有匹配数字键的项目：
$collection = collect(['Taylor', 'Abigail', 'James']);
$replaced = $collection->replace([1 => 'Victoria', 3 => 'Finn']);
$replaced->all();
// ['Taylor', 'Victoria', 'James', 'Finn']
replaceRecursive()
这种方法就像replace，但它会重复出现在数组中，并对内部值应用相同的替换过程：
$collection = collect([
'Taylor',
'Abigail',
[
'James',
'Victoria',
'Finn'
]
]);
$replaced = $collection->replaceRecursive([
'Charlie',
2 => [1 => 'King']
]);
$replaced->all();
// ['Charlie', 'Abigail', ['James', 'King', 'Finn']]
reverse()
这reverse 方法反转集合项的顺序，保留原始键：
$collection = collect(['a', 'b', 'c', 'd', 'e']);
$reversed = $collection->reverse();
$reversed->all();
/*
[
4 => 'e',
3 => 'd',
2 => 'c',
1 => 'b',
0 => 'a',
]
*/
search()
这search 方法在集合中搜索给定值，如果找到则返回其键。如果找不到该项目，false 返回：
$collection = collect([2, 4, 6, 8]);
$collection->search(4);
// 1
搜索是使用“松散”比较完成的，这意味着具有整数值的字符串将被视为等于具有相同值的整数。要使用“严格”比较，通过true 作为方法的第二个参数：
collect([2, 4, 6, 8])->search('4', $strict = true);
// false
或者，您可以提供自己的闭包来搜索通过给定真值测试的第一个项目：
collect([2, 4, 6, 8])->search(function (int $item, int $key) {
return $item > 5;
});
// 2
shift()
这shift 方法从集合中删除并返回第一项：
$collection = collect([1, 2, 3, 4, 5]);
$collection->shift();
// 1
$collection->all();
// [2, 3, 4, 5]
您可以将一个整数传递给shift 从集合开头移除和返回多个项目的方法：
$collection = collect([1, 2, 3, 4, 5]);
$collection->shift(3);
// collect([1, 2, 3])
$collection->all();
// [4, 5]
shuffle()
这shuffle 方法随机洗牌集合中的项目：
$collection = collect([1, 2, 3, 4, 5]);
$shuffled = $collection->shuffle();
$shuffled->all();
// [3, 2, 5, 1, 4] - (generated randomly)
skip()
这skip 方法返回一个新集合，从集合的开头删除给定数量的元素：
$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
$collection = $collection->skip(4);
$collection->all();
// [5, 6, 7, 8, 9, 10]
skipUntil()
这skipUntil 方法跳过集合中的项目，直到给定的回调返回true 然后将集合中的剩余项作为新的集合实例返回：
$collection = collect([1, 2, 3, 4]);
$subset = $collection->skipUntil(function (int $item) {
return $item >= 3;
});
$subset->all();
// [3, 4]
您也可以将一个简单的值传递给skipUntil 跳过所有项目直到找到给定值的方法：
$collection = collect([1, 2, 3, 4]);
$subset = $collection->skipUntil(3);
$subset->all();
// [3, 4]
Warning
如果未找到给定值或回调永远不会返回true， 这skipUntil方法将返回一个空集合。
skipWhile()
这skipWhile 方法在给定的回调返回时跳过集合中的项目true 然后将集合中的剩余项作为新集合返回：
$collection = collect([1, 2, 3, 4]);
$subset = $collection->skipWhile(function (int $item) {
return $item <= 3;
});
$subset->all();
// [4]
Warning
如果回调永远不会返回false， 这skipWhile方法将返回一个空集合。
slice()
这slice 方法返回从给定索引开始的集合的一部分：
$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
$slice = $collection->slice(4);
$slice->all();
// [5, 6, 7, 8, 9, 10]
如果您想限制返回切片的大小，请将所需大小作为第二个参数传递给该方法：
$slice = $collection->slice(4, 2);
$slice->all();
// [5, 6]
默认情况下，返回的切片将保留键。如果您不想保留原始密钥，可以使用values 重新索引它们的方法。
sliding()
这sliding 方法返回一个新的块集合，表示集合中项目的“滑动窗口”视图：
$collection = collect([1, 2, 3, 4, 5]);
$chunks = $collection->sliding(2);
$chunks->toArray();
// [[1, 2], [2, 3], [3, 4], [4, 5]]
这在与eachSpread 方法：
$transactions->sliding(2)->eachSpread(function (Collection $previous, Collection $current) {
$current->total = $previous->total + $current->amount;
});
您可以选择传递第二个“step”值，它确定每个块的第一项之间的距离：
$collection = collect([1, 2, 3, 4, 5]);
$chunks = $collection->sliding(3, step: 2);
$chunks->toArray();
// [[1, 2, 3], [3, 4, 5]]
sole()
这sole 方法返回集合中第一个通过给定真值测试的元素，但前提是真值测试与一个元素完全匹配：
collect([1, 2, 3, 4])->sole(function (int $value, int $key) {
return $value === 2;
});
// 2
您还可以将键/值对传递给sole 方法，它将返回集合中与给定对匹配的第一个元素，但前提是只有一个元素匹配：
$collection = collect([
['product' => 'Desk', 'price' => 200],
['product' => 'Chair', 'price' => 100],
]);
$collection->sole('product', 'Chair');
// ['product' => 'Chair', 'price' => 100]
或者，您也可以致电sole 如果只有一个元素，则不带参数的方法获取集合中的第一个元素：
$collection = collect([
['product' => 'Desk', 'price' => 200],
]);
$collection->sole();
// ['product' => 'Desk', 'price' => 200]
如果集合中没有应该由sole 方法，一个\Illuminate\Collections\ItemNotFoundException 将抛出异常。如果应该返回一个以上的元素，一个\Illuminate\Collections\MultipleItemsFoundException 将被抛出。
some()
的别名contains 方法。
sort()
这sort 方法对集合进行排序。已排序的集合保留了原始数组键，因此在下面的示例中我们将使用values 将键重置为连续编号索引的方法：
$collection = collect([5, 3, 1, 2, 4]);
$sorted = $collection->sort();
$sorted->values()->all();
// [1, 2, 3, 4, 5]
如果您的排序需求更高级，您可以将回调传递给sort 用你自己的算法。请参阅 PHP 文档uasort，这是集合的sort 方法调用在内部使用。
Note
如果您需要对嵌套数组或对象的集合进行排序，请参阅sortBy和sortByDesc方法。
sortBy()
这sortBy 方法按给定的键对集合进行排序。已排序的集合保留了原始数组键，因此在下面的示例中我们将使用values 将键重置为连续编号索引的方法：
$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],
]
*/
这sortBy 方法接受排序标志 作为它的第二个参数：
$collection = collect([
['title' => 'Item 1'],
['title' => 'Item 12'],
['title' => 'Item 3'],
]);
$sorted = $collection->sortBy('title', SORT_NATURAL);
$sorted->values()->all();
/*
[
['title' => 'Item 1'],
['title' => 'Item 3'],
['title' => 'Item 12'],
]
*/
或者，您可以传递自己的闭包来确定如何对集合的值进行排序：
$collection = collect([
['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
['name' => 'Chair', 'colors' => ['Black']],
['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
]);
$sorted = $collection->sortBy(function (array $product, int $key) {
return count($product['colors']);
});
$sorted->values()->all();
/*
[
['name' => 'Chair', 'colors' => ['Black']],
['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
]
*/
如果您想按多个属性对集合进行排序，您可以将排序操作数组传递给sortBy 方法。每个排序操作应该是一个数组，由您希望排序的属性和所需排序的方向组成：
$collection = collect([
['name' => 'Taylor Otwell', 'age' => 34],
['name' => 'Abigail Otwell', 'age' => 30],
['name' => 'Taylor Otwell', 'age' => 36],
['name' => 'Abigail Otwell', 'age' => 32],
]);
$sorted = $collection->sortBy([
['name', 'asc'],
['age', 'desc'],
]);
$sorted->values()->all();
/*
[
['name' => 'Abigail Otwell', 'age' => 32],
['name' => 'Abigail Otwell', 'age' => 30],
['name' => 'Taylor Otwell', 'age' => 36],
['name' => 'Taylor Otwell', 'age' => 34],
]
*/
当按多个属性对集合进行排序时，您还可以提供定义每个排序操作的闭包：
$collection = collect([
['name' => 'Taylor Otwell', 'age' => 34],
['name' => 'Abigail Otwell', 'age' => 30],
['name' => 'Taylor Otwell', 'age' => 36],
['name' => 'Abigail Otwell', 'age' => 32],
]);
$sorted = $collection->sortBy([
fn (array $a, array $b) => $a['name'] <=> $b['name'],
fn (array $a, array $b) => $b['age'] <=> $a['age'],
]);
$sorted->values()->all();
/*
[
['name' => 'Abigail Otwell', 'age' => 32],
['name' => 'Abigail Otwell', 'age' => 30],
['name' => 'Taylor Otwell', 'age' => 36],
['name' => 'Taylor Otwell', 'age' => 34],
]
*/
sortByDesc()
此方法具有与sortBy 方法，但会以相反的顺序对集合进行排序。
sortDesc()
此方法将以相反的顺序对集合进行排序sort 方法：
$collection = collect([5, 3, 1, 2, 4]);
$sorted = $collection->sortDesc();
$sorted->values()->all();
// [5, 4, 3, 2, 1]
不像sort，你不能将闭包传递给sortDesc.相反，您应该使用sort 方法并反转你的比较。
sortKeys()
这sortKeys 方法通过底层关联数组的键对集合进行排序：
$collection = collect([
'id' => 22345,
'first' => 'John',
'last' => 'Doe',
]);
$sorted = $collection->sortKeys();
$sorted->all();
/*
[
'first' => 'John',
'id' => 22345,
'last' => 'Doe',
]
*/
sortKeysDesc()
此方法具有与sortKeys 方法，但会以相反的顺序对集合进行排序。
sortKeysUsing()
这sortKeysUsing 方法使用回调按底层关联数组的键对集合进行排序：
$collection = collect([
'ID' => 22345,
'first' => 'John',
'last' => 'Doe',
]);
$sorted = $collection->sortKeysUsing('strnatcasecmp');
$sorted->all();
/*
[
'first' => 'John',
'ID' => 22345,
'last' => 'Doe',
]
*/
回调必须是一个比较函数，它返回一个小于、等于或大于零的整数。有关更多信息，请参阅 PHP 文档uksort, 这是 PHP 函数sortKeysUsing 方法在内部使用。
splice()
这splice 方法删除并返回从指定索引开始的项目切片：
$collection = collect([1, 2, 3, 4, 5]);
$chunk = $collection->splice(2);
$chunk->all();
// [3, 4, 5]
$collection->all();
// [1, 2]
您可以传递第二个参数来限制结果集合的大小：
$collection = collect([1, 2, 3, 4, 5]);
$chunk = $collection->splice(2, 1);
$chunk->all();
// [3]
$collection->all();
// [1, 2, 4, 5]
此外，您可以传递包含新项目的第三个参数来替换从集合中删除的项目：
$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()
这split 方法将集合分成给定数量的组：
$collection = collect([1, 2, 3, 4, 5]);
$groups = $collection->split(3);
$groups->all();
// [[1, 2], [3, 4], [5]]
splitIn()
这splitIn 方法将集合分成给定数量的组，在将剩余组分配给最终组之前完全填充非终结组：
$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
$groups = $collection->splitIn(3);
$groups->all();
// [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10]]
sum()
这sum 方法返回集合中所有项目的总和：
collect([1, 2, 3, 4, 5])->sum();
// 15
如果集合包含嵌套数组或对象，您应该传递一个键，该键将用于确定要对哪些值求和：
$collection = collect([
['name' => 'JavaScript: The Good Parts', 'pages' => 176],
['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096],
]);
$collection->sum('pages');
// 1272
此外，您可以通过自己的闭包来确定要对集合的哪些值求和：
$collection = collect([
['name' => 'Chair', 'colors' => ['Black']],
['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
['name' => 'Bookcase', 'colors' => ['Red', 'Beige', 'Brown']],
]);
$collection->sum(function (array $product) {
return count($product['colors']);
});
// 6
take()
这take 方法返回具有指定数量项目的新集合：
$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(3);
$chunk->all();
// [0, 1, 2]
您还可以传递一个负整数以从集合末尾获取指定数量的项目：
$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(-2);
$chunk->all();
// [4, 5]
takeUntil()
这takeUntil 方法返回集合中的项目，直到给定的回调返回true:
$collection = collect([1, 2, 3, 4]);
$subset = $collection->takeUntil(function (int $item) {
return $item >= 3;
});
$subset->all();
// [1, 2]
您也可以将一个简单的值传递给takeUntil 获取项目直到找到给定值的方法：
$collection = collect([1, 2, 3, 4]);
$subset = $collection->takeUntil(3);
$subset->all();
// [1, 2]
Warning
如果未找到给定值或回调永远不会返回true， 这takeUntil方法将返回集合中的所有项目。
takeWhile()
这takeWhile 方法返回集合中的项目，直到给定的回调返回false:
$collection = collect([1, 2, 3, 4]);
$subset = $collection->takeWhile(function (int $item) {
return $item < 3;
});
$subset->all();
// [1, 2]
Warning
如果回调永远不会返回false， 这takeWhile方法将返回集合中的所有项目。
tap()
这tap 方法将集合传递给给定的回调，允许您在特定点“点击”集合并在不影响集合本身的情况下对项目执行某些操作。该集合然后由tap 方法：
collect([2, 4, 3, 1, 5])
->sort()
->tap(function (Collection $collection) {
Log::debug('Values after sorting', $collection->values()->all());
})
->shift();
// 1
times()
静态的times 方法通过调用给定闭包指定次数来创建一个新集合：
$collection = Collection::times(10, function (int $number) {
return $number * 9;
});
$collection->all();
// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
toArray()
这toArray 方法将集合转换为纯 PHParray.如果集合的值是Eloquent 模型，模型也将被转换为数组：
$collection = collect(['name' => 'Desk', 'price' => 200]);
$collection->toArray();
/*
[
['name' => 'Desk', 'price' => 200],
]
*/
Warning
toArray还转换集合的所有嵌套对象，这些对象是Arrayable到一个数组。如果要获取集合下的原始数组，请使用all方法代替。
toJson()
这toJson 方法将集合转换为 JSON 序列化字符串：
$collection = collect(['name' => 'Desk', 'price' => 200]);
$collection->toJson();
// '{"name":"Desk", "price":200}'
transform()
这transform 方法遍历集合并调用集合中每个项目的给定回调。集合中的项目将被回调返回的值替换：
$collection = collect([1, 2, 3, 4, 5]);
$collection->transform(function (int $item, int $key) {
return $item * 2;
});
$collection->all();
// [2, 4, 6, 8, 10]
Warning
与大多数其他收集方法不同，transform修改集合本身。如果您希望创建一个新集合，请使用map方法。
undot()
这undot 方法将使用“点”表示法的一维集合扩展为多维集合：
$person = collect([
'name.first_name' => 'Marie',
'name.last_name' => 'Valentine',
'address.line_1' => '2992 Eagle Drive',
'address.line_2' => '',
'address.suburb' => 'Detroit',
'address.state' => 'MI',
'address.postcode' => '48219'
]);
$person = $person->undot();
$person->toArray();
/*
[
"name" => [
"first_name" => "Marie",
"last_name" => "Valentine",
],
"address" => [
"line_1" => "2992 Eagle Drive",
"line_2" => "",
"suburb" => "Detroit",
"state" => "MI",
"postcode" => "48219",
],
]
*/
union()
这union 方法将给定的数组添加到集合中。如果给定数组包含原始集合中已有的键，则将首选原始集合的值：
$collection = collect([1 => ['a'], 2 => ['b']]);
$union = $collection->union([3 => ['c'], 1 => ['d']]);
$union->all();
// [1 => ['a'], 2 => ['b'], 3 => ['c']]
unique()
这unique 方法返回集合中的所有唯一项。返回的集合保留了原始数组键，所以在下面的例子中我们将使用values 将键重置为连续编号索引的方法：
$collection = collect([1, 1, 2, 2, 3, 4, 2]);
$unique = $collection->unique();
$unique->values()->all();
// [1, 2, 3, 4]
在处理嵌套数组或对象时，您可以指定用于确定唯一性的键：
$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'],
]
*/
最后，您还可以将自己的闭包传递给unique 方法来指定哪个值应该确定项目的唯一性：
$unique = $collection->unique(function (array $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'],
]
*/
这unique 方法在检查项目值时使用“松散”比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。使用uniqueStrict 使用“严格”比较进行过滤的方法。
Note
使用时修改此方法的行为雄辩的收藏.
uniqueStrict()
此方法具有与unique 方法;但是，所有值都使用“严格”比较进行比较。
unless()
这unless 方法将执行给定的回调，除非给方法的第一个参数的计算结果为true:
$collection = collect([1, 2, 3]);
$collection->unless(true, function (Collection $collection) {
return $collection->push(4);
});
$collection->unless(false, function (Collection $collection) {
return $collection->push(5);
});
$collection->all();
// [1, 2, 3, 5]
可以将第二个回调传递给unless 方法。第二个回调将在第一个参数传递给unless 方法评估为true:
$collection = collect([1, 2, 3]);
$collection->unless(true, function (Collection $collection) {
return $collection->push(4);
}, function (Collection $collection) {
return $collection->push(5);
});
$collection->all();
// [1, 2, 3, 5]
对于的倒数unless, 看到when 方法。
unlessEmpty()
的别名whenNotEmpty 方法。
unlessNotEmpty()
的别名whenEmpty 方法。
unwrap()
静态的unwrap 方法在适用时从给定值返回集合的基础项：
Collection::unwrap(collect('John Doe'));
// ['John Doe']
Collection::unwrap(['John Doe']);
// ['John Doe']
Collection::unwrap('John Doe');
// 'John Doe'
value()
这value 方法从集合的第一个元素中检索给定值：
$collection = collect([
['product' => 'Desk', 'price' => 200],
['product' => 'Speaker', 'price' => 400],
]);
$value = $collection->value('price');
// 200
values()
这values 方法返回一个新集合，其中的键重置为连续的整数：
$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],
]
*/
when()
这when 当提供给方法的第一个参数的计算结果为时，方法将执行给定的回调true.集合实例和给定的第一个参数when 方法将提供给闭包：
$collection = collect([1, 2, 3]);
$collection->when(true, function (Collection $collection, int $value) {
return $collection->push(4);
});
$collection->when(false, function (Collection $collection, int $value) {
return $collection->push(5);
});
$collection->all();
// [1, 2, 3, 4]
可以将第二个回调传递给when 方法。第二个回调将在第一个参数传递给when 方法评估为false:
$collection = collect([1, 2, 3]);
$collection->when(false, function (Collection $collection, int $value) {
return $collection->push(4);
}, function (Collection $collection) {
return $collection->push(5);
});
$collection->all();
// [1, 2, 3, 5]
对于的倒数when, 看到unless方法。
whenEmpty()
这whenEmpty 方法将在集合为空时执行给定的回调：
$collection = collect(['Michael', 'Tom']);
$collection->whenEmpty(function (Collection $collection) {
return $collection->push('Adam');
});
$collection->all();
// ['Michael', 'Tom']
$collection = collect();
$collection->whenEmpty(function (Collection $collection) {
return $collection->push('Adam');
});
$collection->all();
// ['Adam']
可以将第二个闭包传递给whenEmpty 当集合不为空时执行的方法：
$collection = collect(['Michael', 'Tom']);
$collection->whenEmpty(function (Collection $collection) {
return $collection->push('Adam');
}, function (Collection $collection) {
return $collection->push('Taylor');
});
$collection->all();
// ['Michael', 'Tom', 'Taylor']
对于的倒数whenEmpty, 看到whenNotEmpty 方法。
whenNotEmpty()
这whenNotEmpty 当集合不为空时，方法将执行给定的回调：
$collection = collect(['michael', 'tom']);
$collection->whenNotEmpty(function (Collection $collection) {
return $collection->push('adam');
});
$collection->all();
// ['michael', 'tom', 'adam']
$collection = collect();
$collection->whenNotEmpty(function (Collection $collection) {
return $collection->push('adam');
});
$collection->all();
// []
可以将第二个闭包传递给whenNotEmpty 集合为空时执行的方法：
$collection = collect();
$collection->whenNotEmpty(function (Collection $collection) {
return $collection->push('adam');
}, function (Collection $collection) {
return $collection->push('taylor');
});
$collection->all();
// ['taylor']
对于的倒数whenNotEmpty, 看到whenEmpty 方法。
where()
这where 方法通过给定的键/值对过滤集合：
$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],
]
*/
这where 方法在检查项目值时使用“松散”比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。使用whereStrict 使用“严格”比较进行过滤的方法。
或者，您可以将比较运算符作为第二个参数传递。支持的运算符有：'==='、'!=='、'!='、'=='、'='、'<>'、'>'、'<'、'>=' 和 ' <=':
$collection = collect([
['name' => 'Jim', 'deleted_at' => '2019-01-01 00:00:00'],
['name' => 'Sally', 'deleted_at' => '2019-01-02 00:00:00'],
['name' => 'Sue', 'deleted_at' => null],
]);
$filtered = $collection->where('deleted_at', '!=', null);
$filtered->all();
/*
[
['name' => 'Jim', 'deleted_at' => '2019-01-01 00:00:00'],
['name' => 'Sally', 'deleted_at' => '2019-01-02 00:00:00'],
]
*/
whereStrict()
此方法具有与where 方法;但是，所有值都使用“严格”比较进行比较。
whereBetween()
这whereBetween 方法通过确定指定的项目值是否在给定范围内来过滤集合：
$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]);
$filtered->all();
/*
[
['product' => 'Desk', 'price' => 200],
['product' => 'Bookcase', 'price' => 150],
['product' => 'Door', 'price' => 100],
]
*/
whereIn()
这whereIn 方法从集合中删除没有包含在给定数组中的指定项目值的元素：
$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' => 'Desk', 'price' => 200],
['product' => 'Bookcase', 'price' => 150],
]
*/
这whereIn 方法在检查项目值时使用“松散”比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。使用whereInStrict 使用“严格”比较进行过滤的方法。
whereInStrict()
此方法具有与whereIn 方法;但是，所有值都使用“严格”比较进行比较。
whereInstanceOf()
这whereInstanceOf 方法按给定的类类型过滤集合：
use App\Models\User;
use App\Models\Post;
$collection = collect([
new User,
new User,
new Post,
]);
$filtered = $collection->whereInstanceOf(User::class);
$filtered->all();
// [App\Models\User, App\Models\User]
whereNotBetween()
这whereNotBetween 方法通过确定指定的项目值是否超出给定范围来过滤集合：
$collection = collect([
['product' => 'Desk', 'price' => 200],
['product' => 'Chair', 'price' => 80],
['product' => 'Bookcase', 'price' => 150],
['product' => 'Pencil', 'price' => 30],
['product' => 'Door', 'price' => 100],
]);
$filtered = $collection->whereNotBetween('price', [100, 200]);
$filtered->all();
/*
[
['product' => 'Chair', 'price' => 80],
['product' => 'Pencil', 'price' => 30],
]
*/
whereNotIn()
这whereNotIn 方法从集合中删除具有给定数组中包含的指定项值的元素：
$collection = collect([
['product' => 'Desk', 'price' => 200],
['product' => 'Chair', 'price' => 100],
['product' => 'Bookcase', 'price' => 150],
['product' => 'Door', 'price' => 100],
]);
$filtered = $collection->whereNotIn('price', [150, 200]);
$filtered->all();
/*
[
['product' => 'Chair', 'price' => 100],
['product' => 'Door', 'price' => 100],
]
*/
这whereNotIn 方法在检查项目值时使用“松散”比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。使用whereNotInStrict 使用“严格”比较进行过滤的方法。
whereNotInStrict()
此方法具有与whereNotIn 方法;但是，所有值都使用“严格”比较进行比较。
whereNotNull()
这whereNotNull 方法返回集合中给定键不存在的项目null:
$collection = collect([
['name' => 'Desk'],
['name' => null],
['name' => 'Bookcase'],
]);
$filtered = $collection->whereNotNull('name');
$filtered->all();
/*
[
['name' => 'Desk'],
['name' => 'Bookcase'],
]
*/
whereNull()
这whereNull 方法从给定键所在的集合中返回项目null:
$collection = collect([
['name' => 'Desk'],
['name' => null],
['name' => 'Bookcase'],
]);
$filtered = $collection->whereNull('name');
$filtered->all();
/*
[
['name' => null],
]
*/
wrap()
静态的wrap 方法在适用时将给定值包装在集合中：
use Illuminate\Support\Collection;
$collection = Collection::wrap('John Doe');
$collection->all();
// ['John Doe']
$collection = Collection::wrap(['John Doe']);
$collection->all();
// ['John Doe']
$collection = Collection::wrap(collect('John Doe'));
$collection->all();
// ['John Doe']
zip()
这zip 方法将给定数组的值与其相应索引处的原始集合的值合并在一起：
$collection = collect(['Chair', 'Desk']);
$zipped = $collection->zip([100, 200]);
$zipped->all();
// [['Chair', 100], ['Desk', 200]]
高阶消息
集合还提供对“高阶消息”的支持，这是对集合执行常见操作的快捷方式。提供高阶消息的收集方法有：average,avg,contains,each,every,filter,first,flatMap,groupBy,keyBy,map,max,min,partition,reject,skipUntil,skipWhile,some,sortBy,sortByDesc,sum,takeUntil,takeWhile， 和unique.
每个高阶消息都可以作为集合实例上的动态属性进行访问。例如，让我们使用each 在集合中的每个对象上调用方法的高阶消息：
use App\Models\User;
$users = User::where('votes', '>', 500)->get();
$users->each->markAsVip();
同样，我们可以使用sum 收集一组用户的“投票”总数的高阶消息：
$users = User::where('group', 'Development')->get();
return $users->sum->votes;
惰性集合
Introduction
Warning
在进一步了解 Laravel 的惰性集合之前，先花点时间熟悉一下PHP 生成器.
补充已经强大的Collection 类，LazyCollection 类利用 PHP 的generators 允许您处理非常大的数据集，同时保持低内存使用率。
例如，假设您的应用程序需要处理一个数 GB 的日志文件，同时利用 Laravel 的收集方法来解析日志。惰性集合可用于在给定时间仅将文件的一小部分保留在内存中，而不是一次将整个文件读入内存：
use App\Models\LogEntry;
use Illuminate\Support\LazyCollection;
LazyCollection::make(function () {
$handle = fopen('log.txt', 'r');
while (($line = fgets($handle)) !== false) {
yield $line;
}
})->chunk(4)->map(function (array $lines) {
return LogEntry::fromLines($lines);
})->each(function (LogEntry $logEntry) {
// Process the log entry...
});
或者，假设您需要迭代 10,000 个 Eloquent 模型。当使用传统的 Laravel 集合时，所有 10,000 个 Eloquent 模型必须同时加载到内存中：
use App\Models\User;
$users = User::all()->filter(function (User $user) {
return $user->id > 500;
});
但是，查询生成器的cursor方法返回一个LazyCollection 实例。这允许您仍然只对数据库运行一个查询，而且一次只将一个 Eloquent 模型加载到内存中。在这个例子中，filter 在我们实际单独迭代每个用户之前不会执行回调，从而大幅减少内存使用：
use App\Models\User;
$users = User::cursor()->filter(function (User $user) {
return $user->id > 500;
});
foreach ($users as $user) {
echo $user->id;
}
创建惰性集合
要创建惰性集合实例，您应该将 PHP 生成器函数传递给集合的make 方法：
use Illuminate\Support\LazyCollection;
LazyCollection::make(function () {
$handle = fopen('log.txt', 'r');
while (($line = fgets($handle)) !== false) {
yield $line;
}
});
可枚举契约
几乎所有可用的方法Collection 类也可在LazyCollection 班级。这两个类都实现了Illuminate\Support\Enumerable 合同，它定义了以下方法：
all average avg chunk chunkWhile collapse collect combine concat contains containsStrict count countBy crossJoin dd diff diffAssoc diffKeys dump duplicates duplicatesStrict each eachSpread every except filter first firstOrFail firstWhere flatMap flatten flip forPage get groupBy has implode intersect intersectByKeys isEmpty isNotEmpty join keyBy keys last macro make map mapInto mapSpread mapToGroups mapWithKeys max median merge mergeRecursive min mode nth only pad partition pipe pluck random reduce reject replace replaceRecursive reverse search shuffle skip slice sole some sort sortBy sortByDesc sortKeys sortKeysDesc split sum take tap times toArray toJson union unique uniqueStrict unless unlessEmpty unlessNotEmpty unwrap values when whenEmpty whenNotEmpty where whereStrict whereBetween whereIn whereInStrict whereInstanceOf whereNotBetween whereNotIn whereNotInStrict wrap zip
Warning
改变集合的方法（例如shift,pop,prepend等）是not 可在LazyCollection班级。
惰性收集方法
除了定义在Enumerable 合同，LazyCollection 类包含以下方法：
takeUntilTimeout()
这takeUntilTimeout 方法返回一个新的惰性集合，它将枚举值直到指定的时间。在那之后，集合将停止枚举：
$lazyCollection = LazyCollection::times(INF)
->takeUntilTimeout(now()->addMinute());
$lazyCollection->each(function (int $number) {
dump($number);
sleep(1);
});
// 1
// 2
// ...
// 58
// 59
为了说明此方法的用法，假设一个应用程序使用游标从数据库提交发票。你可以定义一个定时任务 每 15 分钟运行一次，最多只处理 14 分钟的发票：
use App\Models\Invoice;
use Illuminate\Support\Carbon;
Invoice::pending()->cursor()
->takeUntilTimeout(
Carbon::createFromTimestamp(LARAVEL_START)->add(14, 'minutes')
)
->each(fn (Invoice $invoice) => $invoice->submit());
tapEach()
虽然each 方法立即为集合中的每个项目调用给定的回调，tapEach 方法只调用给定的回调，因为项目被一个接一个地拉出列表：
// Nothing has been dumped so far...
$lazyCollection = LazyCollection::times(INF)->tapEach(function (int $value) {
dump($value);
});
// Three items are dumped...
$array = $lazyCollection->take(3)->all();
// 1
// 2
// 3
remember()
这remember 方法返回一个新的惰性集合，它将记住任何已经枚举的值，并且不会在后续的集合枚举中再次检索它们：
// No query has been executed yet...
$users = User::cursor()->remember();
// The query is executed...
// The first 5 users are hydrated from the database...
$users->take(5)->all();
// First 5 users come from the collection's cache...
// The rest are hydrated from the database...
$users->take(20)->all();