3-collections.pdf

Laracon EU tickets are now available! Get your tickets today!

SEARCH

5.8

☰

Des collections # introduction # Création de collections # Extension des collections

# Méthodes disponibles # Messages d'ordre supérieur

# introduction La classe fournit un wrapper fluide et pratique pour travailler avec des tableaux de données. Par exemple, consultez le code suivant. Nous utiliserons l' assistant pour créer une nouvelle instance de collection à partir du tableau, exécuter la fonction sur chaque élément, puis supprimer tous les éléments vides: Illuminate\Support\Collection collect strtoupper

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

Comme vous pouvez le constater, la Collection classe vous permet d’enchaîner ses méthodes pour effectuer un mappage fluide et réduire le tableau sous-jacent. En général, les collections sont immuables, ce qui signifie que chaque Collection méthode renvoie une Collection instance entièrement nouvelle .

Création de collections Comme mentionné ci-dessus, l' collect assistant renvoie une nouvelle instance pour le tableau donné. Donc, créer une collection est aussi simple que: Illuminate\Support\Collection

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

Les résultats des requêtes Eloquent sont toujours renvoyés en tant Collection qu'instances.

Extension des collections Les collections sont "macroables", ce qui vous permet d'ajouter des méthodes supplémentaires à la Collection classe au moment de l'exécution. Par exemple, le code suivant ajoute une toUpper méthode

à la Collection classe:

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

En règle générale, vous devez déclarer les macros de collecte dans un fournisseur de services .

# Méthodes disponibles Pour le reste de cette documentation, nous discuterons de chaque méthode disponible dans la Collection classe. N'oubliez pas que toutes ces méthodes peuvent être chaînées pour manipuler

couramment le tableau sous-jacent. De plus, presque chaque méthode renvoie une nouvelle Collection instance, ce qui vous permet de conserver la copie originale de la collection lorsque cela est

nécessaire: tous

combiner

countBy

moyenne

concat

Crossjoin

Avg

contient

dd

morceau

containsStrict

diff

effondrement

nombre

diffAssoc

diffKeys

mapWithKeys

divisée

vidage

max

somme

chaque

médian de

prendre

eachSpread

fusion

tap

tous

min en

fois

sauf le

mode

toArray

filtre

nième

toJson

premier

seul

transform

firstWhere

pad

union

flatMap

partition

unique ,

aplatissent

tuyau

uniqueStrict

chiquenaude

plumer

moins

oublier

pop

unlessEmpty

forPage

précédez

unlessNotEmpty

se

traction

Déballer

groupBy

poussée

valeurs

a

mis

quand

imploser

aléatoire

whenEmpty

Intersection

permettent de réduire de

whenNotEmpty

intersectByKeys

rejet

où

isEmpty

inverse

whereStrict entre

isNotEmpty

recherche

lesquels

joindre

changement

laquelle

keyBy

aléatoire

whereInStrict

clés

tranche

whereInstanceOf

dernière

quelque

whereNotBetween

macro

tri

whereNotIn

make

sortBy

whereNotInStrict

carte

sortByDesc des

wrap

mapInto

clefs de tri

zip

mapSpread

sortKeysDesc

mapToGroups

épissure

# Liste de méthode all() La all méthode retourne le tableau sous-jacent représenté par la collection:

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

// [1, 2, 3]

average() Alias pour la avg méthode.

avg() La avg méthode retourne la valeur moyenne d'une clé donnée:

$average = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->avg('foo');

// 20

$average = collect([1, 1, 2, 4])->avg();

// 2

chunk() La chunk méthode divise la collection en plusieurs collections plus petites d’une taille donnée:

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

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

$chunks->toArray();

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

Cette méthode est particulièrement utile dans les vues lorsque vous travaillez avec un système de grille tel que Bootstrap . Imaginez que vous ayez une collection de modèles Eloquent que vous souhaitez afficher dans une grille:

@foreach ($products->chunk(3) as $chunk) @endforeach

collapse() La collapse méthode réduit une collection de tableaux en une seule collection plate:

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

$collapsed = $collection->collapse();

$collapsed->all();

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

combine() La combine méthode combine les valeurs de la collection, sous forme de clés, avec les valeurs d'un autre tableau ou d'une autre collection:

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

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

$combined->all();

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

concat() La concat méthode ajoute les array valeurs données ou de collection à la fin de la collection:

$collection = collect(['John Doe']);

$concatenated = $collection->concat(['Jane Doe'])->concat(['name' => 'Johnny Doe']);

$concatenated->all();

// ['John Doe', 'Jane Doe', 'Johnny Doe']

contains() La contains méthode détermine si la collection contient un élément donné:

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

$collection->contains('Desk');

// true

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

// false

Vous pouvez également passer une paire clé / valeur à la contains méthode, qui déterminera si la paire donnée existe dans la collection:

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

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

// false

Enfin, vous pouvez également passer un rappel à la contains méthode pour effectuer votre propre test de vérité:

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

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

// false

La contains méthode utilise des comparaisons "lâches" lors de la vérification des valeurs d'élément, ce qui signifie qu'une chaîne avec une valeur entière sera considérée comme égale à un entier de même valeur. Utilisez la containsStrict méthode pour filtrer en utilisant des comparaisons "strictes".

containsStrict() Cette méthode a la même signature que la contains méthode; Cependant, toutes les valeurs sont comparées à l'aide de comparaisons "strictes".

count() La count méthode renvoie le nombre total d'éléments de la collection:

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

$collection->count();

// 4

countBy() La countBy méthode compte les occurrences de valeurs dans la collection. Par défaut, la méthode compte les occurrences de chaque élément:

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

$counted = $collection->countBy();

$counted->all();

// [1 => 1, 2 => 3, 3 => 1]

Cependant, vous passez un rappel à la countBy méthode pour compter tous les éléments selon une valeur personnalisée:

$collection = collect(['[email protected]', '[email protected]', '[email protected]']);

$counted = $collection->countBy(function ($email) { return substr(strrchr($email, "@"), 1);

});

$counted->all();

// ['gmail.com' => 2, 'yahoo.com' => 1]

crossJoin() La crossJoin méthode relie les valeurs de la collection parmi les tableaux ou collections donnés, renvoyant un produit cartésien avec toutes les permutations possibles:

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

$matrix = $collection->crossJoin(['a', 'b']);

$matrix->all();

/* [ [1, 'a'], [1, 'b'], [2, 'a'], [2, 'b'], ] */

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

$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']);

$matrix->all();

/* [ [1, 'a', 'I'], [1, 'a', 'II'], [1, 'b', 'I'], [1, 'b', 'II'], [2, 'a', 'I'], [2, 'a', 'II'], [2, 'b', 'I'],

[2, 'b', 'II'], ] */

dd() La dd méthode vide les éléments de la collection et termine l'exécution du script:

$collection = collect(['John Doe', 'Jane Doe']);

$collection->dd();

/* Collection { #items: array:2 [ 0 => "John Doe" 1 => "Jane Doe" ] } */

Si vous ne souhaitez pas arrêter l'exécution du script, utilisez dump plutôt la méthode.

diff() La diff méthode compare la collection à une autre collection ou à un simple PHP en array fonction de ses valeurs. Cette méthode renverra les valeurs de la collection d'origine qui ne sont pas présentes dans la collection donnée:

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

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

$diff->all();

// [1, 3, 5]

diffAssoc()

La diffAssoc méthode compare la collection à une autre collection ou à un simple PHP en array fonction de ses clés et de ses valeurs. Cette méthode renverra les paires clé / valeur de la

collection d'origine qui ne sont pas présentes dans la collection donnée:

$collection = collect([ 'color' => 'orange', 'type' => 'fruit', 'remain' => 6 ]);

$diff = $collection->diffAssoc([ 'color' => 'yellow', 'type' => 'fruit', 'remain' => 3, 'used' => 6 ]);

$diff->all();

// ['color' => 'orange', 'remain' => 6]

diffKeys() La diffKeys méthode compare la collection à une autre collection ou à un simple PHP en array fonction de ses clés. Cette méthode renverra les paires clé / valeur de la collection d'origine qui

ne sont pas présentes dans la collection donnée:

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

dump() La dump méthode vide les éléments de la collection:

$collection = collect(['John Doe', 'Jane Doe']);

$collection->dump();

/* Collection { #items: array:2 [ 0 => "John Doe" 1 => "Jane Doe" ] } */

Si vous souhaitez arrêter l'exécution du script après le vidage de la collection, utilisez dd plutôt la méthode.

each() La each méthode itère sur les éléments de la collection et transmet chaque élément à un rappel:

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

Si vous souhaitez arrêter de parcourir les éléments, vous pouvez revenir false de votre rappel:

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

} });

eachSpread() La eachSpread méthode itère sur les éléments de la collection, en passant chaque valeur d'élément imbriquée dans le rappel donné:

$collection = collect([['John Doe', 35], ['Jane Doe', 33]]);

$collection->eachSpread(function ($name, $age) { // });

Vous pouvez arrêter de parcourir les éléments en revenant false du rappel:

$collection->eachSpread(function ($name, $age) { return false; });

every() La every méthode peut être utilisée pour vérifier que tous les éléments d'une collection réussissent un test de vérité donné:

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

// false

Si la collection est vide, every retournera true:

$collection = collect([]);

$collection->every(function($value, $key) { return $value > 2; });

// true

except() La except méthode retourne tous les éléments de la collection sauf ceux avec les clés spécifiées:

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

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

$filtered->all();

// ['product_id' => 1]

Pour l'inverse de except , voir la seule méthode.

filter() La filter méthode filtre la collection en utilisant le rappel donné, en ne conservant que les éléments qui passent un test de vérité donné:

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

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

$filtered->all();

// [3, 4]

Si aucun rappel n'est fourni, toutes les entrées de la collection équivalentes à false seront supprimées:

$collection = collect([1, 2, 3, null, false, '', 0, []]);

$collection->filter()->all();

// [1, 2, 3]

Pour l'inverse de filter , voir la méthode de rejet .

first() La first méthode retourne le premier élément de la collection qui passe un test de vérité donné:

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

// 3

Vous pouvez également appeler la first méthode sans argument pour obtenir le premier élément de la collection. Si la collection est vide, null est renvoyé:

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

// 1

firstWhere() La firstWhere méthode retourne le premier élément de la collection avec la paire clé / valeur donné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]

Vous pouvez également appeler la firstWhere méthode avec un opérateur:

$collection->firstWhere('age', '>=', 18);

// ['name' => 'Diego', 'age' => 23]

Comme pour la méthode where , vous pouvez passer un argument à la firstWhere méthode. Dans ce scénario, la firstWhere méthode renvoie le premier élément où la valeur de la clé d'élément donnée est "vérité":

$collection->firstWhere('age');

// ['name' => 'Linda', 'age' => 14]

flatMap() La flatMap méthode parcourt la collection et transmet chaque valeur au rappel donné. Le rappel est libre de modifier l'élément et de le retourner, formant ainsi une nouvelle collection d'éléments modifiés. Ensuite, le tableau est aplati par un niveau:

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

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

$flattened->all();

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

flatten() La flatten méthode aplatit une collection multidimensionnelle en une seule dimension:

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

$flattened = $collection->flatten();

$flattened->all();

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

// [ tay o

,

p p ,

ja asc

pt ];

Vous pouvez éventuellement transmettre à la fonction un argument "depth":

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

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

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

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

Dans cet exemple, appeler flatten sans fournir la profondeur aurait également aplati les tableaux imbriqués, ce qui aurait entraîné . Fournir une profondeur vous permet de limiter les niveaux de tableaux imbriqués qui seront aplatis. ['iPhone 6S', 'Apple', 'Galaxy S7', 'Samsung']

flip() La flip méthode échange les clés de la collection avec leurs valeurs correspondantes:

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

$flipped = $collection->flip();

$flipped->all();

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

forget() La forget méthode supprime un élément de la collection par sa clé:

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

$collection->forget('name');

$collection->all();

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

Contrairement à la plupart des autres méthodes de collecte, forget ne renvoie pas une nouvelle collection modifiée. il modifie la collection sur laquelle il est appelé.

forPage() La forPage méthode retourne une nouvelle collection contenant les éléments qui seraient présents sur un numéro de page donné. La méthode accepte le numéro de page comme premier argument et le nombre d'éléments à afficher par page comme deuxième argument:

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

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

$chunk->all();

// [4, 5, 6]

get() La get méthode renvoie l'élément à une clé donnée. Si la clé n'existe pas, null est renvoyé:

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

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

// taylor

Vous pouvez éventuellement passer une valeur par défaut comme deuxième argument:

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

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

// default-value

Vous pouvez même transmettre un rappel comme valeur par défaut. Le résultat du rappel sera renvoyé si la clé spécifiée n'existe pas:

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

// default-value

groupBy() La groupBy méthode regroupe les éléments de la collection selon une clé donnée:

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

[ account_id

=>

account-x11 ,

product

=>

Desk ],

], ] */

Au lieu de passer une chaîne key , vous pouvez passer un rappel. Le rappel devrait renvoyer la valeur que vous souhaitez utiliser pour le groupe:

$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'], ], ] */

Plusieurs critères de regroupement peuvent être passés en tant que tableau. Chaque élément de tableau sera appliqué au niveau correspondant dans un tableau multidimensionnel:

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

], $preserveKeys

true);

/* [ 1 => [ 'Role_1' => [ 10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']], 20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']], ], 'Role_2' => [ 20 => ['user' => 2, 'skill' => 1, 'roles' => ['Role_1', 'Role_2']], ], 'Role_3' => [ 10 => ['user' => 1, 'skill' => 1, 'roles' => ['Role_1', 'Role_3']], ], ], 2 => [ 'Role_1' => [ 30 => ['user' => 3, 'skill' => 2, 'roles' => ['Role_1']], ], 'Role_2' => [ 40 => ['user' => 4, 'skill' => 2, 'roles' => ['Role_2']], ], ], ]; */

has() La has méthode détermine si une clé donnée existe dans la collection:

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

$collection->has('product');

// true

$collection->has(['product', 'amount']);

// true

$

ll

ti

h

(['

t'

'

i

'])

$collection->has(['amount', 'price']);

// false

implode() La implode méthode joint les éléments d'une collection. Ses arguments dépendent du type d'éléments de la collection. Si la collection contient des tableaux ou des objets, vous devez passer la clé des attributs que vous souhaitez rejoindre, ainsi que la chaîne "colle" que vous souhaitez placer entre les valeurs:

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

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

// Desk, Chair

Si la collection contient des chaînes simples ou des valeurs numériques, passez le "glue" comme seul argument de la méthode:

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

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

intersect() La intersect méthode supprime les valeurs de la collection d'origine qui ne sont pas présentes dans la donnée array ou la collection. La collection résultante conservera les clés de la collection originale:

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

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

$intersect->all();

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

intersectByKeys() La intersectByKeys méthode supprime toutes les clés de la collection d'origine qui ne sont pas présentes dans la donnée array ou la collection:

$collection = collect([ 'serial' => 'UX301', 'type' => 'screen', 'year' => 2009 ]);

$intersect = $collection->intersectByKeys([ 'reference' => 'UX404', 'type' => 'tab', 'year' => 2011 ]);

$intersect->all();

// ['type' => 'screen', 'year' => 2009]

isEmpty() La isEmpty méthode retourne true si la collection est vide. sinon, false est retourné:

collect([])->isEmpty();

// true

isNotEmpty() La isNotEmpty méthode retourne true si la collection n'est pas vide. sinon, false est retourné:

collect([])->isNotEmpty();

// false

join() La join méthode joint les valeurs de la collection avec une chaîne:

collect(['a', 'b', 'c'])->join(', '); // 'a, b, c' collect(['a', 'b', 'c'])->join(', ', ', and '); // 'a, b, and c' collect(['a', 'b'])->join(', ', ' and '); // 'a and b' collect(['a'])->join(', ', ' and '); // 'a' collect([])->join(', ', ' and '); // ''

keyBy() La keyBy méthode clé la collection par la clé donnée. Si plusieurs éléments ont la même clé, seul le dernier apparaîtra dans la nouvelle collection:

$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'], ] */

Vous pouvez également transmettre un rappel à la méthode. Le rappel doit renvoyer la valeur permettant de saisir la collection par:

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

$keyed->all();

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

] */

keys() La keys méthode retourne toutes les clés de la collection:

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

$keys = $collection->keys();

$keys->all();

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

last() La last méthode retourne le dernier élément de la collection qui passe un test de vérité donné:

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

// 2

Vous pouvez également appeler la last méthode sans argument pour obtenir le dernier élément de la collection. Si la collection est vide, null est renvoyé:

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

// 4

macro()

La macro méthode statique vous permet d'ajouter des méthodes à la Collection classe au moment de l'exécution. Reportez-vous à la documentation sur l' extension des collections pour plus d'informations.

make() La make méthode statique crée une nouvelle instance de collection. Voir la section Création de collections .

map() La map méthode parcourt la collection et transmet chaque valeur au rappel donné. Le rappel est libre de modifier l'élément et de le retourner, formant ainsi une nouvelle collection d'éléments modifiés:

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

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

$multiplied->all();

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

Comme la plupart des méthodes de collecte, map renvoie une nouvelle instance de collecte; il ne modifie pas la collection sur laquelle il est appelé. Si vous souhaitez transformer la collection d'origine, utilisez la transform méthode.

mapInto() La méthode itère sur la collection, créant une nouvelle instance de la classe donnée en transmettant la valeur au constructeur: mapInto()

class Currency { /** * Create a new currency instance. * * @param

string

* @return void

$code

*/ 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')]

mapSpread() La mapSpread méthode itère sur les éléments de la collection, en passant chaque valeur d'élément imbriquée dans le rappel donné. Le rappel est libre de modifier l'élément et de le retourner, formant ainsi une nouvelle collection d'éléments modifiés:

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

mapToGroups() La mapToGroups méthode regroupe les éléments de la collection en fonction du rappel donné. Le rappel doit renvoyer un tableau associatif contenant une seule paire clé / valeur, formant ainsi une nouvelle collection de valeurs groupées:

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

mapWithKeys() La mapWithKeys méthode parcourt la collection et transmet chaque valeur au rappel donné. Le rappel doit renvoyer un tableau associatif contenant une seule paire clé / valeur:

$collection = collect([ [ 'name' => 'John',

'department' => 'Sales', 'email' => '[email protected]' ], [ 'name' => 'Jane', 'department' => 'Marketing', 'email' => '[email protected]' ] ]);

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

$keyed->all();

/* [ '[email protected]' => 'John', '[email protected]' => 'Jane', ] */

max() La max méthode renvoie la valeur maximale d'une clé donnée:

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

// 20

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

// 5

median() La median méthode renvoie la valeur médiane d'une clé donnée:

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

$median

collect([[ foo

> 10], [ foo

> 10], [ foo

> 20], [ foo

> 40]]) >median( foo );

// 15

$median = collect([1, 1, 2, 4])->median();

// 1.5

merge() La merge méthode fusionne le tableau ou la collection donné avec la collection d'origine. Si une clé de chaîne dans les éléments donnés correspond à une clé de chaîne dans la collection d'origine, sa valeur remplacera la valeur de la collection d'origine:

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

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

$merged->all();

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

Si les clés des éléments donnés sont numériques, les valeurs seront ajoutées à la fin de la collection:

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

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

$merged->all();

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

min() La min méthode retourne la valeur minimale d'une clé donnée:

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

// 10

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

// 1

mode() La mode méthode retourne la valeur de mode d'une clé donnée:

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

// [10]

$mode = collect([1, 1, 2, 4])->mode();

// [1]

nth() La nth méthode crée une nouvelle collection composée de chaque nième élément:

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

$collection->nth(4);

// ['a', 'e']

Vous pouvez éventuellement passer un offset comme second argument:

$collection->nth(4, 1);

// ['b', 'f']

only() La only méthode retourne les éléments de la collection avec les clés spécifiées:

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

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

$filtered->all();

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

Pour l'inverse de only , voir la méthode except .

pad() La pad méthode remplira le tableau avec la valeur donnée jusqu'à ce que le tableau atteigne la taille spécifiée. Cette méthode se comporte comme la fonction PHP array_pad . Pour remplir à gauche, vous devez spécifier une taille négative. Aucun remplissage ne se produira si la valeur absolue de la taille donnée est inférieure ou égale à la longueur du tableau:

$collection = collect(['A', 'B', 'C']);

$filtered = $collection->pad(5, 0);

$filtered->all();

// ['A', 'B', 'C', 0, 0]

$filtered = $collection->pad(-5, 0);

$filtered->all();

// [0, 0, 'A', 'B', 'C']

partition() La partition méthode peut être combinée avec la list fonction PHP pour séparer les éléments qui passent un test de vérité donné de ceux qui ne le font pas:

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

pipe() La pipe méthode passe la collection au rappel donné et renvoie le résultat:

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

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

// 6

pluck() La pluck méthode récupère toutes les valeurs pour une clé donnée:

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

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

$plucked->all();

// ['Desk', 'Chair']

Vous pouvez également spécifier comment vous souhaitez que la collection résultante soit saisie:

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

$plucked->all();

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

S'il existe des clés en double, le dernier élément correspondant sera inséré dans la collection pincée:

$collection = collect([ ['brand' => 'Tesla',

'color' => 'red'],

['brand' => 'Pagani', 'color' => 'white'], ['brand' => 'Tesla',

'color' => 'black'],

['brand' => 'Pagani', 'color' => 'orange'], ]);

$plucked = $collection->pluck('color', 'brand');

$plucked->all();

// ['Tesla' => 'black', 'Pagani' => 'orange']

pop() La pop méthode supprime et retourne le dernier élément de la collection:

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

$collection->pop();

// 5

$collection->all();

// [1, 2, 3, 4]

prepend()

La prepend méthode ajoute un élément au début de la collection:

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

$collection->prepend(0);

$collection->all();

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

Vous pouvez également passer un deuxième argument pour définir la clé de l'élément ajouté:

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

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

$collection->all();

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

pull() La pull méthode supprime et retourne un élément de la collection par sa clé:

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

$collection->pull('name');

// 'Desk'

$collection->all();

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

push() La push méthode ajoute un élément à la fin de la collection:

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

$collection->push(5);

$collection->all();

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

put() La put méthode définit la clé et la valeur données dans la collection:

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

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

$collection->all();

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

random() La random méthode retourne un élément aléatoire de la collection:

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

$collection->random();

// 4 - (retrieved randomly)

Vous pouvez éventuellement passer un entier pour random spécifier le nombre d'éléments que vous souhaitez récupérer de manière aléatoire. Une collection d'éléments est toujours renvoyée lorsque vous transmettez explicitement le nombre d'éléments que vous souhaitez recevoir:

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

$random->all();

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

Si la collection contient moins d'éléments que demandé, la méthode lancera un InvalidArgumentException .

reduce() La reduce méthode réduit la collection à une valeur unique, en passant le résultat de chaque itération à l'itération suivante:

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

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

// 6

La valeur pour $carry la première itération est null ; Cependant, vous pouvez spécifier sa valeur initiale en passant un deuxième argument à reduce :

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

// 10

reject() La reject méthode filtre la collection en utilisant le rappel donné. Le rappel doit renvoyer true si l'élément doit être supprimé de la collection résultante:

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

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

$filtered->all();

// [1, 2]

Pour l'inverse de la reject méthode, voir la filter méthode.

reverse() La reverse méthode inverse l'ordre des éléments de la collection, en conservant les clés d'origine:

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

$reversed = $collection->reverse();

$reversed->all();

/* [ 4 => 'e', 3 => 'd', 2 => 'c', 1 => 'b', 0 => 'a', ] */

search() La search méthode recherche la valeur donnée dans la collection et renvoie sa clé si elle est trouvée. Si l'élément n'est pas trouvé, false est retourné.

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

$collection->search(4);

// 1

La recherche est effectuée à l'aide d'une comparaison "en vrac", ce qui signifie qu'une chaîne avec une valeur entière sera considérée comme égale à un entier de même valeur. Pour utiliser la comparaison

"stricte", passez true le deuxième argument à la méthode:

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

// false

Vous pouvez également passer votre propre rappel pour rechercher le premier élément qui passe votre test de vérité:

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

// 2

shift() La shift méthode supprime et retourne le premier élément de la collection:

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

$collection->shift();

// 1

$collection->all();

// [2, 3, 4, 5]

shuffle() La shuffle méthode mélange aléatoirement les éléments de la collection:

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

$shuffled = $collection->shuffle();

$shuffled->all();

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

slice() La slice méthode retourne une tranche de la collection commençant à l'index donné:

$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 vous souhaitez limiter la taille de la tranche renvoyée, transmettez la taille souhaitée en tant que deuxième argument de la méthode:

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

$slice->all();

// [5, 6]

La tranche retournée conservera les clés par défaut. Si vous ne souhaitez pas conserver les clés d'origine, vous pouvez utiliser la values méthode pour les réindexer.

some() Alias pour la contains méthode.

sort() La sort méthode trie la collection. La collection triée conserve les clés de tableau d'origine. Dans cet exemple, nous allons utiliser la values méthode pour réinitialiser les clés sur des index numérotés consécutivement:

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

$sorted = $collection->sort();

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

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

Si vos besoins de tri sont plus avancés, vous pouvez passer un rappel à sort votre propre algorithme. Reportez-vous à la documentation PHP sur uasort , qui est ce que la sort méthode de la collection appelle sous le capot.

Si vous devez trier une collection de tableaux ou d'objets imbriqués, voir les méthodes sortBy et sortByDesc .

sortBy() La sortBy méthode trie la collection en fonction de la clé donnée. La collection triée conserve les clés de tableau d'origine. Dans cet exemple, nous allons utiliser la values méthode pour réinitialiser les clés sur des index numérotés consécutivement:

$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], ] */

Vous pouvez également transmettre votre propre rappel pour déterminer comment trier les valeurs de la collection:

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

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

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

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

sortByDesc() Cette méthode a la même signature que la sortBy méthode, mais triera la collection dans l'ordre inverse.

sortKeys() La sortKeys méthode trie la collection en fonction des clés du tableau associatif sous-jacent:

$collection = collect([ 'id' => 22345, 'first' => 'John', 'last' => 'Doe', ]);

$sorted = $collection->sortKeys();

$sorted->all();

/*

[ 'first' => 'John', 'id' => 22345, 'last' => 'Doe', ] */

sortKeysDesc() Cette méthode a la même signature que la sortKeys méthode, mais triera la collection dans l'ordre inverse.

splice() La splice méthode supprime et retourne une tranche d'éléments à partir de l'index spécifié:

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

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

$chunk->all();

// [3, 4, 5]

$collection->all();

// [1, 2]

Vous pouvez passer un deuxième argument pour limiter la taille du bloc résultant:

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

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

$chunk->all();

// [3]

$collection->all();

// [1, 2, 4, 5]

De plus, vous pouvez passer un troisième argument contenant les nouveaux éléments pour remplacer les éléments supprimé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]

split() La split méthode divise une collection en un nombre donné de groupes:

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

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

$groups->toArray();

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

sum() La sum méthode retourne la somme de tous les éléments de la collection:

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

// 15

Si la collection contient des tableaux ou des objets imbriqués, vous devez transmettre une clé à utiliser pour déterminer les valeurs à additionner:

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

$collection->sum('pages');

// 1272

De plus, vous pouvez passer votre propre rappel pour déterminer les valeurs de la collection à additionner:

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

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

// 6

take() La take méthode retourne une nouvelle collection avec le nombre d'éléments spécifié:

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

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

$chunk->all();

// [0, 1, 2]

Vous pouvez également passer un entier négatif pour prendre le nombre spécifié d'éléments de la fin de la collection:

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

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

$chunk->all();

// [4, 5]

tap() La tap méthode transmet la collection au rappel spécifié, vous permettant de "taper" sur la collection à un moment donné et de faire quelque chose avec les éléments sans affecter la collection elle-même:

collect([2, 4, 3, 1, 5]) ->sort() ->tap(function ($collection) { Log::debug('Values after sorting', $collection->values()->toArray()); }) ->shift();

// 1

times() La times méthode statique crée une nouvelle collection en appelant le rappel plusieurs fois:

$collection = Collection::times(10, function ($number) { return $number * 9; });

$collection->all();

// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]

Cette méthode peut être utile en combinaison avec des usines pour créer des modèles Eloquent :

$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'], ] */

toArray() La toArray méthode convertit la collection en un PHP simple array . Si les valeurs de la collection sont des modèles Eloquent , les modèles seront également convertis en tableaux:

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

$collection->toArray();

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

toArray convertit également tous les objets imbriqués de la collection qui sont une instance

de Arrayable dans un tableau. Si vous souhaitez obtenir le tableau sous-jacent brut, utilisez all plutôt la méthode.

toJson() La toJson méthode convertit la collection en une chaîne sérialisée JSON:

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

$collection->toJson();

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

transform() La transform méthode parcourt la collection et appelle le rappel donné avec chaque élément de la collection. Les éléments de la collection seront remplacés par les valeurs renvoyées par le rappel:

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

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

$collection->all();

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

Contrairement à la plupart des autres méthodes de collecte, transform modifie la collection elle-même. Si vous souhaitez plutôt créer une nouvelle collection, utilisez la map méthode.

union() La union méthode ajoute le tableau donné à la collection. Si le tableau donné contient des clés déjà présentes dans la collection d'origine, les valeurs de la collection d'origine seront préférées:

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

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

$union->all();

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

unique()

La unique méthode renvoie tous les éléments uniques de la collection. La collection renvoyée conserve les clés de tableau d'origine. Dans cet exemple, nous allons utiliser la values méthode pour réinitialiser les clés sur des index numérotés consécutivement:

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

$unique = $collection->unique();

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

// [1, 2, 3, 4]

Lorsque vous traitez avec des tableaux ou des objets imbriqués, vous pouvez spécifier la clé utilisée pour déterminer l'unicité:

$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'], ] */

Vous pouvez également transmettre votre propre rappel pour déterminer l'unicité de l'article:

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

$

i

>

l

() > ll()

$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'], ] */

La unique méthode utilise des comparaisons "lâches" lors de la vérification des valeurs d'élément, ce qui signifie qu'une chaîne avec une valeur entière sera considérée comme égale à un entier de même valeur. Utilisez la uniqueStrict méthode pour filtrer en utilisant des comparaisons "strictes".

uniqueStrict() Cette méthode a la même signature que la unique méthode; Cependant, toutes les valeurs sont comparées à l'aide de comparaisons "strictes".

unless() La unless méthode exécutera le rappel donné à moins que le premier argument donné à la méthode ait pour résultat true :

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

Pour l'inverse de unless , voir la when méthode.

unlessEmpty() Alias pour la whenNotEmpty méthode.

unlessNotEmpty() Alias pour la whenEmpty méthode.

unwrap() La unwrap méthode statique renvoie les éléments sous-jacents de la collection à partir de la valeur donnée, le cas échéant:

Collection::unwrap(collect('John Doe'));

// ['John Doe']

Collection::unwrap(['John Doe']);

// ['John Doe']

Collection::unwrap('John Doe');

// 'John Doe'

values() La values méthode retourne une nouvelle collection avec les clés réinitialisées sur des entiers consécutifs:

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

$values = $collection->values();

$values->all();

/*

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

when() La when méthode exécutera le rappel donné lorsque le premier argument donné à la méthode sera évalué à true :

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

Pour l'inverse de when , voir la unless méthode.

whenEmpty() La whenEmpty méthode exécutera le rappel donné lorsque la collection est vide:

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

Pour l'inverse de whenEmpty , voir la whenNotEmpty méthode.

whenNotEmpty() La whenNotEmpty méthode exécutera le rappel donné lorsque la collection n'est pas vide:

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

Pour l'inverse de whenNotEmpty , voir la whenEmpty méthode.

where() La where méthode filtre la collection en fonction d'une paire clé / valeur donnée:

$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], ] */

La where méthode utilise des comparaisons "lâches" lors de la vérification des valeurs d'élément, ce qui signifie qu'une chaîne avec une valeur entière sera considérée comme égale à un entier de même valeur. Utilisez la whereStrict méthode pour filtrer en utilisant des comparaisons "strictes".

whereStrict() Cette méthode a la même signature que la where méthode; Cependant, toutes les valeurs sont comparées à l'aide de comparaisons "strictes".

whereBetween() La whereBetween méthode filtre la collection dans une plage donnée:

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

$filtered = $collection->whereBetween('price', [100, 200]);

$filtered->all();

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

whereIn() La whereIn méthode filtre la collection par une clé / valeur donnée contenue dans le tableau donné:

$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], ] */

La whereIn méthode utilise des comparaisons "lâches" lors de la vérification des valeurs d'élément, ce qui signifie qu'une chaîne avec une valeur entière sera considérée comme égale à un entier de même valeur. Utilisez la whereInStrict méthode pour filtrer en utilisant des comparaisons "strictes".

whereInStrict() Cette méthode a la même signature que la whereIn méthode; Cependant, toutes les valeurs sont comparées à l'aide de comparaisons "strictes".

whereInstanceOf() La whereInstanceOf méthode filtre la collection selon un type de classe donné:

$collection = collect([ new User, new User, new Post, ]);

return $collection->whereInstanceOf(User::class);

whereNotBetween() La whereNotBetween méthode filtre la collection dans une plage donnée:

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

$filtered = $collection->whereNotBetween('price', [100, 200]);

$filtered->all();

/* [ ['product' => 'Chair', 'price' => 80], ['product' => 'Pencil', 'price' => 30], ] */

whereNotIn() La whereNotIn méthode filtre la collection par une clé / valeur donnée non contenue dans le tableau donné:

$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], ] */

La whereNotIn méthode utilise des comparaisons "lâches" lors de la vérification des valeurs d'élément, ce qui signifie qu'une chaîne avec une valeur entière sera considérée comme égale à un entier de même valeur. Utilisez la whereNotInStrict méthode pour filtrer en utilisant des comparaisons "strictes".

whereNotInStrict() Cette méthode a la même signature que la whereNotIn méthode; Cependant, toutes les valeurs sont comparées à l'aide de comparaisons "strictes".

wrap() The static wrap method wraps the given value in a collection when applicable:

$collection = Collection::wrap('John Doe');

$collection->all();

// ['John Doe']

$collection = Collection::wrap(['John Doe']);

$collection->all();

// ['John Doe']

$collection = Collection::wrap(collect('John Doe'));

$collection->all();

// ['John Doe']

zip() The zip method merges together the values of the given array with the values of the original collection at the corresponding index:

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

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

$zipped->all();

// [['Chair', 100], ['Desk', 200]]

# Higher Order Messages Collections also provide support for "higher order messages", which are short-cuts for performing common actions on collections. The collection methods that provide higher order messages are: average , avg , contains , each , every , filter , first , flatMap , groupBy , keyBy , map , max , min , partition , reject , some , sortBy , sortByDesc , sum , and unique .

Each higher order message can be accessed as a dynamic property on a collection instance. For instance, let's use the each higher order message to call a method on each object within a collection:

$users = User::where('votes', '>', 500)->get();

$users->each->markAsVip();

Likewise, we can use the sum higher order message to gather the total number of "votes" for a collection of users:

$users = User::where('group', 'Development')->get();

return $users->sum->votes;

L A R A V E L I S A T R A D E M A R K O F T AY L O R O T W E L L . C O P Y R I G H T © T AY L O R O T W E L L .

DESIGNED BY