Laravel
话题列表 社区 Wiki 优质外文 招聘求职 Laravel 实战教程 社区文档
登录
注册
集合
/
所有投稿
/
投稿详情
诺墨 2年前

修改理由：

润色文档，修正部分表述和中英文标点使用

相关信息：


此投稿由 kis龍 在 2年前 合并。

标题修改：

+ 集合

内容修改：

红色背景 为原始内容

绿色背景 为新增或者修改的内容

OldNewDifferences
11# 集合
22
33- [介绍](#introduction)
4     - [创建集合](#creating-collections)
5     - [扩展集合](#extending-collections)
 4   - [创建集合](#creating-collections)
 5   - [扩展集合](#extending-collections)
66- [可用方法](#available-methods)
77- [高阶消息](#higher-order-messages)
88- [惰性集合](#lazy-collections)
9     - [介绍](#lazy-collection-introduction)
10     - [创建惰性集合](#creating-lazy-collections)
11     - [枚举契约](#the-enumerable-contract)
12     - [惰性集合方法](#lazy-collection-methods)
 9   - [介绍](#lazy-collection-introduction)
 10   - [创建惰性集合](#creating-lazy-collections)
 11   - [枚举契约](#the-enumerable-contract)
 12   - [惰性集合方法](#lazy-collection-methods)
1313
1414<a name="introduction"></a>
1515## 介绍
1616
17 `Illuminate\Support\Collection` 类为处理数据数组提供了一个流畅、方便的包装器。 例如，查看以下代码。 我们将使用 `collect` 助手从数组中创建一个新的集合实例，对每个元素运行 `strtoupper` 函数，然后删除所有空元素：
 17`Illuminate\Support\Collection` 类为处理数据数组提供了一个流畅、方便的包装器。例如，查看以下代码。我们将使用 `collect` 助手从数组中创建一个新的集合实例，对每个元素运行 `strtoupper` 函数，然后删除所有空元素：
1818
1919   $collection = collect(['taylor', 'abigail', null])->map(function ($name) {
2020       return strtoupper($name);
…… 
2222       return empty($name);
2323   });
2424
25 如您所见，`Collection` 类允许您链接其方法以执行流畅的映射和减少底层数组。 一般来说，集合是不可变的，这意味着每个 `Collection` 方法都会返回一个全新的 `Collection` 实例。
 25如你所见，`Collection` 类允许你链接其方法以执行流畅的映射和减少底层数组。一般来说，集合是不可变的，这意味着每个 `Collection` 方法都会返回一个全新的 `Collection` 实例。
2626
2727<a name="creating-collections"></a>
2828### 创建集合
2929
30 如上所述，`collect` 帮助器为给定数组返回一个新的 `Illuminate\Support\Collection` 实例。 因此，创建一个集合非常简单：
 30如上所述，`collect` 帮助器为给定数组返回一个新的 `Illuminate\Support\Collection` 实例。因此，创建一个集合非常简单：
3131
3232   $collection = collect([1, 2, 3]);
3333
…… 
3636<a name="extending-collections"></a>
3737### 扩展集合
3838
39 集合是“可宏化的”，它允许您在运行时向 `Collection` 类添加其他方法。 `Illuminate\Support\Collection` 类的 `macro` 方法接受一个闭包，该闭包将在调用宏时执行。 宏闭包可以通过 `$this` 访问集合的其他方法，就像它是集合类的真实方法一样。 例如，以下代码在 `Collection` 类中添加了 `toUpper` 方法：
 39集合是「可宏化的」，它允许你在运行时向 `Collection` 类添加其他方法。 `Illuminate\Support\Collection` 类的 `macro` 方法接受一个闭包，该闭包将在调用宏时执行。宏闭包可以通过 `$this` 访问集合的其他方法，就像它是集合类的真实方法一样。例如，以下代码在 `Collection` 类中添加了 `toUpper` 方法：
4040
4141   use Illuminate\Support\Collection;
4242   use Illuminate\Support\Str;
…… 
5353
5454   // ['FIRST', 'SECOND']
5555
56 
57 
58 通常，您应该在[service provider](/docs/laravel/9.x/providers)的 `boot` 方法中声明集合宏。
 56通常，你应该在[service provider](/docs/laravel/9.x/providers)的 `boot` 方法中声明集合宏。
5957
6058<a name="macro-arguments"></a>
6159#### 宏参数
…… 
231229
232230</div>
233231
234   
235   
236232<a name="method-listing"></a>
237233## 方法列表
238234
…… 
256252   // [1, 2, 3]
257253
258254<a name="method-average"></a>
259 #### `average()`
 255#### `average()`
260256
261257[`avg`](#method-avg) 方法的别名。
262258
263259<a name="method-avg"></a>
264 #### `avg()`
 260#### `avg()`
265261
266262`avg` 方法返回给定键的 [平均值](https://en.wikipedia.org/wiki/Average)：
267263
…… 
291287
292288   // [[1, 2, 3, 4], [5, 6, 7]]
293289
294 当使用诸如 [Bootstrap](https://getbootstrap.com/docs/4.1/layout/grid/) 之类的网格系统时，此方法在 [views](/docs/laravel/9.x/views) 中特别有用 . 例如，假设您有一组 [Eloquent](/docs/laravel/9.x/eloquent) 模型要在网格中显示：
 290当使用诸如 [Bootstrap](https://getbootstrap.com/docs/4.1/layout/grid/) 之类的网格系统时，此方法在 [views](/docs/laravel/9.x/views) 中特别有用 . 例如，假设你有一组 [Eloquent](/docs/laravel/9.x/eloquent) 模型要在网格中显示：
295291
296292```blade
297293@foreach ($products->chunk(3) as $chunk)
…… 
304300```
305301
306302<a name="method-chunkwhile"></a>
307 #### `chunkWhile()`
308 
309 `chunkWhile` 方法根据给定回调的评估将集合分成多个更小的集合。 传递给闭包的 `$chunk` 变量可用于检查前一个元素：
 303#### `chunkWhile()`
 304
 305`chunkWhile` 方法根据给定回调的评估将集合分成多个更小的集合。传递给闭包的 `$chunk` 变量可用于检查前一个元素：
310306
311307   $collection = collect(str_split('AABBCCCD'));
312308
…… 
320316
321317<a name="method-collapse"></a>
322318#### `collapse()` {.collection-method}
323   
324   
325319
326320`collapse` 方法将数组集合折叠成一个单一的平面集合：
327321
…… 
368362
369363   // [1, 2, 3]
370364
371 > 技巧：当你有一个 `Enumerable` 的实例并且需要一个非惰性集合实例时，`collect` 方法特别有用。 由于 `collect()` 是 `Enumerable` 合约的一部分，您可以安全地使用它来获取 `Collection` 实例。
 365> 技巧：当你有一个 `Enumerable` 的实例并且需要一个非惰性集合实例时，`collect` 方法特别有用。由于 `collect()` 是 `Enumerable` 合约的一部分，你可以安全地使用它来获取 `Collection` 实例。
372366
373367<a name="method-combine"></a>
374368#### `combine()` {.collection-method}
…… 
396390
397391   // ['John Doe', 'Jane Doe', 'Johnny Doe']
398392
399 `concat` 方法在数字上重新索引连接到原始集合上的项目的键。 要维护关联集合中的键，请参阅 [merge](#method-merge) 方法。
 393`concat` 方法在数字上重新索引连接到原始集合上的项目的键。要维护关联集合中的键，请参阅 [merge](#method-merge) 方法。
400394
401395<a name="method-contains"></a>
402396#### `contains()` {.collection-method}
403397
404 `contains` 方法确定集合是否包含给定项目。 您可以将闭包传递给 `contains` 方法，以确定集合中是否存在与给定真值测试匹配的元素：
 398`contains` 方法确定集合是否包含给定项目。你可以将闭包传递给 `contains` 方法，以确定集合中是否存在与给定真值测试匹配的元素：
405399
406400   $collection = collect([1, 2, 3, 4, 5]);
407401
…… 
411405
412406   // false
413407
414 
415 
416 或者，您可以将字符串传递给 `contains` 方法，以确定集合是否包含给定的项目值：
 408或者，你可以将字符串传递给 `contains` 方法，以确定集合是否包含给定的项目值：
417409
418410   $collection = collect(['name' => 'Desk', 'price' => 100]);
419411
…… 
425417
426418   // false
427419
428 您还可以将键/值对传递给 `contains` 方法，该方法将确定给定对是否存在于集合中：
 420你还可以将键/值对传递给 `contains` 方法，该方法将确定给定对是否存在于集合中：
429421
430422   $collection = collect([
431423       ['product' => 'Desk', 'price' => 200],
…… 
436428
437429   // false
438430
439 `contains` 方法在检查项目值时使用“松散”比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。 使用 [`containsStrict`](#method-containsstrict) 方法使用“严格”比较进行过滤。
 431`contains` 方法在检查项目值时使用「松散」比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。使用 [`containsStrict`](#method-containsstrict) 方法使用「严格」比较进行过滤。
440432
441433对于 `contains` 的逆操作，请参见 [doesntContain](#method-doesntcontain) 方法。
442434
443435<a name="method-containsstrict"></a>
444436#### `containsStrict()` {.collection-method}
445437
446 此方法与 [`contains`](#method-contains) 方法具有相同的签名； 但是，所有值都使用“严格”比较进行比较。
 438此方法与 [`contains`](#method-contains) 方法具有相同的签名；但是，所有值都使用「严格」比较进行比较。
447439
448440> 技巧：使用 [Eloquent Collections](/docs/laravel/9.x/eloquent-collections#method-contains) 时会修改此方法的行为。
449441
…… 
461453<a name="method-countBy"></a>
462454#### `countBy()` {.collection-method}
463455
464 `countBy` 方法计算集合中值的出现次数。 默认情况下，该方法计算每个元素的出现次数，允许您计算集合中元素的某些“类型”：
 456`countBy` 方法计算集合中值的出现次数。默认情况下，该方法计算每个元素的出现次数，允许你计算集合中元素的某些「类型」：
465457
466458   $collection = collect([1, 2, 2, 2, 3]);
467459
…… 
471463
472464   // [1 => 1, 2 => 3, 3 => 1]
473465
474 您将闭包传递给 `countBy` 方法以按自定义值计算所有项目：
 466你将闭包传递给 `countBy` 方法以按自定义值计算所有项目：
475467
476468   $collection = collect(['alice@gmail.com', 'bob@yahoo.com', 'carlos@gmail.com']);
477469
…… 
482474   $counted->all();
483475
484476   // ['gmail.com' => 2, 'yahoo.com' => 1]
485   
486   
487477
488478<a name="method-crossjoin"></a>
489479#### `crossJoin()` {.collection-method}
…… 
542532       }
543533   */
544534
545 如果您不想停止执行脚本，请改用 [`dump`](#method-dump) 方法。
 535如果你不想停止执行脚本，请改用 [`dump`](#method-dump) 方法。
546536
547537<a name="method-diff"></a>
548538#### `diff()` {.collection-method}
549539
550 `diff` 方法根据集合的值将集合与另一个集合或普通 PHP `array` 进行比较。 此方法将返回给定集合中不存在的原始集合中的值：
 540`diff` 方法根据集合的值将集合与另一个集合或普通 PHP `array` 进行比较。此方法将返回给定集合中不存在的原始集合中的值：
551541
552542   $collection = collect([1, 2, 3, 4, 5]);
553543
…… 
562552<a name="method-diffassoc"></a>
563553#### `diffAssoc()` {.collection-method}
564554
565 `diffAssoc` 方法根据其键和值将集合与另一个集合或普通 PHP `array` 进行比较。 此方法将返回给定集合中不存在的原始集合中的键/值对：
 555`diffAssoc` 方法根据其键和值将集合与另一个集合或普通 PHP `array` 进行比较。此方法将返回给定集合中不存在的原始集合中的键/值对：
566556
567557   $collection = collect([
568558       'color' => 'orange',
…… 
582572   // ['color' => 'orange', 'remain' => 6]
583573
584574<a name="method-diffkeys"></a>
585   
586   
587575#### `diffKeys()` {.collection-method}
588576
589 `diffKeys` 方法将集合与另一个集合或基于其键的普通 PHP `array` 进行比较。 此方法将返回给定集合中不存在的原始集合中的键/值对：
 577`diffKeys` 方法将集合与另一个集合或基于其键的普通 PHP `array` 进行比较。此方法将返回给定集合中不存在的原始集合中的键/值对：
590578
591579   $collection = collect([
592580       'one' => 10,
…… 
610598<a name="method-doesntcontain"></a>
611599#### `doesntContain()` {.collection-method}
612600
613 `doesntContain` 方法确定集合是否不包含给定项目。 您可以将闭包传递给 `doesntContain` 方法，以确定集合中是否不存在与给定真值测试匹配的元素：
 601`doesntContain` 方法确定集合是否不包含给定项目。你可以将闭包传递给 `doesntContain` 方法，以确定集合中是否不存在与给定真值测试匹配的元素：
614602
615603   $collection = collect([1, 2, 3, 4, 5]);
616604
…… 
620608
621609   // false
622610
623 或者，您可以将字符串传递给 `doesntContain` 方法，以确定集合是否不包含给定的项目值：
 611或者，你可以将字符串传递给 `doesntContain` 方法，以确定集合是否不包含给定的项目值：
624612
625613   $collection = collect(['name' => 'Desk', 'price' => 100]);
626614
…… 
632620
633621   // false
634622
635 您还可以将键/值对传递给 `doesntContain` 方法，该方法将确定给定对是否不存在于集合中：
 623你还可以将键/值对传递给 `doesntContain` 方法，该方法将确定给定对是否不存在于集合中：
636624
637625   $collection = collect([
638626       ['product' => 'Desk', 'price' => 200],
…… 
643631
644632   // true
645633
646 `doesntContain` 方法在检查项目值时使用“松散”比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。
 634`doesntContain` 方法在检查项目值时使用「松散」比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。
647635
648636<a name="method-dump"></a>
649637#### `dump()` {.collection-method}
…… 
665653
666654如果要在转储集合后停止执行脚本，请改用 [`dd`](#method-dd) 方法。
667655
668   
669   
670656<a name="method-duplicates"></a>
671657#### `duplicates()` {.collection-method}
672658
…… 
678664
679665   // [2 => 'a', 4 => 'b']
680666
681 如果集合包含数组或对象，您可以传递要检查重复值的属性的键：
 667如果集合包含数组或对象，你可以传递要检查重复值的属性的键：
682668
683669   $employees = collect([
684670       ['email' => 'abigail@example.com', 'position' => 'Developer'],
…… 
693679<a name="method-duplicatesstrict"></a>
694680#### `duplicatesStrict()` {.collection-method}
695681
696 此方法与 [`duplicates`](#method-duplicates) 方法具有相同的签名； 但是，所有值都使用“严格”比较进行比较。
 682此方法与 [`duplicates`](#method-duplicates) 方法具有相同的签名；但是，所有值都使用「严格」比较进行比较。
697683
698684<a name="method-each"></a>
699685#### `each()` {.collection-method}
…… 
723709       //
724710   });
725711
726 您可以通过从回调中返回 `false` 来停止遍历项目：
 712你可以通过从回调中返回 `false` 来停止遍历项目：
727713
728714   $collection->eachSpread(function ($name, $age) {
729715       return false;
…… 
750736
751737   // true
752738
753   
754   
755739<a name="method-except"></a>
756740#### `except()` {.collection-method}
757741
…… 
805789
806790   // 3
807791
808 你也可以调用不带参数的 `first` 方法来获取集合中的第一个元素。 如果集合为空，则返回 `null`：
 792你也可以调用不带参数的 `first` 方法来获取集合中的第一个元素。如果集合为空，则返回 `null`：
809793
810794   collect([1, 2, 3, 4])->first();
811795
…… 
827811
828812   // ['name' => 'Linda', 'age' => 14]
829813
830 您还可以使用比较运算符调用 `firstWhere` 方法：
 814你还可以使用比较运算符调用 `firstWhere` 方法：
831815
832816   $collection->firstWhere('age', '>=', 18);
833817
834818   // ['name' => 'Diego', 'age' => 23]
835819
836 
837 
838 与 [where](#method-where) 方法一样，您可以将一个参数传递给 `firstWhere` 方法。 在这种情况下，`firstWhere` 方法将返回给定项目键值为“真”的第一个项目：
 820与 [where](#method-where) 方法一样，你可以将一个参数传递给 `firstWhere` 方法。在这种情况下，`firstWhere` 方法将返回给定项目键值为「真」的第一个项目：
839821
840822   $collection->firstWhere('age');
841823
…… 
844826<a name="method-flatmap"></a>
845827#### `flatMap()` {.collection-method}
846828
847 `flatMap` 方法遍历集合并将每个值传递给给定的闭包。 闭包可以自由修改项目并将其返回，从而形成一个新的修改项目集合。 然后，数组被展平一层：
 829`flatMap` 方法遍历集合并将每个值传递给给定的闭包。闭包可以自由修改项目并将其返回，从而形成一个新的修改项目集合。然后，数组被展平一层：
848830
849831   $collection = collect([
850832       ['name' => 'Sally'],
…… 
878860
879861   // ['taylor', 'php', 'javascript'];
880862
881 如有必要，您可以向 `flatten` 方法传递一个“深度”参数：
 863如有必要，你可以向 `flatten` 方法传递一个「深度」参数：
882864
883865   $collection = collect([
884866       'Apple' => [
…… 
906888       ]
907889   */
908890
909 在此示例中，调用 `flatten` 而不提供深度也会使嵌套数组变平，从而导致 `['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']`。 提供深度允许您指定嵌套数组将被展平的级别数。
 891在此示例中，调用 `flatten` 而不提供深度也会使嵌套数组变平，从而导致 `['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']`。提供深度允许你指定嵌套数组将被展平的级别数。
910892
911893<a name="method-flip"></a>
912894#### `flip()` {.collection-method}
…… 
921903
922904   // ['taylor' => 'name', 'laravel' => 'framework']
923905
924   
925   
926906<a name="method-forget"></a>
927 #### `forget()`
 907#### `forget()`
928908
929909该 `forget` 方法将通过指定的键来移除集合中对应的元素：
930910
…… 
1005985       ]
1006986   */
1007987
1008 
1009 
1010 您可以传递回调，而不是传递字符串 `key`。 回调应返回您希望通过以下方式键入组的值：
 988你可以传递回调，而不是传递字符串 `key`。回调应返回你希望通过以下方式键入组的值：
1011989
1012990   $grouped = $collection->groupBy(function ($item, $key) {
1013991       return substr($item['account_id'], -3);
…… 
10271005       ]
10281006   */
10291007
1030 多个分组标准可以作为数组传递。 每个数组元素将应用于多维数组中的相应级别：
 1008多个分组标准可以作为数组传递。每个数组元素将应用于多维数组中的相应级别：
10311009
10321010   $data = new Collection([
10331011       10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']],
…… 
10871065<a name="method-implode"></a>
10881066#### `implode()` {.collection-method}
10891067
1090 `implode` 方法连接集合中的项目。 它的参数取决于集合中项目的类型。 如果集合包含数组或对象，您应该传递您希望加入的属性的键，以及您希望放置在值之间的“胶水”字符串：
 1068`implode` 方法连接集合中的项目。它的参数取决于集合中项目的类型。如果集合包含数组或对象，你应该传递你希望加入的属性的键，以及你希望放置在值之间的「胶水」字符串：
10911069
10921070   $collection = collect([
10931071       ['account_id' => 1, 'product' => 'Desk'],
…… 
10981076
10991077   // Desk, Chair
11001078
1101 
1102 
1103 如果集合包含简单的字符串或数值，则应将“胶水”作为唯一参数传递给该方法：
 1079如果集合包含简单的字符串或数值，则应将「胶水」作为唯一参数传递给该方法：
11041080
11051081   collect([1, 2, 3, 4, 5])->implode('-');
11061082
…… 
11091085<a name="method-intersect"></a>
11101086#### `intersect()` {.collection-method}
11111087
1112 `intersect` 方法从原始集合中删除任何不存在于给定 `array` 或集合中的值。 生成的集合将保留原始集合的键：
 1088`intersect` 方法从原始集合中删除任何不存在于给定 `array` 或集合中的值。生成的集合将保留原始集合的键：
11131089
11141090   $collection = collect(['Desk', 'Sofa', 'Chair']);
11151091
…… 
11411117<a name="method-isempty"></a>
11421118#### `isEmpty()` {.collection-method}
11431119
1144 如果集合为空，`isEmpty` 方法返回 `true`； 否则，返回 `false`：
 1120如果集合为空，`isEmpty` 方法返回 `true`；否则，返回 `false`：
11451121
11461122   collect([])->isEmpty();
11471123
…… 
11501126<a name="method-isnotempty"></a>
11511127#### `isNotEmpty()` {.collection-method}
11521128
1153 如果集合不为空，`isNotEmpty` 方法返回 `true`； 否则，返回 `false`：
 1129如果集合不为空，`isNotEmpty` 方法返回 `true`；否则，返回 `false`：
11541130
11551131   collect([])->isNotEmpty();
11561132
…… 
11591135<a name="method-join"></a>
11601136#### `join()` {.collection-method}
11611137
1162 `join` 方法将集合的值与字符串连接起来。 使用此方法的第二个参数，您还可以指定最终元素应如何附加到字符串：
 1138`join` 方法将集合的值与字符串连接起来。使用此方法的第二个参数，你还可以指定最终元素应如何附加到字符串：
11631139
11641140   collect(['a', 'b', 'c'])->join(', '); // 'a, b, c'
11651141   collect(['a', 'b', 'c'])->join(', ', ', and '); // 'a, b, and c'
…… 
11671143   collect(['a'])->join(', ', ' and '); // 'a'
11681144   collect([])->join(', ', ' and '); // ''
11691145
1170   
1171   
11721146<a name="method-keyby"></a>
11731147#### `keyBy()` {.collection-method}
11741148
1175 `keyBy` 方法通过给定键对集合进行键控。 如果多个项目具有相同的键，则只有最后一个会出现在新集合中：
 1149`keyBy` 方法通过给定键对集合进行键控。如果多个项目具有相同的键，则只有最后一个会出现在新集合中：
11761150
11771151   $collection = collect([
11781152       ['product_id' => 'prod-100', 'name' => 'Desk'],
…… 
11901164       ]
11911165   */
11921166
1193 您也可以将回调传递给该方法。 回调应通过以下方式返回值以作为集合的键：
 1167你也可以将回调传递给该方法。回调应通过以下方式返回值以作为集合的键：
11941168
11951169   $keyed = $collection->keyBy(function ($item) {
11961170       return strtoupper($item['product_id']);
…… 
12321206
12331207   // 2
12341208
1235 你也可以调用不带参数的`last`方法来获取集合中的最后一个元素。 如果集合为空，则返回 `null`：
 1209你也可以调用不带参数的`last`方法来获取集合中的最后一个元素。如果集合为空，则返回 `null`：
12361210
12371211   collect([1, 2, 3, 4])->last();
12381212
…… 
12411215<a name="method-macro"></a>
12421216#### `macro()` {.collection-method}
12431217
1244 静态`macro()`方法允许您在运行时向“集合”类添加方法。 有关详细信息，请参阅有关 [扩展集合](#extending-collections) 的文档。
1245 
1246 
 1218静态`macro()`方法允许你在运行时向「集合」类添加方法。有关详细信息，请参阅有关 [扩展集合](#extending-collections) 的文档。
12471219
12481220<a name="method-make"></a>
12491221#### `make()`
…… 
12531225<a name="method-map"></a>
12541226#### `map()`
12551227
1256 该 `map` 方法遍历集合并将每一个值传入给定的回调函数。该回调函数可以任意修改集合项并返回，从而生成被修改过集合项的新集合：
 1228静态 `make` 方法可以创建一个新的集合实例。请参照 [创建集合](#creating-collections) 部分。
12571229
12581230   $collection = collect([1, 2, 3, 4, 5]);
12591231
…… 
13481320
13491321   // ['John Doe', 'Jane Doe']
13501322
1351   
1352   
13531323<a name="method-mapwithkeys"></a>
13541324#### `mapWithKeys()` {.collection-method}
13551325
1356 `mapWithKeys` 方法遍历集合并将每个值传递给给定的回调。 回调应返回包含单个键/值对的关联数组：
 1326`mapWithKeys` 方法遍历集合并将每个值传递给给定的回调。回调应返回包含单个键/值对的关联数组：
13571327
13581328   $collection = collect([
13591329       [
…… 
14181388<a name="method-merge"></a>
14191389#### `merge()` {.collection-method}
14201390
1421 `merge` 方法将给定的数组或集合与原始集合合并。 如果给定项目中的字符串键与原始集合中的字符串键匹配，则给定项目的值将覆盖原始集合中的值：
 1391`merge` 方法将给定的数组或集合与原始集合合并。如果给定项目中的字符串键与原始集合中的字符串键匹配，则给定项目的值将覆盖原始集合中的值：
14221392
14231393   $collection = collect(['product_id' => 1, 'price' => 100]);
14241394
…… 
14411411<a name="method-mergerecursive"></a>
14421412#### `mergeRecursive()` {.collection-method}
14431413
1444 `mergeRecursive` 方法将给定的数组或集合递归地与原始集合合并。 如果给定项目中的字符串键与原始集合中的字符串键匹配，则这些键的值将合并到一个数组中，这是递归完成的：
 1414`mergeRecursive` 方法将给定的数组或集合递归地与原始集合合并。如果给定项目中的字符串键与原始集合中的字符串键匹配，则这些键的值将合并到一个数组中，这是递归完成的：
14451415
14461416   $collection = collect(['product_id' => 1, 'price' => 100]);
14471417
…… 
14541424   $merged->all();
14551425
14561426   // ['product_id' => [1, 2], 'price' => [100, 200], 'discount' => false]
1457   
1458   
14591427
14601428<a name="method-min"></a>
14611429#### `min()` {.collection-method}
…… 
15031471
15041472   // ['a', 'e']
15051473
1506 您可以选择将起始偏移量作为第二个参数传递：
 1474你可以选择将起始偏移量作为第二个参数传递：
15071475
15081476   $collection->nth(4, 1);
15091477
…… 
15271495
15281496   // ['product_id' => 1, 'name' => 'Desk']
15291497
1530 For the inverse of `only`, see the [except](#method-except) method.
 1498关于 `only` 的反义词，见[except](#method-except) 方法。
15311499
15321500> 技巧：使用 [Eloquent Collections](/docs/laravel/9.x/eloquent-collections#method-only) 时会修改此方法的行为。
15331501
15341502<a name="method-pad"></a>
15351503#### `pad()` {.collection-method}
15361504
1537 `pad` 方法将用给定的值填充数组，直到数组达到指定的大小。 此方法的行为类似于 [array_pad](https://secure.php.net/manual/en/function.array-pad.php) PHP 函数。
1538 
1539 要向左填充，您应该指定一个负尺寸。 如果给定大小的绝对值小于或等于数组的长度，则不会发生填充：
 1505`pad` 方法将用给定的值填充数组，直到数组达到指定的大小。此方法的行为类似于 [array_pad](https://secure.php.net/manual/en/function.array-pad.php) PHP 函数。
 1506
 1507要向左填充，你应该指定一个负尺寸。如果给定大小的绝对值小于或等于数组的长度，则不会发生填充：
15401508
15411509   $collection = collect(['A', 'B', 'C']);
15421510
…… 
15511519   $filtered->all();
15521520
15531521   // [0, 0, 'A', 'B', 'C']
1554   
1555   
15561522
15571523<a name="method-partition"></a>
15581524#### `partition()`
…… 
16771643
16781644   // ['Rosa', 'Judith']
16791645
1680   
1681   
16821646如果存在重复键，则将最后一个匹配元素插入到 plucked 集合中：
16831647
16841648   $collection = collect([
…… 
17091673
17101674   // [1, 2, 3, 4]
17111675
1712 您可以将整数传递给 `pop` 方法以从集合末尾删除并返回多个项目：
 1676你可以将整数传递给 `pop` 方法以从集合末尾删除并返回多个项目：
17131677
17141678   $collection = collect([1, 2, 3, 4, 5]);
17151679
…… 
17341698
17351699   // [0, 1, 2, 3, 4, 5]
17361700
1737 您还可以传递第二个参数来指定前置项的键：
 1701你还可以传递第二个参数来指定前置项的键：
17381702
17391703   $collection = collect(['one' => 1, 'two' => 2]);
17401704
…… 
17961760
17971761   // 4 - (retrieved randomly)
17981762
1799 
1800 
1801 您可以将一个整数传递给“random”，以指定要随机检索的项目数。 当明确传递您希望接收的项目数时，始终返回项目集合：
 1763你可以将一个整数传递给 `random`，以指定要随机检索的项目数。当明确传递你希望接收的项目数时，始终返回项目集合：
18021764
18031765   $random = $collection->random(3);
18041766
…… 
18321794
18331795   // 6
18341796
1835 `$carry` 在第一次迭代时的值为 `null`； 但是，您可以通过将第二个参数传递给 `reduce` 来指定其初始值：
 1797`$carry` 在第一次迭代时的值为 `null`；但是，你可以通过将第二个参数传递给 `reduce` 来指定其初始值：
18361798
18371799   $collection->reduce(function ($carry, $item) {
18381800       return $carry + $item;
…… 
18601822
18611823   // 4264
18621824
1863   
1864   
18651825<a name="method-reduce-spread"></a>
18661826#### `reduceSpread()` {.collection-method}
18671827
1868 `reduceSpread` 方法将集合缩减为一个值数组，将每次迭代的结果传递给后续迭代。 此方法类似于 `reduce` 方法； 但是，它可以接受多个初始值：
 1828`reduceSpread` 方法将集合缩减为一个值数组，将每次迭代的结果传递给后续迭代。此方法类似于 `reduce` 方法；但是，它可以接受多个初始值：
18691829
18701830   [$creditsRemaining, $batch] = Image::where('status', 'unprocessed')
18711831       ->get()
…… 
18821842<a name="method-reject"></a>
18831843#### `reject()` {.collection-method}
18841844
1885 `reject` 方法使用给定的闭包过滤集合。 如果应从结果集合中删除项目，则闭包应返回 `true`：
 1845`reject` 方法使用给定的闭包过滤集合。如果应从结果集合中删除项目，则闭包应返回 `true`：
18861846
18871847   $collection = collect([1, 2, 3, 4]);
18881848
…… 
18991859<a name="method-replace"></a>
19001860#### `replace()` {.collection-method}
19011861
1902 `replace` 方法的行为类似于 `merge`； 但是，除了覆盖具有字符串键的匹配项之外，`replace` 方法还将覆盖集合中具有匹配数字键的项：
 1862`replace` 方法的行为类似于 `merge`；但是，除了覆盖具有字符串键的匹配项之外，`replace` 方法还将覆盖集合中具有匹配数字键的项：
19031863
19041864   $collection = collect(['Taylor', 'Abigail', 'James']);
19051865
…… 
19541914       ]
19551915   */
19561916
1957   
1958   
19591917<a name="method-search"></a>
19601918#### `search()` {.collection-method}
19611919
1962 `search` 方法在集合中搜索给定值，如果找到则返回其键。 如果未找到该项目，则返回 `false`：
 1920`search` 方法在集合中搜索给定值，如果找到则返回其键。如果未找到该项目，则返回 `false`：
19631921
19641922   $collection = collect([2, 4, 6, 8]);
19651923
…… 
19671925
19681926   // 1
19691927
1970 搜索是使用“松散”比较完成的，这意味着具有整数值的字符串将被视为等于具有相同值的整数。 要使用“严格”比较，请将 `true` 作为第二个参数传递给方法：
 1928搜索是使用「松散」比较完成的，这意味着具有整数值的字符串将被视为等于具有相同值的整数。要使用「严格」比较，请将 `true` 作为第二个参数传递给方法：
19711929
19721930   collect([2, 4, 6, 8])->search('4', $strict = true);
19731931
19741932   // false
19751933
1976 或者，您可以提供自己的闭包来搜索通过给定真值测试的第一个项目：
 1934或者，你可以提供自己的闭包来搜索通过给定真值测试的第一个项目：
19771935
19781936   collect([2, 4, 6, 8])->search(function ($item, $key) {
19791937       return $item > 5;
…… 
19961954
19971955   // [2, 3, 4, 5]
19981956
1999 您可以将整数传递给 `shift` 方法以从集合的开头删除并返回多个项目：
 1957你可以将整数传递给 `shift` 方法以从集合的开头删除并返回多个项目：
20001958
20011959   $collection = collect([1, 2, 3, 4, 5]);
20021960
…… 
20241982<a name="method-sliding"></a>
20251983#### `sliding()` {.collection-method}
20261984
2027 `sliding` 方法返回一个新的块集合，表示集合中项目的“滑动窗口”视图：
 1985`sliding` 方法返回一个新的块集合，表示集合中项目的「滑动窗口」视图：
20281986
20291987   $collection = collect([1, 2, 3, 4, 5]);
20301988
…… 
20401998       $current->total = $previous->total + $current->amount;
20411999   });
20422000
2043 您可以选择传递第二个“步长”值，该值确定每个块的第一项之间的距离：
 2001你可以选择传递第二个「步长」值，该值确定每个块的第一项之间的距离：
20442002
20452003   $collection = collect([1, 2, 3, 4, 5]);
20462004
…… 
20492007   $chunks->toArray();
20502008
20512009   // [[1, 2, 3], [3, 4, 5]]
2052   
2053   
20542010
20552011<a name="method-skip"></a>
20562012#### `skip()` {.collection-method}
…… 
20802036
20812037   // [3, 4]
20822038
2083 您还可以将一个简单的值传递给 `skipUntil` 方法以跳过所有项目，直到找到给定值：
 2039你还可以将一个简单的值传递给 `skipUntil` 方法以跳过所有项目，直到找到给定值：
20842040
20852041   $collection = collect([1, 2, 3, 4]);
20862042
…… 
21222078
21232079   // [5, 6, 7, 8, 9, 10]
21242080
2125 如果您想限制返回切片的大小，请将所需大小作为第二个参数传递给该方法：
 2081如果你想限制返回切片的大小，请将所需大小作为第二个参数传递给该方法：
21262082
21272083   $slice = $collection->slice(4, 2);
21282084
…… 
21302086
21312087   // [5, 6]
21322088
2133 默认情况下，返回的切片将保留键。 如果您不希望保留原始键，可以使用 [`values`](#method-values) 方法重新索引它们。
2134 
2135 
 2089默认情况下，返回的切片将保留键。如果你不希望保留原始键，可以使用 [`values`](#method-values) 方法重新索引它们。
21362090
21372091<a name="method-sole"></a>
21382092#### `sole()` {.collection-method}
…… 
21452099
21462100   // 2
21472101
2148 您还可以将键/值对传递给 `sole` 方法，该方法将返回集合中与给定对匹配的第一个元素，但前提是它恰好有一个元素匹配：
 2102你还可以将键/值对传递给 `sole` 方法，该方法将返回集合中与给定对匹配的第一个元素，但前提是它恰好有一个元素匹配：
21492103
21502104   $collection = collect([
21512105       ['product' => 'Desk', 'price' => 200],
…… 
21562110
21572111   // ['product' => 'Chair', 'price' => 100]
21582112
2159 或者，如果只有一个元素，您也可以调用不带参数的 `sole` 方法来获取集合中的第一个元素：
 2113或者，如果只有一个元素，你也可以调用不带参数的 `sole` 方法来获取集合中的第一个元素：
21602114
21612115   $collection = collect([
21622116       ['product' => 'Desk', 'price' => 200],
…… 
21662120
21672121   // ['product' => 'Desk', 'price' => 200]
21682122
2169 如果集合中没有应该由 `sole` 方法返回的元素，则会抛出 `\Illuminate\Collections\ItemNotFoundException` 异常。 如果应该返回多个元素，则会抛出 `\Illuminate\Collections\MultipleItemsFoundException`。
 2123如果集合中没有应该由 `sole` 方法返回的元素，则会抛出 `\Illuminate\Collections\ItemNotFoundException` 异常。如果应该返回多个元素，则会抛出 `\Illuminate\Collections\MultipleItemsFoundException`。
21702124
21712125<a name="method-some"></a>
21722126#### `some()` {.collection-method}
…… 
21762130<a name="method-sort"></a>
21772131#### `sort()` {.collection-method}
21782132
2179 `sort` 方法对集合进行排序。 排序后的集合保留了原始数组键，因此在下面的示例中，我们将使用 [`values`](#method-values) 方法将键重置为连续编号的索引：
 2133`sort` 方法对集合进行排序。排序后的集合保留了原始数组键，因此在下面的示例中，我们将使用 [`values`](#method-values) 方法将键重置为连续编号的索引：
21802134
21812135   $collection = collect([5, 3, 1, 2, 4]);
21822136
…… 
21862140
21872141   // [1, 2, 3, 4, 5]
21882142
2189 如果您的排序需求更高级，您可以使用自己的算法将回调传递给“排序”。 参考PHP文档[`uasort`](https://secure.php.net/manual/en/function.uasort.php#refsect1-function.uasort-parameters)，就是集合的`sort`方法 调用内部使用。
2190 
2191 > 技巧：如果您需要对嵌套数组或对象的集合进行排序，请参阅 [`sortBy`](#method-sortby) 和 [`sortByDesc`](#method-sortbydesc) 方法。
2192 
2193 
 2143如果你的排序需求更高级，你可以使用自己的算法将回调传递给「排序」。参考 PHP 文档[`uasort`](https://secure.php.net/manual/en/function.uasort.php#refsect1-function.uasort-parameters)，就是集合的`sort`方法 调用内部使用。
 2144
 2145> 技巧：如果你需要对嵌套数组或对象的集合进行排序，请参阅 [`sortBy`](#method-sortby) 和 [`sortByDesc`](#method-sortbydesc) 方法。
21942146
21952147<a name="method-sortby"></a>
21962148#### `sortBy()` {.collection-method}
21972149
2198 `sortBy` 方法按给定键对集合进行排序。 排序后的集合保留了原始数组键，因此在下面的示例中，我们将使用 [`values`](#method-values) 方法将键重置为连续编号的索引：
 2150`sortBy` 方法按给定键对集合进行排序。排序后的集合保留了原始数组键，因此在下面的示例中，我们将使用 [`values`](#method-values) 方法将键重置为连续编号的索引：
21992151
22002152   $collection = collect([
22012153       ['name' => 'Desk', 'price' => 200],
…… 
22352187       ]
22362188   */
22372189
2238 或者，您可以传递自己的闭包来确定如何对集合的值进行排序：
 2190或者，你可以传递自己的闭包来确定如何对集合的值进行排序：
22392191
22402192   $collection = collect([
22412193       ['name' => 'Desk', 'colors' => ['Black', 'Mahogany']],
…… 
22572209       ]
22582210   */
22592211
2260 如果您想按多个属性对集合进行排序，可以将排序操作数组传递给 `sortBy` 方法。 每个排序操作都应该是一个数组，由您希望排序的属性和所需排序的方向组成：
 2212如果你想按多个属性对集合进行排序，可以将排序操作数组传递给 `sortBy` 方法。每个排序操作都应该是一个数组，由你希望排序的属性和所需排序的方向组成：
22612213
22622214   $collection = collect([
22632215       ['name' => 'Taylor Otwell', 'age' => 34],
…… 
22822234       ]
22832235   */
22842236
2285 
2286 
2287 当按多个属性对集合进行排序时，您还可以提供定义每个排序操作的闭包：
 2237当按多个属性对集合进行排序时，你还可以提供定义每个排序操作的闭包：
22882238
22892239   $collection = collect([
22902240       ['name' => 'Taylor Otwell', 'age' => 34],
…… 
23272277
23282278   // [5, 4, 3, 2, 1]
23292279
2330 与 `sort` 不同，您不能将闭包传递给 `sortDesc`。 相反，您应该使用 [`sort`](#method-sort) 方法并反转比较。
 2280与 `sort` 不同，你不能将闭包传递给 `sortDesc`。相反，你应该使用 [`sort`](#method-sort) 方法并反转比较。
23312281
23322282<a name="method-sortkeys"></a>
23332283#### `sortKeys()` {.collection-method}
…… 
23802330       ]
23812331   */
23822332
2383 
2384 
2385 回调必须是返回小于、等于或大于零的整数的比较函数。 有关更多信息，请参阅 [`uksort`](https://www.php.net/manual/en/function.uksort.php#refsect1-function.uksort-parameters) 上的 PHP 文档，这是 PHP 函数 `sortKeysUsing` 方法在内部使用。
 2333回调必须是返回小于、等于或大于零的整数的比较函数。有关更多信息，请参阅 [`uksort`](https://www.php.net/manual/en/function.uksort.php#refsect1-function.uksort-parameters) 上的 PHP 文档，这是 PHP 函数 `sortKeysUsing` 方法在内部使用。
23862334
23872335<a name="method-splice"></a>
23882336#### `splice()` {.collection-method}
…… 
24012349
24022350   // [1, 2]
24032351
2404 您可以传递第二个参数来限制结果集合的大小：
 2352你可以传递第二个参数来限制结果集合的大小：
24052353
24062354   $collection = collect([1, 2, 3, 4, 5]);
24072355
…… 
24152363
24162364   // [1, 2, 4, 5]
24172365
2418 此外，您可以传递包含新项目的第三个参数来替换从集合中删除的项目：
 2366此外，你可以传递包含新项目的第三个参数来替换从集合中删除的项目：
24192367
24202368   $collection = collect([1, 2, 3, 4, 5]);
24212369
…… 
24752423
24762424   // 1272
24772425
2478 
2479 
2480 此外，您可以传递自己的闭包来确定要对集合的哪些值求和：
 2426此外，你可以传递自己的闭包来确定要对集合的哪些值求和：
24812427
24822428   $collection = collect([
24832429       ['name' => 'Chair', 'colors' => ['Black']],
…… 
25042450
25052451   // [0, 1, 2]
25062452
2507 您还可以传递一个负整数以从集合末尾获取指定数量的项目：
 2453你还可以传递一个负整数以从集合末尾获取指定数量的项目：
25082454
25092455   $collection = collect([0, 1, 2, 3, 4, 5]);
25102456
…… 
25292475
25302476   // [1, 2]
25312477
2532 您还可以将一个简单的值传递给 `takeUntil` 方法以获取项目，直到找到给定值：
 2478你还可以将一个简单的值传递给 `takeUntil` 方法以获取项目，直到找到给定值：
25332479
25342480   $collection = collect([1, 2, 3, 4]);
25352481
…… 
25612507<a name="method-tap"></a>
25622508#### `tap()` {.collection-method}
25632509
2564 `tap` 方法将集合传递给给定的回调，允许您在特定点“点击”到集合中并在不影响集合本身的情况下对项目执行某些操作。 然后集合由 `tap` 方法返回：
 2510`tap` 方法将集合传递给给定的回调，允许你在特定点「点击」到集合中并在不影响集合本身的情况下对项目执行某些操作。然后集合由 `tap` 方法返回：
25652511
25662512   collect([2, 4, 3, 1, 5])
25672513       ->sort()
…… 
25722518
25732519   // 1
25742520
2575   
2576   
25772521<a name="method-times"></a>
25782522#### `times()`
25792523
…… 
26352579<a name="method-undot"></a>
26362580#### `undot()`
26372581
2638 `undot()` 方法将使用“点”表示法的一维集合扩展为多维集合:
 2582`undot()` 方法将使用「点」表示法的一维集合扩展为多维集合：
26392583
26402584   $person = collect([
26412585       'name.first_name' => 'Marie',
…… 
26672611       ]
26682612   */
26692613
2670   
2671   
26722614<a name="method-union"></a>
26732615#### `union()`
26742616
…… 
27162658       ]
27172659   */
27182660
2719 最后，您还可以将自己的闭包传递给该 `unique` 方法，以指定哪个值应确定项目的唯一性：
 2661最后，你还可以将自己的闭包传递给该 `unique` 方法，以指定哪个值应确定项目的唯一性：
27202662
27212663   $unique = $collection->unique(function ($item) {
27222664       return $item['brand'].$item['type'];
…… 
27372679
27382680> 技巧：这个方法的行为在使用 [Eloquent 集合](/docs/laravel/9.x/eloquent-collections#method-unique) 时被修改。
27392681
2740   
2741   
27422682<a name="method-uniquestrict"></a>
27432683#### `uniqueStrict()`
27442684
2745 这个方法与 [`unique`](#method-unique) 方法一样，然而，所有的值是用 「严格」模式来比较的。
 2685这个方法与 [`unique`](#method-unique) 方法一样，然而，所有的值是用「严格」模式来比较的。
27462686
27472687<a name="method-unless"></a>
27482688#### `unless()`
…… 
28462786
28472787   // [1, 2, 3, 4]
28482788
2849   
2850   
28512789可以将第二个回调传递给该 `when` 方法。当给 `when` 方法的第一个参数计算结果为 `false` 时，将执行第二个回调：
28522790
28532791   $collection = collect([1, 2, 3]);
…… 
29472885   // ['taylor']
29482886
29492887与 `whenNotEmpty` 相反的方法，请查看 [`whenEmpty`](#method-whenempty) 方法。
2950   
2951   
29522888
29532889<a name="method-where"></a>
29542890#### `where()`
…… 
30472983       ]
30482984   */
30492985
3050 
3051 
3052 `whereIn` 方法在检查项目值时使用 "loose" 比较，这意味着具有整数值的字符串将被视为等于相同值的整数。 使用 [`whereInStrict`](#method-whereinstrict) 方法使用“strict”比较进行过滤。
 2986`whereIn` 方法在检查项目值时使用 "loose" 比较，这意味着具有整数值的字符串将被视为等于相同值的整数。使用 [`whereInStrict`](#method-whereinstrict) 方法使用「strict」比较进行过滤。
30532987
30542988<a name="method-whereinstrict"></a>
30552989#### `whereInStrict()` {.collection-method}
30562990
3057 此方法与 [`whereIn`](#method-wherein) 方法具有相同的签名； 但是，所有值都使用“strict”比较进行比较。
 2991此方法与 [`whereIn`](#method-wherein) 方法具有相同的签名；但是，所有值都使用「strict」比较进行比较。
30582992
30592993<a name="method-whereinstanceof"></a>
30602994#### `whereInstanceOf()` {.collection-method}
…… 
31233057       ]
31243058   */
31253059
3126 `whereNotIn` 方法在检查项目值时使用“loose”比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。 使用 [`whereNotInStrict`](#method-wherenotinstrict) 方法使用“strict”比较进行过滤。
3127 
3128 
 3060`whereNotIn` 方法在检查项目值时使用「loose」比较，这意味着具有整数值的字符串将被视为等于具有相同值的整数。使用 [`whereNotInStrict`](#method-wherenotinstrict) 方法使用「strict」比较进行过滤。
31293061
31303062<a name="method-wherenotinstrict"></a>
31313063#### `whereNotInStrict()`
…… 
31753107       ]
31763108   */
31773109
3178   
31793110<a name="method-wrap"></a>
31803111#### `wrap()`
31813112
…… 
32193150
32203151集合也提供对「高阶消息传递」的支持，即集合常见操作的快捷方式。支持高阶消息传递的集合方法有： [`average`](#method-average)，[`avg`](#method-avg)，[`contains`](#method-contains)， [`each`](#method-each)，[`every`](#method-every)，[`filter`](#method-filter)， [`first`](#method-first)，[`flatMap`](#method-flatmap)，[`groupBy`](#method-groupby)，[`keyBy`](#method-keyby)，[`map`](#method-map)，[`max`](#method-max)， [`min`](#method-min)，[`partition`](#method-partition)，[`reject`](#method-reject)， [`skipUntil`](#method-skipuntil)，[`skipWhile`](#method-skipwhile)，[`some`](#method-some)，[`sortBy`](#method-sortby)，[`sortByDesc`](#method-sortbydesc)， [`sum`](#method-sum)，[`takeUntil`](#method-takeuntil)，[`takeWhile`](#method-takewhile) 和 [`unique`](#method-unique)。
32213152
3222 
3223 
3224 每个高阶消息都可以作为集合实例上的动态属性进行访问。 例如，让我们使用 `each` 高阶消息来调用集合中每个对象的方法：
 3153每个高阶消息都可以作为集合实例上的动态属性进行访问。例如，让我们使用 `each` 高阶消息来调用集合中每个对象的方法：
32253154
32263155   use App\Models\User;
32273156
…… 
32293158
32303159   $users->each->markAsVip();
32313160
3232 同样，我们可以使用 `sum` 高阶消息来收集用户集合的“votes”总数：
 3161同样，我们可以使用 `sum` 高阶消息来收集用户集合的「votes」总数：
32333162
32343163   $users = User::where('group', 'Development')->get();
32353164
…… 
32433172
32443173> 注意：在进一步了解 Laravel 的惰性集合之前，花点时间熟悉一下 [PHP 生成器](https://www.php.net/manual/en/language.generators.overview.php).
32453174
3246 为了补充已经强大的 `Collection` 类，`LazyCollection` 类利用 PHP 的 [generators](https://www.php.net/manual/en/language.generators.overview.php) 允许您使用非常 大型数据集，同时保持较低的内存使用率。
3247 
3248 例如，假设您的应用程序需要处理数 GB 的日志文件，同时利用 Laravel 的集合方法来解析日志。 可以使用惰性集合在给定时间仅将文件的一小部分保留在内存中，而不是一次将整个文件读入内存：
 3175为了补充已经强大的 `Collection` 类，`LazyCollection` 类利用 PHP 的 [generators](https://www.php.net/manual/en/language.generators.overview.php) 允许你使用非常 大型数据集，同时保持较低的内存使用率。
 3176
 3177例如，假设你的应用程序需要处理数 GB 的日志文件，同时利用 Laravel 的集合方法来解析日志。可以使用惰性集合在给定时间仅将文件的一小部分保留在内存中，而不是一次将整个文件读入内存：
32493178
32503179   use App\Models\LogEntry;
32513180   use Illuminate\Support\LazyCollection;
…… 
32623191       // Process the log entry...
32633192   });
32643193
3265 
3266 
3267 或者，假设您需要遍历 10,000 个 Eloquent 模型。 使用传统 Laravel 集合时，所有 10,000 个 Eloquent 模型必须同时加载到内存中：
 3194或者，假设你需要遍历 10,000 个 Eloquent 模型。使用传统 Laravel 集合时，所有 10,000 个 Eloquent 模型必须同时加载到内存中：
32683195
32693196   use App\Models\User;
32703197
…… 
32723199       return $user->id > 500;
32733200   });
32743201
3275 但是，查询构建器的 `cursor` 方法返回一个 `LazyCollection` 实例。 这允许您仍然只对数据库运行一个查询，而且一次只在内存中加载一个 Eloquent 模型。 在这个例子中，`filter` 回调在我们实际单独遍历每个用户之前不会执行，从而可以大幅减少内存使用量：
 3202但是，查询构建器的 `cursor` 方法返回一个 `LazyCollection` 实例。这允许你仍然只对数据库运行一个查询，而且一次只在内存中加载一个 Eloquent 模型。在这个例子中，`filter` 回调在我们实际单独遍历每个用户之前不会执行，从而可以大幅减少内存使用量：
32763203
32773204   use App\Models\User;
32783205
…… 
32873214<a name="creating-lazy-collections"></a>
32883215### 创建惰性集合
32893216
3290 要创建惰性集合实例，您应该将 PHP 生成器函数传递给集合的 `make` 方法：
 3217要创建惰性集合实例，你应该将 PHP 生成器函数传递给集合的 `make` 方法：
32913218
32923219   use Illuminate\Support\LazyCollection;
32933220
…… 
33023229<a name="the-enumerable-contract"></a>
33033230### 枚举契约
33043231
3305 `Collection` 类上几乎所有可用的方法也可以在 `LazyCollection` 类上使用。 这两个类都实现了 `Illuminate\Support\Enumerable` 契约，它定义了以下方法：
 3232`Collection` 类上几乎所有可用的方法也可以在 `LazyCollection` 类上使用。这两个类都实现了 `Illuminate\Support\Enumerable` 契约，它定义了以下方法：
33063233
33073234<div id="collection-method-list" markdown="1">
33083235
…… 
34193346
34203347> 注意：改变集合的方法（例如 `shift`、`pop`、`prepend` 等）在 `LazyCollection` 类中**不**可用。
34213348
3422   
3423   
34243349<a name="lazy-collection-methods"></a>
34253350### 惰性集合方法
34263351
…… 
34483373   // 59
34493374```
34503375
3451 为了具体阐述此方法，请设想一个使用游标从数据库提交发票的例子。你可以定义一个 [计划任务 ](/docs/laravel/9.x/scheduling)，它每十五分钟执行一次，并且只执行发票提交操作的最大时间是 14 分钟：
 3376为了具体阐述此方法，请设想一个使用游标从数据库提交发票的例子。你可以定义一个 [计划任务](/docs/laravel/9.x/scheduling)，它每十五分钟执行一次，并且只执行发票提交操作的最大时间是 14 分钟：
34523377
34533378```php
34543379   use App\Models\Invoice;
…… 
34643389<a name="method-tapEach"></a>
34653390#### `tapEach()` {.collection-method}
34663391
3467   
34683392当 `each` 方法为集合中每一个元素调用给定回调时， `tapEach` 方法仅调用给定回调，因为这些元素正在逐个从列表中拉出：
34693393
34703394```php
…… 
34953419   $users->take(5)->all();
34963420
34973421   // 前 5 个用户数据从缓存中获取
3498    // 剩余的（15个）用户数据从数据库中查询
 3422   // 剩余的（15 个）用户数据从数据库中查询
34993423   $users->take(20)->all();
35003424```
35013425

关于 LearnKu

LearnKu 是终身编程者的修道场
做最专业、严肃的技术论坛
LearnKu 诞生的故事

资源推荐

  • 《社区使用指南》
  • 《文档撰写指南》
  • 《LearnKu 社区规范》
  • 《提问的智慧》

    • 服务提供商

    其他信息

  • 成为版主
  • 所有测验
  • 联系站长（反馈建议）

    • 粤ICP备18099781号-6 | 粤公网安备 44030502004330号 | 违法和不良信息举报

    由 Summer 设计和编码 | 方长科技协力运营

    请登录

    内容举报
    匿名举报，为防止滥用，仅管理员可见举报者。

    我要举报该，理由是：

    取消