rassembler

Collection

Introduction
- Création d'une collection
- Extension d'une collection
Méthodes disponibles
Informations avancées

Introduction

La classe IlluminateSupportCollection fournit une encapsulation plus lisible et plus pratique pour le traitement des données du tableau. Veuillez consulter le code ci-dessous pour des exemples spécifiques. Nous utilisons la fonction d'assistance collect pour créer une nouvelle instance de collection à partir du tableau, exécutons la fonction strtoupper sur chaque élément, puis supprimons tous les éléments vides : IlluminateSupportCollection 类提供了一个更具可读性和更便于处理数组数据的封装。具体例子请查看下面代码。我们使用 collect 辅助函数从数组中创建一个新的集合实例，对其中每一个元素执行 strtoupper 函数之后再删除所有的空元素：

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

正如你所见， Collection 类允许你链式调用其它方法，以达到在底层数组上流畅的执行 map 和 reduce 操作，通常，集合是不可变的，这意味着每一个 Collection 方法都会返回一个新的 Collection 实例。

创建集合

如上所述， collect 辅助函数会为指定的数组返回一个新的 IlluminateSupportCollection 实例。因此，我们可以这样轻松的创建一个集合：

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

{tip} 通常，Eloquent 查询的结果返回的内容都是 Collection 实例。

扩展集合

集合都是「可宏扩展」(macroable) 的，它允许你在执行时将其它方法添加到 Collection 类。例如，通过下面的代码在 Collection 类中添加一个 toUpper

use Illuminate\Support\Str;Collection::macro('toUpper', function () { 
   return $this->map(function ($value) {  
         return Str::upper($value);    
       });
 });$collection = collect(['first', 'second']);
 $upper = $collection->toUpper();
 // ['FIRST', 'SECOND']

As you As vous pouvez le voir, la classe Collection vous permet d'enchaîner les appels à d'autres méthodes pour effectuer en douceur des opérations de mappage et de réduction sur le tableau sous-jacent. Généralement, les collections sont immuables, ce qui signifie que chaque

 Collection renverront toutes une nouvelle instance Collection. 
Création de collections
Comme mentionné ci-dessus, collecter La fonction d'assistance renvoie une nouvelle instance IlluminateSupportCollection pour le tableau spécifié. Par conséquent, nous pouvons facilement créer une collection comme celle-ci : collect([1, 2, 3])->all();// [1, 2, 3]
{tip} Habituellement, les résultats renvoyés par les requêtes Eloquent sont des instances de Collection. 🎜🎜🎜🎜🎜Extension des collections
🎜Les collections sont "macro-ables" " "Extensible" (macroable), qui permet d'ajouter des méthodes supplémentaires à la classe Collection au moment de l'exécution. Par exemple, ajoutez une méthode toUpper dans la classe Collection avec le code suivant : 🎜$average = collect([['foo' => 10],
             ['foo' => 10], 
            ['foo' => 20], 
            ['foo' => 40]])->avg('foo');
// 20
$average = collect([1, 1, 2, 4])->avg();
// 2
🎜Normalement, vous devez déclarer la macro de collection à l'intérieur du fournisseur de services. 🎜🎜🎜🎜🎜🎜🎜Méthodes disponibles
Suite à la documentation, nous explorerons Collection 类的每个方法。请牢记，所有方法都可以通过链式访问的形式优雅的操作数组。而且，几乎所有的方法都会返回一个新的 Collection les instances qui vous permettent de sauvegarder une copie originale d'une collection lorsque cela est nécessaire : tous
moyenne
avg
chunk
collapse
combine
concat
contient
 containsStrict
count
crossJoin
dd
 diffAssoc 
premier
premierOù
flatMap
aplatir 
flip
oublie
forPage
get
groupBy
has
implode
intersect 
intersectByKeys
isEmpty
isNotEmpty
keyBy 
keys
last
macro
make
map
mapInto
mapSpread
mapToGroups
mapWithKeys 
max
médiane
merge
min 
mode
ntième
seulement
pad
partition
pipe
pluck
pop
prepend 
tirer
pousser
mettre aléatoire 
trier
sortBy
sortByDesc
sortKeys
sortKeysDesc
splice
split
sum
take
tap
times
 toArray 
toJson
transform
union
unique 
uniqueStrict
sauf
saufEmpty
saufNotEmpty
unwrap
valeurs
quand
quand 
whenNotEmpty
where
whereStrict
whereBetween 
 whereIn
whereInStrict
whereInstanceOf
whereNotBetween
whereNotIn
whereNotInStrict
wrap
z ip 
Liste des méthodes
  La méthode all()
all()all 方法返回该集合表示的底层数组：
$collection = collect([1, 2, 3, 4, 5, 6, 7]);
$chunks = $collection->chunk(4);
$chunks->toArray();
// [[1, 2, 3, 4], [5, 6, 7]]
average()
avg 方法的别名。
avg()
avg 方法返回给定键的 平均值 ：
@foreach ($products->chunk(3) as $chunk)  
  <div class="row">
        @foreach ($chunk as $product)         
           <div class="col-xs-4">
              {{ $product->name }}
           </div>
        @endforeach   
   </div>
 @endforeach
chunk()
chunk 方法将集合拆成多个给定大小的小集合：
$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]
这个方法在使用网格系统的 视图 中特别适用，例如 Bootstrap。 想象你有一个 Eloquent 模型的集合要在网格中显示：
$collection = collect(['name', 'age']);
$combined = $collection->combine(['George', 29]);
$combined->all();
// ['name' => 'George', 'age' => 29]
collapse()
collapseall renvoie le tableau sous-jacent représenté par la collection : 
$collection = collect(['John Doe']);
$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);
$concatenated->all();
// ['John Doe', 'Jane Doe', 'Johnny Doe']
 
moyenne()
moy< /code> 
 Alias de la méthode. 🎜🎜🎜🎜🎜avg()
🎜avg renvoie la moyenne 🎜 pour la clé donnée : 🎜$collection = collect(['name' => 'Desk', 'price' => 100]);
$collection->contains('Desk');
// true
$collection->contains('New York');
// false
🎜🎜 🎜🎜chunk()
🎜La méthode chunk divise la collection en plusieurs Small collections d'une taille donnée : 🎜$collection = collect([
    ['product' => 'Desk', 'price' => 200],    
    ['product' => 'Chair', 'price' => 100],
]);
$collection->contains('product', 'Bookcase');
// false
🎜Cette méthode fonctionne particulièrement bien dans les vues qui utilisent un système de grille, comme Bootstrap🎜. Imaginez que vous ayez une collection de modèles Eloquent à afficher dans une grille : 🎜$collection = collect([1, 2, 3, 4, 5]);
$collection->contains(function ($value, $key) {
    return $value > 5;
  });
// false
🎜🎜🎜🎜< code La méthode >collapse()
🎜collapse fusionne une collection de plusieurs tableaux en une collection de tableaux : 🎜$collection = collect([1, 2, 3, 4]);
$collection->count();
// 4
🎜🎜🎜🎜🎜🎜La méthode combine()
combine()combine 方法可以将一个集合的值作为键，再将另一个数组或集合的值作为值合并成一个集合：
$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'],
    ]
*/
concat()
concat 方法将给定的 数组 或集合值追加到集合的末尾：
$collection = collect(['John Doe', 'Jane Doe']);
$collection->dd();
/*
    Collection {
        #items: array:2 [
            0 => "John Doe"
            1 => "Jane Doe"
        ]
    }
*/
contains()
contains 方法判断集合是否包含指定的集合项：
$collection = collect([1, 2, 3, 4, 5]);
$diff = $collection->diff([2, 4, 6, 8]);
$diff->all();
// [1, 3, 5]
你也可以使用 contains 方法传递一组键 / 值对，可以判断该键 / 值对是否存在于集合中：
$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]
最后，你也可以用 contains 方法传递一个回调函数来执行自己的真实测试：
$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]
contains 方法在检查集合项的值时使用「宽松」比较，这意味着具有整数值的字符串将被视为等于相同值的整数。相反 containsStrict 方法则是使用「严格」比较进行过滤。
containsStrict()
这个方法和 contains 方法类似，但是它却是使用了「严格」比较来比较所有的值。
count()
count 方法返回这个集合内集合项的总数量：
$collection = collect(['John Doe', 'Jane Doe']);
$collection->dump();
/*
    Collection {
        #items: array:2 [
            0 => "John Doe"
            1 => "Jane Doe"
        ]
    }
*/
crossJoin()
crossJoin 方法交叉连接指定数组或集合的值，返回所有可能排列的笛卡尔积：
$collection->each(function ($item, $key) {
    //
});
dd()
dd 方法用于打印集合项并中断脚本执行：
$collection->each(function ($item, $key) {
    if (/* 某些条件 */ ) 
  { 
         return false;   
    
    }
 });
如果你不想中断执行脚本，请使用 dump 方法代替。
diff()
diff 方法将集合与其它集合或纯 PHP 数组 进行值的比较。然后返回原集合中存在而指定集合中不存在的值：
$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);
$collection->eachSpread(function ($name, $age) {
    //
 });
diffAssoc()
diffAssoc 方法与另外一个集合或基于它的键和值的 PHP 数组combine peut utiliser la valeur d'un ensemble comme clé, puis combiner la valeur d'un autre tableau ou définir comme valeur pour former un ensemble : 
$collection->eachSpread(function ($name, $age) {
    return false;
});
concat() 
 La méthode concat ajoute le array donné ou la valeur de collection à la fin de la collection : 🎜collect([1, 2, 3, 4])->every(function ($value, $key) {
    return $value > 2;
 });
// false
🎜🎜🎜🎜🎜contains()🎜La méthode contains détermine si la collection contient l'élément de collection spécifié : 🎜$collection = collect([]);
$collection->every(function($value, $key)
 {
   return $value > 2;
 });
// true
 🎜Vous pouvez également utiliser la méthode < The code>contains pour transmettre un ensemble de paires clé/valeur, qui peuvent être utilisées pour déterminer si la paire clé/valeur existe dans la collection : 🎜$collection = collect(['product_id' => 1, 'price' => 100, 'discount' => false]);
$filtered = $collection->except(['price', 'discount']);
$filtered->all();
// ['product_id' => 1]
🎜Enfin, vous pouvez également utiliser la méthode contains pour passer une fonction de rappel pour effectuer votre propre test réel : La méthode 🎜$collection = collect([1, 2, 3, 4]);
$filtered = $collection->filter(function ($value, $key) {
    return $value > 2;
  });
$filtered->all();
// [3, 4]
🎜contains utilise une comparaison "détendue" lors de la vérification de la valeur d'une collection élément, ce qui signifie que les chaînes avec des valeurs entières seront considérées comme égales à la même valeur entière. En revanche, la méthode containsStrict🎜 utilise une comparaison "stricte" pour le filtrage. 🎜🎜🎜🎜🎜🎜containsStrict()🎜Cette méthode est la identique à la méthode < a href="#method-contains">contains🎜 est similaire, mais elle utilise une comparaison "stricte" pour comparer toutes les valeurs. 🎜🎜🎜🎜🎜🎜count()🎜count  La méthode renvoie le nombre total d'éléments de collection dans cette collection : 🎜$collection = collect([1, 2, 3, null, false, '', 0, []]);
$collection->filter()->all();
// [1, 2, 3]
🎜🎜🎜🎜🎜 La méthode crossJoin()🎜crossJoin joint les valeurs du tableau ou de la collection spécifié, renvoyant le produit cartésien de toutes les permutations possibles : 🎜collect([1, 2, 3, 4])->first(function ($value, $key) { 
   return $value > 2;
 });
// 3
🎜🎜🎜🎜🎜dd()🎜dd La méthode est utilisée pour imprimer les éléments de la collection Et interrompre l'exécution du script : 🎜collect([1, 2, 3, 4])->first();
// 1
🎜 Si vous ne souhaitez pas interrompre l'exécution du script, utilisez plutôt la méthode dump🎜 . 🎜🎜🎜🎜🎜🎜diff()🎜diff La méthode  compare les valeurs d'une collection avec d'autres collections ou des tableaux PHP purs. Renvoyez ensuite les valeurs qui existent dans la collection d'origine mais n'existent pas dans la collection spécifiée : 🎜$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]
🎜🎜🎜🎜🎜 La méthode diffAssoc()🎜diffAssoc se compare à une autre collection ou à un array PHP en fonction de ses clés et valeurs. Cette méthode renverra des paires clé/valeur dont la collection d'origine n'existe pas dans la collection spécifiée : 🎜$collection->firstWhere('age', '>=', 18);
// ['name' => 'Diego', 'age' => 23]
🎜🎜🎜🎜🎜🎜La méthode diffKeys()
diffKeys()diffKeys 方法和另外一个集合或 PHP 数组 的键进行比较，然后返回原集合中存在而指定集合中不存在键所对应的键 / 值对：
$collection->firstWhere('age');
// ['name' => 'Linda', 'age' => 14]
dump()
dump 方法用于打印集合项：
$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'];
如果要在打印集合后终止执行脚本，请使用 dd 方法代替。
each()
each 方法用于循环集合项并将其传递到回调函数中：
$collection = collect(['name' => 'taylor', 'languages' => ['php', 'javascript']]);
$flattened = $collection->flatten();
$flattened->all();
// ['taylor', 'php', 'javascript'];
如果你想中断对集合项的循环，那么就在你的回调函数中返回 false ：
$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'],
    ]
*/
eachSpread()
eachSpread 方法用于循环集合项，将每个嵌套集合项的值传递给回调函数：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$flipped = $collection->flip();$flipped->all();
// ['taylor' => 'name', 'laravel' => 'framework']
你可以通过在回调函数里返回 false 来中断循环：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$collection->forget('name');$collection->all();
// ['framework' => 'laravel']
every()
every 方法可用于验证集合中的每一个元素是否通过指定的条件测试：
$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
$chunk = $collection->forPage(2, 3);$chunk->all();
// [4, 5, 6]
如果集合为空， every 将返回 true：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$value = $collection->get('name');
// taylor
except()
except 方法返回集合中除了指定键之外的所有集合项：
$collection = collect(['name' => 'taylor', 'framework' => 'laravel']);
$value = $collection->get('foo', 'default-value');
// default-value
与 except 对应的是 only 方法。
filter()
filter 方法使用给定的回调函数过滤集合，只保留那些通过指定条件测试的集合项：
$collection->get('email', function () {
    return 'default-value';
 });
 // default-value
如果没有提供回调函数，集合中所有返回 false 的元素都会被移除：
$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'],
        ],
    ]
*/
与 filter 对应的是 reject 方法。
first()
first 方法返回集合中通过指定条件测试的第一个元素：
$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'],
        ],
    ]
*/
你也可以不传入参数调用 first 方法来获取集合中的第一个元素。如果集合为空，则会返回 nulldiffKeys compare les clés d'une autre collection ou d'un tableau PHP, puis renvoie les clés dans l'original collection La paire clé/valeur correspondant à la clé n'existe pas dans la collection spécifiée : 
$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 ($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']],
        ],
    ],
];
*/
 La méthode  dump()
dump est utilisée pour imprimer les éléments de la collection : 🎜$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
$collection->has('product');
// true
$collection->has(['product', 'amount']);
// true
$collection->has(['amount', 'price']);
// false
🎜Si vous souhaitez terminer l'exécution du script après l'impression de la collection, utilisez dd🎜 à la place. 🎜🎜🎜🎜🎜🎜each()🎜each La méthode  est utilisée pour boucler sur les éléments de la collection et les transmettre à la fonction de rappel : 🎜$collection = collect([
    ['account_id' => 1,'product' => 'Desk'],    
    ['account_id' => 2, 'product' => 'Chair'],
  ]);
$collection->implode('product', ', ');
// Desk, Chair
🎜 Si vous souhaitez rompre la boucle sur les éléments de la collection, renvoyez false dans votre fonction de rappel : 🎜collect([1, 2, 3, 4, 5])->implode('-');
// '1-2-3-4-5'
🎜🎜🎜🎜🎜eachSpread()🎜 La méthode eachSpread est utilisée pour parcourir les éléments de collection, en transmettant la valeur de chaque élément de collection imbriqué à la fonction de rappel : 🎜$collection = collect(['Desk', 'Sofa', 'Chair']);
$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
$intersect->all();
// [0 => 'Desk', 2 => 'Chair']
🎜Vous pouvez interrompre la boucle en renvoyant false dans le rappel fonction : 🎜 $collection = collect([
    'serial' => 'UX301', 
    'type' => 'screen', 
    'year' => 2009
  ]);
$intersect = $collection->intersectByKeys([ 
   'reference' => 'UX404', 
   'type' => 'tab', 
   'year' => 2011
 ]);
$intersect->all();
// ['type' => 'screen', 'year' => 2009]
🎜🎜🎜🎜🎜every()🎜< code>every La méthode  peut être utilisée pour vérifier si chaque élément de la collection réussit le test de condition spécifié : 🎜collect([])->isEmpty();
// true
🎜Si la collection est vide, every retournera true : 🎜collect([])->isNotEmpty();
// false
🎜 🎜🎜🎜🎜sauf()🎜sauf renvoie la collection Tous les éléments de la collection sauf la clé spécifiée : 🎜$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'],
    ]
*/
🎜 et sauf correspondent à la méthode only🎜. 🎜🎜🎜🎜🎜🎜filter()🎜filtre La méthode  utilise la fonction de rappel donnée pour filtrer la collection, en conservant uniquement les éléments de la collection qui réussissent le test de condition spécifié : 🎜$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'],
    ]
*/
🎜Si aucune fonction de rappel n'est fournie, tous les éléments de la collection qui renvoient false sera supprimé : 🎜$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']
🎜 et filter correspondent à la méthode reject🎜. 🎜🎜🎜🎜🎜🎜first()🎜first La méthode  renvoie le premier élément de la collection qui réussit le test de condition spécifié : 🎜collect([1, 2, 3, 4])->last(function ($value, $key) {
    return $value < 3;
  });
// 2
🎜 Vous pouvez également appeler la méthode first sans passer de paramètres pour obtenir le premier élément de la collection. Si la collection est vide, null sera renvoyé : 🎜collect([1, 2, 3, 4])->last();
// 4
🎜🎜🎜🎜🎜🎜La méthode firstWhere()
firstWhere()firstWhere 方法返回集合中含有指定键 / 值对的第一个元素：
$collection = collect([1, 2, 3, 4, 5]);
$multiplied = $collection->map(function ($item, $key) {
    return $item * 2;
  });
$multiplied->all();
// [2, 4, 6, 8, 10]
你也可以使用运算符来调用 firstWhere 方法：
class Currency{    
         /**
     * Create a new currency instance.
     *
     * @param  string  $code
     * @return void
     */  
function __construct(string $code) 
   {     
      $this->code = $code;   
    }
  }
$collection = collect(['USD', 'EUR', 'GBP']);
$currencies = $collection->mapInto(Currency::class);
$currencies->all();
// [Currency('USD'), Currency('EUR'), Currency('GBP')]和 where 方法一样，你可以将一个参数传递给 firstWhere 方法。在这种情况下， firstWhere 方法将返回指定键的值为「真」的第一个集合项：
$collection = collect([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
$chunks = $collection->chunk(2);
$sequence = $chunks->mapSpread(function ($even, $odd) {
    return $even + $odd;
  });
$sequence->all();
// [1, 5, 9, 13, 17]
flatMap()
flatMap 方法遍历集合并将其中的每个值传递到给定的回调函数。可以通过回调函数修改集合项并返回它们，从而形成一个被修改过的新集合。然后，集合转化的数组是同级的：
$collection = collect([
    [   
         'name' => 'John Doe',        
         'department' => 'Sales',   
     ],   
     [    
         'name' => 'Jane Doe',        
         'department' => 'Sales',   
      ],    
      [   
           'name' => 'Johnny Doe',        
           'department' => 'Marketing',    
      ]
   ]);
$grouped = $collection->mapToGroups(function ($item, $key) {
    return [$item['department'] => $item['name']];
 });
$grouped->toArray();
/*
    [
        'Sales' => ['John Doe', 'Jane Doe'],
        'Marketing' => ['Johnny Doe'],
    ]
*/
$grouped->get('Sales')->all();
// ['John Doe', 'Jane Doe']
flatten()
flatten 方法将多维集合转为一维集合：
$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 = collect([['foo' => 10], ['foo' => 20]])->max('foo');
// 20
$max = collect([1, 2, 3, 4, 5])->max();
// 5
在这个例子里，调用 flatten 时不传入深度参数的话也会将嵌套数组转成一维的，然后返回 ['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']。传入深度参数能让你限制设置返回数组的层数。
flip()
flip 方法将集合的键和对应的值进行互换：
$median = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->median('foo');
// 15
$median = collect([1, 1, 2, 4])->median();
// 1.5
forget()
forget 方法将通过指定的键来移除集合中对应的内容：
$collection = collect(['product_id' => 1, 'price' => 100]);
$merged = $collection->merge(['price' => 200, 'discount' => false]);
$merged->all();
// ['product_id' => 1, 'price' => 200, 'discount' => false]
{note} 与大多数集合的方法不同的是， forget 不会返回修改后的新集合；它会直接修改原集合。
forPage()
forPage 方法返回一个含有指定页码数集合项的新集合。这个方法接受页码数作为其第一个参数，每页显示的项数作为其第二个参数：
$collection = collect(['Desk', 'Chair']);
$merged = $collection->merge(['Bookcase', 'Door']);
$merged->all();
// ['Desk', 'Chair', 'Bookcase', 'Door']
get()
get 方法返回指定键的集合项，如果该键在集合中不存在，则返回 nullfirstWhere renvoie le premier élément de la collection contenant la paire clé/valeur spécifiée : 
$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');
// 10
$min = collect([1, 2, 3, 4, 5])->min();
// 1
Vous pouvez également utiliser des opérateurs pour appeler la méthode firstWhere : 
$mode = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->mode('foo');
// [10]
$mode = collect([1, 1, 2, 4])->mode();
// [1]
Comme la méthode where
, vous pouvez passer un argument à la méthode firstWhere. Dans ce cas, la méthode firstWhere renverra le premier élément de collection dont la valeur est "true" pour la clé spécifiée : 
$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
$collection->nth(4);
// ['a', 'e']
flatMap()🎜flatMap parcourt la collection et transmet chaque valeur à un certain fonction de rappel. Vous pouvez modifier les éléments de la collection et les renvoyer via des fonctions de rappel, formant ainsi une nouvelle collection modifiée. Ensuite, les tableaux transformés par la collection sont du même niveau : 🎜$collection->nth(4, 1);
// ['b', 'f']
🎜🎜🎜🎜🎜flatten ()< /code>🎜La méthode flatten convertit une collection multidimensionnelle en une collection unidimensionnelle : 🎜$collection = collect(['product_id' => 1, 'name' => 'Desk', 'price' => 100, 'discount' => false]);
$filtered = $collection->only(['product_id', 'name']);
$filtered->all();
// ['product_id' => 1, 'name' => 'Desk']
🎜Vous pouvez éventuellement passer le paramètre "profondeur" : 🎜$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']
🎜 Dans cet exemple, appelez flatten Si le paramètre de profondeur n'est pas transmis, le tableau imbriqué sera converti en unidimensionnel, puis ['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung' sera renvoyé ]. Passer le paramètre de profondeur permet de limiter le nombre de niveaux dans le tableau renvoyé. 🎜🎜🎜🎜🎜🎜flip()🎜flip  La méthode échange les clés de la collection avec les valeurs correspondantes : 🎜$collection = collect([1, 2, 3, 4, 5, 6]);
list($underThree, $equalOrAboveThree) = $collection->partition(function ($i) {
    return $i < 3;
   });
$underThree->all();
// [1, 2]
$equalOrAboveThree->all();
// [3, 4, 5, 6]
🎜🎜🎜🎜🎜< code>forget() La méthode 🎜forget supprimera le contenu correspondant de la collection par la clé spécifiée : 🎜$collection = collect([1, 2, 3]);
$piped = $collection->pipe(function ($collection) {
    return $collection->sum();
 });
 // 6
🎜{note} et la plupart des collections. la différence est que forget ne renvoie pas une nouvelle collection modifiée ; il modifie directement la collection originale. 🎜
🎜🎜🎜🎜🎜forPage()🎜 La méthode forPage renvoie une nouvelle collection contenant le numéro de page spécifié des éléments de collection. Cette méthode accepte le numéro de page comme premier paramètre et le nombre d'éléments affichés par page comme deuxième paramètre : 🎜$collection = collect([
    ['product_id' => 'prod-100', 'name' => 'Desk'],    
    ['product_id' => 'prod-200', 'name' => 'Chair'],
  ]);
$plucked = $collection->pluck('name');
$plucked->all();
// ['Desk', 'Chair']
🎜🎜🎜🎜🎜get()🎜La méthode get renvoie l'élément de collection de la clé spécifiée. Si la clé n'existe pas dans la collection, elle renvoie < code>null : 🎜$plucked = $collection->pluck('name', 'product_id');
$plucked->all();
// ['prod-100' => 'Desk', 'prod-200' => 'Chair']
🎜 Vous pouvez passer une valeur par défaut de votre choix comme deuxième paramètre : 🎜$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']
🎜 Vous pouvez même passer une fonction de rappel comme valeur par défaut. Si la clé spécifiée n'existe pas, le résultat de la fonction de rappel sera renvoyé : 🎜$collection = collect([1, 2, 3, 4, 5]);
$collection->pop();
// 5
$collection->all();
// [1, 2, 3, 4]
🎜🎜🎜🎜🎜🎜La méthode groupBy()
groupBy()groupBy 方法根据指定键对集合项进行分组：
$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]
可以传递一个数组用于多重分组标准。每一个数组元素将对应多维数组内的相应级别：
$collection = collect(['product_id' => 'prod-100', 'name' => 'Desk']);
$collection->pull('name');
// 'Desk'
$collection->all();
// ['product_id' => 'prod-100']
has()
has 方法判断集合中是否存在指定键：
$collection = collect([1, 2, 3, 4]);
$collection->push(5);
$collection->all();
// [1, 2, 3, 4, 5]
implode()
implode 方法用于合并集合项。其参数取决于集合项的类型。如果集合包含数组或对象，你应该传递你希望合并的属性的键，以及你希望放在值之间用来「拼接」的字符串：
$collection = collect(['product_id' => 1, 'name' => 'Desk']);
$collection->put('price', 100);
$collection->all();
// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]
如果集合中包含简单的字符串或数值，只需要传入「拼接」用的字符串作为该方法的唯一参数即可：
$collection = collect([1, 2, 3, 4, 5]);
$collection->random();
// 4 - (retrieved randomly)
intersect()
intersect 方法从原集合中移除在指定 数组 或集合中不存在的任何值。生成的集合将会保留原集合的键：
$random = $collection->random(3);
$random->all();
// [2, 4, 5] - (retrieved randomly)
intersectByKeys()
intersectByKeys 方法从原集合中移除在指定 数组 或集合中不存在的任何键：
$collection = collect([1, 2, 3]);
$total = $collection->reduce(function ($carry, $item) {
    return $carry + $item;
 });
 // 6
isEmpty()
如果集合为空，isEmpty 方法返回 true，否则，返回 false：
$collection->reduce(function ($carry, $item) {
   return $carry + $item;}, 4);
  // 10
isNotEmpty()
如果集合不为空，isNotEmpty 方法返回 true，否则，返回 false：
$collection = collect([1, 2, 3, 4]);
$filtered = $collection->reject(function ($value, $key) {
    return $value > 2;
  });
$filtered->all();
// [1, 2]
keyBy()
keyBy 方法以指定的键作为集合的键。如果多个集合项具有相同的键，则只有最后一个集合项会显示在新集合中：
$collection = collect(['a', 'b', 'c', 'd', 'e']);
$reversed = $collection->reverse();
$reversed->all();
/*
    [
        4 => 'e',
        3 => 'd',
        2 => 'c',
        1 => 'b',
        0 => 'a',
    ]
*/
你还可以在这个方法传递一个回调函数。该回调函数返回的值会作为该集合的键：
$collection = collect([2, 4, 6, 8]);
$collection->search(4);
// 1
keys()
keysgroupBy regroupe les éléments de la collection en fonction de la clé spécifiée : 
$collection->search('4', true);
// false
Vous pouvez passer une fonction de rappel au lieu d'une chaîne  clé. Cette fonction de rappel doit renvoyer la valeur de la clé par laquelle vous souhaitez regrouper : 
$collection->search(function ($item, $key) {
    return $item > 5;
  });
// 2
 Un tableau peut être transmis pour plusieurs critères de regroupement. Chaque élément du tableau correspondra au niveau correspondant au sein du tableau multidimensionnel : 
$collection = collect([1, 2, 3, 4, 5]);
$collection->shift();
// 1
$collection->all();
// [2, 3, 4, 5]
🎜🎜🎜has ( )🎜La méthode has détermine si la clé spécifiée existe dans la collection : 🎜$collection = collect([1, 2, 3, 4, 5]);
$shuffled = $collection->shuffle();
$shuffled->all();
// [3, 2, 5, 1, 4] - (generated randomly)
🎜🎜🎜🎜🎜implode()🎜implode est utilisée pour fusionner des éléments de collection. Ses paramètres dépendent du type d'éléments de collection. Si la collection contient des tableaux ou des objets, vous devez passer les clés des propriétés que vous souhaitez fusionner, ainsi que la chaîne que vous souhaitez mettre entre les valeurs pour les "coller" : 🎜$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
$slice = $collection->slice(4);
$slice->all();
// [5, 6, 7, 8, 9, 10]
🎜 Si la collection contient des chaînes simples ou des nombres , il vous suffit de transmettre la chaîne utilisée pour "l'épissage" comme seul paramètre de cette méthode : 🎜$slice = $collection->slice(4, 2);
$slice->all();
// [5, 6]
🎜🎜🎜🎜 La méthode 🎜intersect()🎜intersect supprime de la collection d'origine toutes les valeurs qui n'existent pas dans le array< spécifié. /code> ou collection. L'ensemble généré conservera les clés de l'ensemble d'origine : 🎜$collection = collect([5, 3, 1, 2, 4]);
$sorted = $collection->sort();
$sorted->values()->all();
// [1, 2, 3, 4, 5]
🎜🎜🎜🎜🎜intersectByKeys()  La méthode 🎜intersectByKeys supprime toutes les clés de la collection d'origine qui n'existent pas dans le tableau ou la collection spécifié : 🎜$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],
    ]
*/
🎜🎜🎜🎜🎜isEmpty()🎜Si la collection est vide,  La méthode isEmpty renvoie true, sinon elle renvoie false : 🎜$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']],
    ]
*/
🎜🎜🎜🎜🎜isNotEmpty()🎜Si la collection n'est pas vide, la méthode isNotEmpty renvoie true, sinon, renvoie false：🎜$collection = collect([ 
   'id' => 22345,    
   'first' => 'John',    
   'last' => 'Doe',
  ]);
$sorted = $collection->sortKeys();$sorted->all();
/*
    [
        'first' => 'John',
        'id' => 22345,
        'last' => 'Doe',
    ]
*/
🎜🎜🎜🎜🎜keyBy ()🎜La méthode keyBy utilise la clé spécifiée comme clé de la collection. Si plusieurs éléments de collection ont la même clé, seul le dernier élément de collection sera affiché dans la nouvelle collection : 🎜$collection = collect([1, 2, 3, 4, 5]);
$chunk = $collection->splice(2);
$chunk->all();
// [3, 4, 5]
$collection->all();
// [1, 2]
🎜 Vous pouvez également passer une fonction de rappel dans cette méthode. La valeur renvoyée par cette fonction de rappel sera utilisée comme clé de la collection : 🎜$collection = collect([1, 2, 3, 4, 5]);
$chunk = $collection->splice(2, 1);
$chunk->all();
// [3]
$collection->all();
// [1, 2, 4, 5]
🎜🎜🎜🎜🎜< La méthode code>keys( )🎜keys renvoie toutes les clés de la 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]
🎜🎜🎜🎜🎜🎜La méthode last()
last()last 方法返回集合中通过指定条件测试的最后一个元素：
$collection = collect([1, 2, 3, 4, 5]);
$groups = $collection->split(3);
$groups->toArray();
// [[1, 2], [3, 4], [5]]
你也可以不传入参数调用 last 方法来获取集合中的最后一个元素。如果集合为空，则返回 null：
collect([1, 2, 3, 4, 5])->sum();
// 15
macro()
静态 macro 方法允许你在运行时将方法添加至 Collection 类。关于更多信息，请参阅 扩展集合 的文档。
make()
静态 make 方法可以创建一个新的集合实例。请参阅 创建集合 部分。
map()
map 方法遍历集合并将每一个值传入给定的回调函数。该回调函数可以任意修改集合项并返回，从而生成被修改过集合项的新集合：
$collection = collect([
    ['name' => 'JavaScript: The Good Parts', 'pages' => 176],    
    ['name' => 'JavaScript: The Definitive Guide', 'pages' => 1096],
  ]);
$collection->sum('pages');
// 1272
{note} 与其它大多数集合方法一样，map 会返回一个新的集合实例；它不会修改原集合。如果你想修改原集合，请使用 transform 方法。
mapInto()
mapInto() 方法可以迭代集合，通过将值传递给构造函数来创建给定类的新实例：
$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
mapSpread()
mapSpread 方法可以遍历集合项，将每个嵌套项值给指定的回调函数。该回调函数可以自由修改该集合项并返回，从而生成被修改过集合项的新集合：
$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(3);
$chunk->all();
// [0, 1, 2]
mapToGroups()
mapToGroups 方法通过给定的回调函数对集合项进行分组。该回调函数应该返回一个包含单个键 / 值对的关联数组，从而生成一个分组值的新集合：
$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(-2);
$chunk->all();
// [4, 5]
mapWithKeys()
mapWithKeys 方法遍历集合并将每个值传入给定的回调函数。该回调函数将返回一个包含单个键 / 值对的关联数组：
collect([2, 4, 3, 1, 5])
    ->sort()    
    ->tap(function ($collection) { 
           Log::debug('Values after sorting', $collection->values()->toArray()); 
         })   
     ->shift();
 // 1
max()
maxlast renvoie le dernier élément de la collection qui réussit le test de condition spécifié : 
$collection = Collection::times(10, function ($number) {
    return $number * 9;
 });
$collection->all();
// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]
Vous pouvez également appeler last pour obtenir le dernier élément de la collection. Si la collection est vide, retournez null : 
$categories = Collection::times(3, function ($number) { 
   return factory(Category::class)->create(['name' => "Category No. $number"]);
  });
$categories->all();
/*
    [
        ['id' => 1, 'name' => 'Category #1'],
        ['id' => 2, 'name' => 'Category #2'],
        ['id' => 3, 'name' => 'Category #3'],
    ]
*/
🎜macro()🎜La méthode statique macro vous permet d'ajouter des méthodes à la classe Collection au moment de l'exécution. Pour plus d'informations, consultez la documentation sur l'extension des collections 🎜. 🎜🎜🎜🎜🎜🎜make()🎜static La méthode make crée une nouvelle instance de collection. Voir la section Création de collections 🎜. 🎜🎜🎜🎜🎜🎜map()🎜map La méthode  parcourt la collection et transmet chaque valeur dans la fonction de rappel donnée. Cette fonction de rappel peut arbitrairement modifier les éléments de collection et les renvoyer, générant ainsi une nouvelle collection d'éléments de collection modifiés : 🎜$collection = collect(['name' => 'Desk', 'price' => 200]);
$collection->toArray();
/*
    [
        ['name' => 'Desk', 'price' => 200],
    ]
*/🎜{note} Comme la plupart des autres méthodes de collection, map renverra un Un nouveau instance de collection ; il ne modifie pas la collection d’origine. Si vous souhaitez modifier la collection originale, veuillez utiliser la méthode transform🎜. 🎜
🎜🎜🎜🎜🎜mapInto()🎜 La méthode mapInto() peut parcourir une collection, créant de nouvelles instances d'une classe donnée en passant des valeurs au constructeur : 🎜$collection = collect(['name' => 'Desk', 'price' => 200]);
$collection->toJson();
// '{"name":"Desk", "price":200}'
🎜🎜🎜< div name= "e1f874" data-unique="e1f874">🎜🎜mapSpread()🎜La méthode mapSpread peut parcourir les éléments de la collection et donner la valeur de chaque élément imbriqué dans la fonction de rappel spécifiée. La fonction de rappel peut librement modifier l'élément de collection et le retourner, générant ainsi une nouvelle collection d'éléments de collection modifiés : 🎜$collection = collect([1, 2, 3, 4, 5]);
$collection->transform(function ($item, $key) {
    return $item * 2;
  });
$collection->all();
// [2, 4, 6, 8, 10]
🎜🎜🎜🎜🎜La méthode mapToGroups()🎜mapToGroups regroupe les éléments de la collection via la fonction de rappel donnée. La fonction de rappel doit renvoyer un tableau associatif contenant une seule paire clé/valeur, résultant en une nouvelle collection de valeurs groupées : 🎜$collection = collect([1 => ['a'], 2 => ['b']]);
$union = $collection->union([3 => ['c'], 1 => ['b']]);
$union->all();
// [1 => ['a'], 2 => ['b'], 3 => ['c']]
🎜🎜🎜🎜🎜mapWithKeys() La méthode 🎜mapWithKeys parcourt la collection et transmet chaque valeur dans la fonction de rappel donnée. Cette fonction de rappel renverra un tableau associatif contenant une seule paire clé/valeur : 🎜$collection = collect([1, 1, 2, 2, 3, 4, 2]);
$unique = $collection->unique();
$unique->values()->all();
// [1, 2, 3, 4]
🎜🎜🎜🎜🎜max()🎜max renvoie la valeur maximale de la clé spécifiée : 🎜$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'],
    ]
*/
🎜🎜🎜🎜🎜🎜La méthode median()
median()median 方法返回指定键的 中值：
$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'],
    ]
*/
merge()
merge 方法将合并指定的数组或集合到原集合。如果给定的集合项的字符串键与原集合中的字符串键相匹配，则指定集合项的值将覆盖原集合的值：
$collection = collect([1, 2, 3]);
$collection->unless(true, function ($collection) {
    return $collection->push(4);
  });
$collection->unless(false, function ($collection) {
    return $collection->push(5);
  });
$collection->all();
// [1, 2, 3, 5]
如果指定的集合项的键是数字，这些值将会追加到集合的末尾：
Collection::unwrap(collect('John Doe'));
// ['John Doe']Collection::unwrap(['John Doe']);
// ['John Doe']Collection::unwrap('John Doe');
// 'John Doe'
min()
min 方法返回指定键的最小值：
$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],
    ]
*/
mode()
mode 方法返回指定键的 众数 ：
$collection = collect([1, 2, 3]);
$collection->when(true, function ($collection) {
    return $collection->push(4);
  });
$collection->when(false, function ($collection) {
    return $collection->push(5);
  });
$collection->all();
// [1, 2, 3, 4]
nth()
nth 方法创建由每隔 n 个元素组成的一个新集合：
$collection = collect(['michael', 'tom']);
$collection->whenEmpty(function ($collection) {
    return $collection->push('adam');
  });
$collection->all();
// ['michael', 'tom']
$collection = collect();$collection->whenEmpty(function ($collection) {
    return $collection->push('adam');
  });
$collection->all();
 // ['adam']
$collection = collect(['michael', 'tom']);
$collection->whenEmpty(function($collection) {
    return $collection->push('adam');}, function($collection) {
        return $collection->push('taylor');
      });
$collection->all();
   // ['michael', 'tom', 'taylor']
你可以选择传入一个偏移位置作为第二个参数：
 $collection = collect(['michael', 'tom']);
 $collection->whenNotEmpty(function ($collection) {
    return $collection->push('adam');
   });
 $collection->all();
    // ['michael', 'tom', 'adam']
 $collection = collect();
 $collection->whenNotEmpty(function ($collection) {
     return $collection->push('adam');
   });
  $collection->all();
  // []
  $collection = collect();
  $collection->whenNotEmpty(function($collection) {
      return $collection->push('adam');
    }, 
  function($collection) {
        return $collection->push('taylor');
       });
   $collection->all();
 // ['taylor']
only()
only 方法返回集合中所有指定键的集合项：
$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],
    ]
*/
与 only 对应的是 except 方法。
pad()
pad 方法将使用给定的值填充数组，直到数组达到指定的大小。该方法的行为与 array_pad PHP 函数功能类似。
要填充到左侧，你应该使用负值。如果给定大小的绝对值小于或等于数组的长度，则不会发生填充：
$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],
    ]
*/
partition()
partition 方法可以和 PHP 函数中的 list 结合使用，用来分开通过指定条件的元素以及那些不通过指定条件的元素：
$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],
    ]
*/
pipe()
pipe 方法将集合传给指定的回调函数并返回结果：
$collection = collect([
    new User,    
    new User,    
    new Post,
 ]);
return $collection->whereInstanceOf(User::class);
pluck()
pluckmedian renvoie  pour la clé spécifiée Valeur 
 : 
$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],
    ]
*/
merge() La méthode merge fusionnera le tableau ou la collection spécifié dans la collection d'origine. Si la clé de chaîne de l'élément de collection donné correspond à la clé de chaîne de la collection d'origine, la valeur de l'élément de collection spécifié écrasera la valeur de la collection d'origine : 
$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],
    ]
*/
 Si la clé de l'élément de collection spécifié est un nombre, ces les valeurs seront ajoutées à la fin de la 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']
🎜🎜🎜🎜🎜min ()< /h4>🎜min renvoie la valeur minimale de la clé spécifiée : 🎜$collection = collect(['Chair', 'Desk']);
$zipped = $collection->zip([100, 200]);
$zipped->all();
// [['Chair', 100], ['Desk', 200]]
🎜🎜🎜 🎜🎜mode()🎜mode renvoie le Mode 🎜 : 🎜$users = User::where('votes', '>', 500)->get();
$users->each->markAsVip();
🎜🎜🎜🎜🎜nth( )< /h4>🎜ntième crée un nouvel ensemble composé de chaque nième élément : 🎜$users = User::where('group', 'Development')->get();
return $users->sum->votes;
🎜Vous pouvez choisir de passer dans une position décalée comme deuxième paramètre : 🎜rrreee🎜< a name="method-only">🎜🎜🎜🎜only()🎜only méthode Renvoie tous les éléments de la collection avec la clé spécifiée dans la collection : 🎜rrreee🎜 et only correspondent à la méthode sauf🎜. 🎜🎜🎜🎜🎜🎜pad()🎜pad La méthode  remplira le tableau avec les valeurs données jusqu'à ce que le tableau atteigne la taille spécifiée. Cette méthode se comporte de manière similaire à la fonction array_pad🎜 PHP. 🎜🎜Pour remplir vers la gauche, vous devez utiliser des valeurs négatives. Si la valeur absolue de la taille donnée est inférieure ou égale à la longueur du tableau, aucun remplissage ne se produira : 🎜rrreee🎜🎜🎜 🎜🎜La méthode partition()🎜partition peut être utilisée en conjonction avec la list dans la fonction PHP pour séparer les éléments qui satisfont aux conditions spécifiées et ceux qui ne satisfont pas à la condition spécifiée : 🎜rrreee🎜🎜🎜🎜🎜 La méthode pipe()🎜pipe transmet la collection à la fonction de rappel spécifiée et renvoie le résultat : 🎜rrreee🎜 🎜🎜🎜🎜pluck()🎜La méthode pluck peut obtenir toutes les valeurs correspondantes à la clé spécifiée dans la collection : 🎜rrreee🎜Vous aussi La clé de l'ensemble généré peut être spécifiée en passant le deuxième paramètre : 🎜rrreee🎜 S'il y a des clés en double, le dernier élément correspondant sera inséré dans l'ensemble sauté : 🎜rrreee🎜🎜🎜🎜🎜🎜La méthode pop()
pop()pop 方法从集合中移除并返回最后一个集合项：
rrreee
prepend()
prepend 方法将指定的值添加的集合的开头：
rrreee你也可以传递第二个参数来设置新增加集合项的键：
rrreee
pull()
pull 方法把指定键对应的值从集合中移除并返回：
rrreee
push()
push 方法把指定的值追加到集合项的末尾：
rrreee
put()
put 方法在集合内设置给定的键值对：
rrreee
random()
random 方法从集合中返回一个随机项：
rrreee你可以选择传入一个整数到 random 来指定要获取的随即项的数量。只要你显示传递你希望接收的数量时，则会返回项目的集合：
rrreee如果集合的项小于指定的数量，则该方法将抛出 InvalidArgumentException。
reduce()
reduce 方法将每次迭代的结果传递给下一次迭代直到集合减少为单个值：
rrreee第一次迭代时 $carry 的数值为 null； however，你也可以通过传入第二个参数到 reduce 来指定它的初始值：
rrreee
reject()
reject 方法使用指定的回调函数过滤集合。如果回调函数返回 true 就会把对应的集合项从集合中移除：
rrreee与 reject 方法对应的是 filter 方法。
reverse()
reversepop supprime de la collection et renvoie le dernier élément de la collection : 
rrreee  
prepend()
La méthode prepend ajoute la valeur spécifiée à la collection Début de : 🎜rrreee🎜Vous pouvez également transmettre le deuxième paramètre pour définir la clé de l'élément de collection nouvellement ajouté : 🎜rrreee🎜🎜🎜🎜🎜pull()🎜La méthode pull supprime la valeur correspondant à la clé spécifiée de la collection et renvoie : 🎜rrreee🎜🎜🎜🎜🎜push()🎜push descripteur de méthode La valeur spécifiée est ajoutée à la fin de l'élément de collection : 🎜rrreee🎜🎜🎜🎜🎜put( )🎜La méthode put définit la paire clé-valeur donnée dans la collection : 🎜rrreee🎜🎜🎜🎜🎜random()🎜La méthode random renvoie un élément aléatoire de la collection : 🎜rrreee🎜Vous pouvez choisir pour passer un entier à random spécifiant le nombre d'éléments aléatoires à obtenir. Tant que vous transmettez explicitement la quantité que vous souhaitez recevoir, une collection d'articles sera renvoyée : 🎜rrreee🎜 Si la collection contient moins que le nombre d'articles spécifié, cette méthode lancera une InvalidArgumentException. 🎜🎜🎜🎜🎜🎜réduire()🎜réduire La méthode  transmet le résultat de chaque itération à l'itération suivante jusqu'à ce que l'ensemble soit réduit à une seule valeur : 🎜rrreee🎜La valeur de $carry à la première itération est null< /code >; Cependant, vous pouvez également spécifier sa valeur initiale en passant le deuxième paramètre à reduce : 🎜rrreee🎜🎜🎜🎜🎜reject()🎜reject filtre la collection à l'aide de la fonction de rappel spécifiée. Si la fonction de rappel renvoie true, l'élément de collection correspondant sera supprimé de la collection : 🎜rrreee🎜Le correspondant à la méthode reject est filter🎜. 🎜🎜🎜🎜🎜🎜reverse()🎜reverse La méthode  est utilisée pour inverser l'ordre des éléments de collection et conserver les clés d'origine : 🎜rrreee🎜🎜🎜🎜🎜🎜La méthode search()
search()search 方法在集合中搜索给定的值并返回它的键。如果没有找到，则返回 false 。
rrreee使用 「宽松」的方式进行搜索，这意味着具有整数值的字符串会被认为等于相同值的整数。使用 「严格」的方式进行搜索，就传入 true 作为该方法的第二个参数：
rrreee或者，你可以通过传递回调函数来搜索通过条件测试的第一个集合项：
rrreee
shift()
shift 方法移除并返回集合的第一个集合项：
rrreee
shuffle()
shuffle 方法随机打乱集合项：
rrreee
slice()
slice 方法返回集合中给定索引开始后面的部分：
rrreee如果你想限制返回内容的大小，可以将你期望的大小作为第二个参数传递到该方法：
rrreee默认情况下，返回的内容将会保留原始键。如果你不希望保留原始键，你可以使用 values 方法来重新建立索引。
some()
contains 方法的别名。
sort()
sort 方法对集合进行排序。排序后的集合会保留原数组的键，所以在这个例子我们将使用 values 方法去把键重置为连续编号的索引：
rrreee如果你有更高级的排序需求，可以通过自己的算法将回调函数传递到 sort 。请参阅 PHP 文档的 uasort ，这是集合的 sort 方法在底层所调用的。
{tip} 如果你需要对嵌套数组或对象进行排序，请参照 sortBy 和 sortByDescsearch recherche dans la collection une valeur donnée et renvoie sa clé. S'il n'est pas trouvé, false est renvoyé. rrreee
 utilise une approche de recherche « détendue », ce qui signifie que les chaînes avec des valeurs entières sont considérées comme égales aux entiers de même valeur. Pour rechercher de manière "stricte", passez true comme deuxième paramètre de la méthode : 
rrreee Alternativement, vous pouvez passer une fonction de rappel pour rechercher la première collection qui réussit le test de condition Item : rrreee
🎜shift()🎜< Le code La méthode >shift supprime et renvoie le premier élément de la collection : 🎜rrreee🎜🎜🎜 🎜🎜 La méthode shuffle()🎜shuffle mélange aléatoirement les éléments de la collection : 🎜rrreee🎜🎜🎜🎜🎜slice()🎜slice renvoie la partie de la collection commençant à l'index donné : 🎜 rrreee🎜 Si vous souhaitez limiter la taille du contenu renvoyé, vous pouvez transmettre la taille souhaitée comme deuxième paramètre à cette méthode : 🎜rrreee🎜Par défaut, le contenu renvoyé conservera les clés d'origine. Si vous ne souhaitez pas conserver les clés d'origine, vous pouvez utiliser la méthode values🎜 pour réindexer. 🎜🎜🎜🎜🎜🎜some()🎜contient🎜 Alias de la méthode. 🎜🎜🎜🎜🎜🎜sort()🎜tri La méthode  trie la collection. La collection triée conservera les clés du tableau d'origine, donc dans cet exemple, nous utiliserons la méthode values🎜 pour réinitialiser les clés aux indices numérotés consécutivement : 🎜rrreee🎜Si vous avez des besoins de tri plus avancés, vous pouvez transmettre la fonction de rappel au tri avec votre propre algorithme. Veuillez vous référer à la documentation PHP pour uasort🎜 pour cela Il est appelé en bas par la méthode sort de la collection. 🎜🎜{tip} Si vous devez trier des tableaux ou des objets imbriqués, veuillez vous référer à sortBy🎜 et sortByDesc🎜. 🎜🎜🎜🎜🎜🎜🎜🎜La méthode sortBy()
sortBy()sortBy 方法将根据指定键对集合进行排序。排序后的集合会保留原始数组的键，所以在这个例子中我们使用 values 方法将键重置为连续编号的索引：
rrreee你也可以传递你自己的回调函数用于决定如何对集合的值进行排序：
rrreee
sortByDesc()
该方法与 sortBy 方法一样，但是会以相反的顺序来对集合进行排序。
sortKeys()
sortKeys 方法通过底层关联数组的键来对集合进行排序：
rrreee
sortKeysDesc()
该方法与 sortKeys 方法一样，但是会以相反的顺序来对集合进行排序。
splice()
splice 方法移除并返回指定索引开始的集合项片段：
rrreee你可以传递第二个参数用以限制被删除内容的大小：
rrreee此外，你可以传入含有新参数项的第三个参数来代替集合中删除的集合项：
rrreee
split()
split 方法将集合按照给定的值拆分：
rrreee
sum()
sum 方法返回集合内所有项的和：
rrreee如果集合包含嵌套数组或对象，则应该传入一个键来指定要进行求和的值：
rrreee另外，你可以传入自己的回调函数来决定要用集合中的哪些值进行求和：
rrreee
take()
take 方法返回给定数量项的新集合：
rrreee你也可以传递负整数从集合末尾获取指定数量的项：
rrreee
tap()
tapsortBy triera la collection en fonction de la clé spécifiée. La collection triée conserve les clés du tableau d'origine, donc dans cet exemple, nous utilisons la méthode values
 pour réinitialiser les clés aux indices numérotés consécutivement :  rrreee Vous pouvez également transmettre votre propre fonction de rappel qui détermine comment trier les valeurs de la collection : rrreee
🎜🎜 sortByDesc()🎜Cette méthode est la même que la méthode sortBy🎜, mais dans l'ordre inverse pour trier la collection. 🎜🎜🎜🎜🎜🎜sortKeys()🎜sortKeys  La méthode trie une collection par les clés du tableau associatif sous-jacent : 🎜rrreee🎜🎜🎜🎜🎜< code>sortKeysDesc()🎜Cette méthode est la même que la méthode sortKeys🎜, mais elle traitera l'ensemble dans ordre inverse Trier. 🎜🎜🎜🎜🎜🎜splice()🎜splice La méthode  supprime et renvoie le fragment de l'élément de collection en commençant à l'index spécifié : 🎜rrreee🎜 Vous pouvez passer un deuxième paramètre pour limiter la taille du contenu supprimé : 🎜rrreee🎜 De plus, vous pouvez transmettre un nouvel élément de paramètre Le troisième paramètre pour remplacer les éléments de collection supprimés dans la collection : 🎜rrreee🎜🎜🎜🎜🎜split( )🎜La méthode split divise la collection en fonction de la valeur donnée : 🎜rrreee🎜🎜🎜🎜🎜sum()🎜La méthode sum renvoie la somme de tous les éléments de l'ensemble : 🎜rrreee🎜Si l'ensemble contient imbriqué Si vous avez un ensemble de tableaux ou d'objets, vous devez transmettre une clé pour spécifier la valeur à additionner : 🎜rrreee🎜 Alternativement, vous pouvez transmettre votre propre fonction de rappel pour décider quelles valeurs de l'ensemble doivent être résumé : 🎜rrreee🎜< a name="method-take">🎜🎜🎜🎜take()🎜< code>take La méthode renvoie une nouvelle collection avec le nombre d'éléments donné : 🎜rrreee🎜 Vous pouvez également passer un entier négatif pour obtenir le nombre d'éléments spécifié à partir de la fin de la collection : 🎜rrreee🎜🎜🎜🎜🎜tap()🎜tap passe la méthode la fonction de rappel donnée dans la collection, vous permettant de "Toucher" une collection à un moment précis et d'effectuer certaines opérations sur les éléments de la collection sans affecter la collection elle-même : 🎜rrreee🎜🎜🎜🎜🎜🎜times()
times()静态 times 方法通过调用给定次数的回调函数来创建新集合：
rrreee使用这个方法可以与工厂结合使用创建出 Eloquent 模型：
rrreee
toArray()
toArray 方法将集合转换成 PHP 数组 。如果集合的值是 Eloquent 模型，那也会被转换成数组：
rrreee{note} toArray 也会将所有集合的嵌套对象转换为数组。如果你想获取原数组，可以使用 all 方法。
toJson()
toJson 方法将集合转换成 JSON 字符串：
rrreee
transform()
transform 方法迭代集合并对每一个集合项调用给定的回调函数。而集合的内容也会被回调函数的返回值所取代：
rrreee{note} 与大多数集合方法不同， transform 会修改集合本身。如果你想创建新集合，可以使用 map 方法。
union()
union 方法将给定的数组添加到集合。如果给定的数组含有与原集合一样的键，则原集合的值不会被改变：
rrreee
unique()
unique 方法返回集合中所有唯一项。返回的集合保留着原数组的键，所以在这个例子中，我们使用 values 方法把键重置为连续编号的索引：
rrreee在处理嵌套数组或对象时，你可以指定用于确定唯一性的键：
rrreee你也可以通过传递自己的回调函数来确定项的唯一性：
rrreeeunique 方法在检查项目值时使用「宽松」模式比较，意味着具有整数值的字符串将被视为等于相同值的整数。你可以使用 uniqueStrict 方法做「严格」模式比较。
uniqueStrict()
这个方法与 uniqueLa méthode statique times crée une nouvelle collection en appelant une fonction de rappel un nombre de fois donné : rrreee
Utilisez cette méthode conjointement avec une usine Créez un modèle Eloquent : rrreee
toArray() 🎜La méthode toArray convertit une collection en un array PHP. Si la valeur de la collection est un modèle Eloquent, elle sera également convertie en tableau : 🎜rrreee🎜{note} toArray convertira également tous les objets imbriqués de la collection en tableaux. Si vous souhaitez obtenir le tableau d'origine, vous pouvez utiliser la méthode all🎜. 🎜
🎜🎜🎜🎜🎜toJson()🎜 La méthode toJson convertit la collection en chaîne JSON : 🎜rrreee🎜🎜🎜🎜🎜 < La méthode code>transform()🎜transform parcourt la collection et appelle la fonction de rappel donnée pour chaque élément de la collection. Le contenu de la collection sera également remplacé par la valeur de retour de la fonction de rappel : 🎜rrreee🎜{note} Contrairement à la plupart des méthodes de collection, transform modifie la collection elle-même. Si vous souhaitez créer une nouvelle collection, vous pouvez utiliser la méthode map🎜. 🎜
🎜🎜🎜🎜🎜union()🎜 La méthode union ajoute le tableau donné à la collection. Si le tableau donné contient les mêmes clés que la collection d'origine, les valeurs de la collection d'origine ne seront pas modifiées : 🎜rrreee🎜🎜🎜🎜🎜unique()🎜La méthode unique renvoie tous les éléments uniques de la collection. La collection renvoyée conserve les clés du tableau d'origine, donc dans cet exemple, nous utilisons la méthode values🎜 pour réinitialiser les clés aux indices numérotés consécutivement : 🎜 rrreee 🎜Lorsque vous traitez des tableaux ou des objets imbriqués, vous pouvez spécifier la clé utilisée pour déterminer l'unicité : 🎜rrreee🎜Vous pouvez également déterminer l'unicité d'un élément en passant votre propre fonction de rappel : 🎜rrreee🎜unique La méthode utilise une comparaison en mode "détendu" lors de la vérification des valeurs des éléments, ce qui signifie que les chaînes avec des valeurs entières seront traitées comme des entiers égaux à la même valeur. Vous pouvez utiliser la méthode uniqueStrict🎜 pour effectuer une comparaison en mode "strict". 🎜🎜🎜🎜🎜🎜uniqueStrict()🎜Cette méthode est la identique à < a href="#method-unique">unique🎜 Même méthode, cependant, toutes les valeurs sont comparées en mode "strict". 🎜🎜🎜🎜🎜🎜🎜unless()
unless()unless 方法当传入的第一个参数不为 true 的时候，将执行给定的回调函数：
rrreee与 unless 对应的是 when 方法。
unlessEmpty()
whenNotEmpty 方法的别名。
unlessNotEmpty()
whenEmpty 方法的别名。
unwrap()
静态 unwrap 方法返回集合内部的可用值：
rrreee
values()
values 方法返回键被重置为连续编号的新集合：
rrreee
when()
when 方法当传入的第一个参数为 true 时，将执行给定的回调函数：
rrreee与 when 对应的是 unless 方法。
whenEmpty()
whenEmpty 方法当集合为空时，将执行给定的回调函数：
rrreee与 whenEmpty 对应的是 whenNotEmpty 方法。
whenNotEmpty()
whenNotEmpty 方法当集合不为空时，将执行给定的回调函数：
rrreee与 whenNotEmpty 对应的是 whenEmpty 方法。
where()
where 方法通过给定的键 / 值对过滤集合：
rrreeewhere 方法在检查集合项值时使用「宽松」模式比较，这意味着具有整数值的字符串会被认为等于相同值的整数。你可以使用 whereStrict 方法进行「严格」模式比较。
whereStrict()
这个方法与 whereLa méthode sauf exécutera ce qui est donné lorsque le premier paramètre passé n'est pas true La fonction de rappel :  rrreee
 et sauf si correspondent à la méthode when. 
🎜unlessEmpty()🎜whenNotEmpty🎜 Alias de la méthode. 🎜🎜🎜🎜🎜🎜unlessNotEmpty()🎜whenEmpty🎜 Alias de la méthode. 🎜🎜🎜🎜🎜🎜unwrap()🎜static La méthode unwrap renvoie les valeurs disponibles à l'intérieur de la collection : 🎜rrreee🎜🎜🎜🎜🎜< code>values()🎜values renvoie une nouvelle collection avec des clés réinitialisées à des nombres consécutifs : 🎜rrreee🎜🎜🎜< div name= "25703b" data-unique="25703b">🎜🎜when()🎜when lorsque le premier paramètre transmis est  true , la fonction de rappel donnée sera exécutée : 🎜rrreee🎜 et when correspondent à la méthode sauf si🎜 . 🎜🎜🎜🎜🎜🎜whenEmpty()🎜whenEmpty La méthode  exécutera la fonction de rappel donnée lorsque la collection est vide : 🎜rrreee🎜 correspond à whenEmpty est whenNotEmpty< /code> 🎜 méthode. 🎜🎜🎜🎜🎜🎜whenNotEmpty()🎜whenNotEmpty La méthode  exécutera la fonction de rappel donnée lorsque la collection n'est pas vide : 🎜rrreee🎜 correspond à whenNotEmpty est whenEmpty 🎜 méthode. 🎜🎜🎜🎜🎜🎜where()🎜where La méthode  filtre la collection en fonction de la paire clé/valeur donnée : 🎜rrreee🎜La méthode where utilise une comparaison en mode "détendu" lors de la vérification des valeurs des éléments de collection, ce qui signifie que les chaînes avec des valeurs entières Les entiers seront pris en compte égal à la même valeur. Vous pouvez utiliser la méthode whereStrict🎜 pour effectuer des comparaisons en mode "strict". 🎜🎜🎜🎜🎜🎜whereStrict()🎜Cette méthode est la identique à < a href="#method-where">where🎜 La méthode est similaire ; la différence est que la comparaison en mode "strict" est utilisée. 🎜🎜🎜🎜🎜🎜🎜La méthode whereBetween()
whereBetween()whereBetween 方法会用给定的范围对集合进行过滤：
rrreee
whereIn()
whereIn 会根据包含给定数组的键 / 值对来过滤集合：
rrreeewhereIn 方法使用「宽松」的比较来检查集合项的值，这意味着具有整数值的字符串会被视为等于相同值的整数。你可以使用 whereInStrict 方法进行「严格」模式比较。
whereInStrict()
这个方法与 whereIn 方法类似；不同的是会使用「严格」模式进行比较。
whereInstanceOf()
whereInstanceOf 方法根据指定的类来过滤集合：
rrreee
whereNotBetween()
whereNotBetween 方法在指定的范围内过滤集合：
rrreee
whereNotIn()
whereNotIn 方法根据通过指定的键和不含有指定数组的值来对集合进行过滤：
rrreeewhereNotIn 方法使用「宽松」模式比较来检查集合项的值，这意味着具有整数值的字符串将被视为等于相同值的整数。你可以使用 whereNotInStrict 方法做 「严格」模式比较。
whereNotInStrict()
这个方法与 whereNotIn 方法类似；不同的是会使用 「严格」模式作比较。
wrap()
静态 wrap 方法在适当的情况下将指定的值放在集合中：
rrreee
zip()
zipwhereBetween filtrera la collection en utilisant la plage donnée : 
rrreee < div name="5b24c1" data-unique="5b24c1">
whereIn()
whereIn sera basé sur la clé contenant le tableau donné/ Paires de valeurs pour filtrer la collection : 🎜rrreee🎜 La méthode whereIn utilise une comparaison "détendue" pour vérifier la valeur d'un élément de collection, ce qui signifie que les chaînes avec des valeurs entières sont traitées comme des entiers égaux à la même valeur. Vous pouvez utiliser la méthode whereInStrict🎜 pour une comparaison en mode "strict". 🎜🎜🎜🎜🎜🎜whereInStrict()🎜Cette méthode est la identique à < a href="#method-wherein">whereIn🎜 La méthode est similaire ; la différence est que le mode « strict » est utilisé pour la comparaison. 🎜🎜🎜🎜🎜🎜whereInstanceOf()🎜whereInstanceOf  Méthode pour filtrer la collection en fonction de la classe spécifiée : 🎜rrreee🎜🎜🎜🎜🎜 La méthode WhereNotBetween()🎜whereNotBetween filtre la collection dans la plage spécifiée : 🎜rrreee🎜🎜🎜🎜🎜whereNotIn()🎜whereNotIn filtre la collection en fonction de la clé spécifiée et des valeurs qui le font ne contient pas le tableau spécifié :🎜rrreee🎜 La méthode whereNotIn utilise la comparaison en mode "détendu" pour vérifier la valeur d'un élément de collection, ce qui signifie qu'une chaîne avec une valeur entière sera traitée comme un nombre entier égal à la même valeur. Vous pouvez utiliser la méthode whereNotInStrict🎜 pour effectuer des comparaisons en mode "strict". 🎜🎜🎜🎜🎜🎜whereNotInStrict()🎜Cette méthode est la identique à < a href="#method-wherenotin">whereNotIn🎜 La méthode est similaire ; la différence est que le mode "strict" est utilisé pour la comparaison. 🎜🎜🎜🎜🎜🎜wrap()🎜static La méthode wrap place la valeur spécifiée dans la collection le cas échéant : 🎜rrreee🎜🎜🎜 🎜🎜< code>zip()🎜zip fusionne la valeur du tableau spécifié avec la valeur de la collection d'origine à l'index correspondant : 🎜rrreee🎜🎜🎜🎜🎜 🎜Messagerie avancéeLes collections prennent également en charge la « Messagerie avancée », qui est une collection de raccourcis pour les opérations courantes. Les méthodes de collecte qui prennent en charge la messagerie de haut niveau sont : averageaverage, avg, contains, each, every, filter, first, flatMap, groupBy, keyBy, map, max, min, partition, reject, some, sortBy, sortByDesc, sum, and unique。
每个高阶消息传递都能作为集合实例的动态的属性来访问。例如，使用 each 高阶消息传递在集合中的每个对象上调用一个方法：
rrreee同样，我们可以使用 sum, avg
, contient, chaque, chaque< /code>, filtre
, premier
, flatMap🎜, groupBy🎜,  keyBy🎜, carte🎜, max 🎜, min🎜, partition🎜, rejeter🎜, certains🎜,  sortBy🎜, sortByDesc🎜, somme🎜, et unique🎜. 🎜🎜Chaque message d'ordre supérieur transmis est accessible en tant que propriété dynamique de l'instance de collection. Par exemple, utilisez la messagerie d'ordre supérieur each pour appeler une méthode sur chaque objet de la collection : 🎜rrreee🎜De même, nous pouvons utiliser la messagerie d'ordre supérieur sum pour collecter les utilisateurs. Nombre total de « votes » dans la collection : 🎜rrreee🎜Cet article a été publié pour la première fois sur le site 🎜LearnKu.com🎜. 🎜🎜
← système de mise en cache
système d'événements →
soumettre
MaisonvidéosQuestions et réponsesMon
Site Web PHP chinois
MaisonCoursArticleQuestions et réponsesDictionnaireManuelTéléchargerrecherche APPTélécharger