Laravel
Collections

Syntaxe

• $ collection = collect (['Value1', 'Value2', 'Value3']); // Les clés sont par défaut à 0, 1, 2, ...,

Remarques

Créer des collections

A l'aide de l'assistant collect() , vous pouvez facilement créer de nouvelles instances de collection en transmettant un tableau tel que:

$fruits = collect(['oranges', 'peaches', 'pears']);

Si vous ne souhaitez pas utiliser de fonctions d'assistance, vous pouvez créer une nouvelle collection en utilisant directement la classe:

$fruits = new Illuminate\Support\Collection(['oranges', 'peaches', 'pears']);

Comme mentionné dans les remarques, les modèles retournent par défaut une instance Collection , mais vous êtes libre de créer vos propres collections en fonction des besoins. Si aucun tableau n'est spécifié lors de la création, une collection vide sera créée.

où()

Vous pouvez sélectionner certains éléments d'une collection en utilisant la méthode where() .

$data = [
    ['name' => 'Taylor',  'coffee_drinker' => true],
    ['name' => 'Matt', 'coffee_drinker' => true]
];

$matt = collect($data)->where('name', 'Matt');

Ce bit de code sélectionne tous les éléments de la collection dont le nom est «Matt». Dans ce cas, seul le deuxième élément est renvoyé.

Nidification

Tout comme la plupart des méthodes de tableau dans Laravel, where() prend également en charge la recherche d'éléments imbriqués. Prenons l'exemple ci-dessus en ajoutant un deuxième tableau:

$data = [
    ['name' => 'Taylor',  'coffee_drinker' => ['at_work' => true, 'at_home' => true]],
    ['name' => 'Matt', 'coffee_drinker' => ['at_work' => true, 'at_home' => false]]
];

$coffeeDrinkerAtHome = collect($data)->where('coffee_drinker.at_home', true);

Cela ne fera que rendre Taylor, car il boit du café à la maison. Comme vous pouvez le voir, l'imbrication est prise en charge à l'aide de la notation par points.

Ajouts

Lors de la création d'une collection d'objets à la place de tableaux, ceux-ci peuvent également être filtrés à l'aide de where() . La Collection essaiera alors de recevoir toutes les propriétés souhaitées.

Utiliser Get pour rechercher la valeur ou retourner la valeur par défaut

Vous vous trouvez souvent dans une situation où vous devez trouver une variable correspondant à la valeur, et les collections vous ont couvert.

Dans l'exemple ci-dessous, nous avons obtenu trois paramètres régionaux différents dans un tableau avec un code d'appel correspondant. Nous voulons être en mesure de fournir un paramètre régional et obtenir en retour le code d'appel associé. Le deuxième paramètre dans get est un paramètre par défaut si le premier paramètre est introuvable.

function lookupCallingCode($locale)
{
    return collect([
        'de_DE' => 49,
        'en_GB' => 44,
        'en_US' => 1,
    ])->get($locale, 44);
}

Dans l'exemple ci-dessus, nous pouvons faire ce qui suit

lookupCallingCode('de_DE'); // Will return 49
lookupCallingCode('sv_SE'); // Will return 44

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

    return collect([
        'de_DE' => 49,
        'en_GB' => 44,
        'en_US' => 1,
    ])->get($locale, function() {
        return 44;
    });

Utilisation de Contient pour vérifier si une collection satisfait à certaines conditions

Un problème commun est d'avoir une collection d'éléments qui doivent tous répondre à certains critères. Dans l'exemple ci-dessous, nous avons collecté deux éléments pour un régime alimentaire et nous voulons vérifier que le régime ne contient aucun aliment malsain.

// First we create a collection
$diet = collect([
    ['name' => 'Banana', 'calories' => '89'],
    ['name' => 'Chocolate', 'calories' => '546']
]);

// Then we check the collection for items with more than 100 calories
$isUnhealthy = $diet->contains(function ($i, $snack) {
    return $snack["calories"] >= 100;
});

Dans le cas ci-dessus, la variable $isUnhealthy sera définie sur true car le chocolat remplit la condition et le régime est donc malsain.

Utiliser Pluck pour extraire certaines valeurs d'une collection

Vous vous retrouverez souvent avec une collection de données où vous êtes uniquement intéressé par des parties des données.

Dans l'exemple ci-dessous, nous avons reçu une liste des participants à un événement et nous voulons fournir un guide avec une simple liste de noms.

// First we collect the participants
$participants = collect([
    ['name' => 'John', 'age' => 55],
    ['name' => 'Melissa', 'age' => 18],
    ['name' => 'Bob', 'age' => 43],
    ['name' => 'Sara', 'age' => 18],
]);

// Then we ask the collection to fetch all the names
$namesList = $partcipants->pluck('name')
// ['John', 'Melissa', 'Bob', 'Sara'];

Vous pouvez également utiliser le pluck pour des collections d'objets ou des tableaux / objets imbriqués avec une notation par points.

$users = User::all(); // Returns Eloquent Collection of all users
$usernames = $users->pluck('username'); // Collection contains only user names

$users->load('profile'); // Load a relationship for all models in collection

// Using dot notation, we can traverse nested properties
$names = $users->pluck('profile.first_name'); // Get all first names from all user profiles

Utiliser Map pour manipuler chaque élément d'une collection

Vous devez souvent modifier la structure d'un ensemble de données et manipuler certaines valeurs.

Dans l'exemple ci-dessous, nous avons une collection de livres avec un montant de remise attaché. Mais nous préférons plutôt une liste de livres avec un prix déjà réduit.

$books = [
    ['title' => 'The Pragmatic Programmer', 'price' => 20, 'discount' => 0.5],
    ['title' => 'Continuous Delivery', 'price' => 25, 'discount' => 0.1],
    ['title' => 'The Clean Coder', 'price' => 10, 'discount' => 0.75],
];

$discountedItems =  collect($books)->map(function ($book) {
   return ['title' => $book["title"], 'price' => $book["price"] * $book["discount"]];
});

//[
//    ['title' => 'The Pragmatic Programmer', 'price' => 10],
//    ['title' => 'Continuous Delivery', 'price' => 12.5],
//    ['title' => 'The Clean Coder', 'price' => 5],
//]

Cela pourrait également être utilisé pour changer les clés, disons que nous voulions changer le title clé pour name ceci serait une solution appropriée.

Utiliser sum, avg, min ou max sur une collection pour des calculs statistiques

Les collections vous offrent également un moyen simple d'effectuer des calculs statistiques simples.

$books = [
    ['title' => 'The Pragmatic Programmer', 'price' => 20],
    ['title' => 'Continuous Delivery', 'price' => 30],
    ['title' => 'The Clean Coder', 'price' => 10],
]

$min = collect($books)->min('price'); // 10
$max = collect($books)->max('price'); // 30
$avg = collect($books)->avg('price'); // 20
$sum = collect($books)->sum('price'); // 60

Trier une collection

Il existe plusieurs manières de trier une collection.

Trier()

La méthode de sort trie la collection:

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

$sorted = $collection->sort();

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

returns : [1, 2, 3, 4, 5]

La méthode de sort permet également de transmettre un rappel personnalisé avec votre propre algorithme. Sous le capot, le sort utilise l' usort de php.

$collection = $collection->sort(function ($a, $b) {
    if ($a == $b) {
        return 0;
    }
    return ($a < $b) ? -1 : 1;
});

Trier par()

La méthode sortBy trie la collection par la clé donnée:

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

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

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

returns:  [
        ['name' => 'Chair', 'price' => 100],
        ['name' => 'Bookcase', 'price' => 150],
        ['name' => 'Desk', 'price' => 200],
    ]

La méthode sortBy permet d'utiliser un format de notation par points pour accéder à une clé plus profonde afin de trier un tableau multidimensionnel.

$collection = collect([
    ["id"=>1,"product"=>['name' => 'Desk', 'price' => 200]],
    ["id"=>2, "product"=>['name' => 'Chair', 'price' => 100]],
    ["id"=>3, "product"=>['name' => 'Bookcase', 'price' => 150]],
    ]);

$sorted = $collection->sortBy("product.price")->toArray();

return: [
  ["id"=>2, "product"=>['name' => 'Chair', 'price' => 100]],
  ["id"=>3, "product"=>['name' => 'Bookcase', 'price' => 150]],
  ["id"=>1,"product"=>['name' => 'Desk', 'price' => 200]],
]

SortByDesc ()

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

En utilisant Reduce ()

La reduce procédé réduit la perception à une valeur unique, en passant le résultat de chaque itération dans l'itération suivante. S'il vous plaît voir la méthode de réduction .

La méthode de reduce parcourt chaque élément avec une collection et produit un nouveau résultat à la prochaine itération. Chaque résultat de la dernière itération est passé par le premier paramètre (dans les exemples suivants, en tant que $carry ).

Cette méthode peut faire beaucoup de traitement sur des ensembles de données volumineux. Par exemple, les exemples suivants, nous allons utiliser les exemples de données d'étudiant suivants:

 $student = [
    ['class' => 'Math', 'score' => 60],
    ['class' => 'English', 'score' => 61],
    ['class' => 'Chemistry', 'score' => 50],
    ['class' => 'Physics', 'score' => 49],
];

Somme du score total de l'étudiant

$sum = collect($student)
    ->reduce(function($carry, $item){
        return $carry + $item["score"];
    }, 0);

Résultat: 220

Explication:

• $carry est le résultat de la dernière itération.
• Le deuxième paramètre est la valeur par défaut pour le $ carry dans le premier tour d'itération. Ce cas, la valeur par défaut est 0

Passer un étudiant si toutes ses notes sont> = 50

$isPass = collect($student)
    ->reduce(function($carry, $item){
        return $carry && $item["score"] >= 50;
    }, true);

Résultat: false

Explication:

• La valeur par défaut de $ carry est true
• Si tous les scores sont supérieurs à 50, le résultat sera vrai. si moins de 50, retournez faux.

Échouer un élève si un score est <50

$isFail = collect($student)
    ->reduce(function($carry, $item){
        return $carry || $item["score"] < 50;
    }, false);

Résultat: true

Explique:

• la valeur par défaut de $ carry est fausse
• si un score est inférieur à 50, renvoyer true; si tous les scores sont supérieurs à 50, renvoyer false.

Renvoyer le sujet avec le score le plus élevé

$highestSubject = collect($student)
    ->reduce(function($carry, $item){
        return $carry === null || $item["score"] > $carry["score"] ? $item : $carry;
    });

résultat: [ "subject" => "English", "score" => 61 ]

Explique:

• Le second paramètre n'est pas fourni dans ce cas.

• La valeur par défaut de $ carry est null, donc nous vérifions cela dans notre conditionnel.

Utiliser macro () pour étendre les collections

La fonction macro() vous permet d'ajouter de nouvelles fonctionnalités aux objets Illuminate\Support\Collection

Usage:

Collection::macro("macro_name", function ($parameters) {
    // Your macro
});

Par exemple:

Collection::macro('uppercase', function () {
    return $this->map(function ($item) {
        return strtoupper($item);
    });
});

collect(["hello", "world"])->uppercase();

Résultat: ["HELLO", "WORLD"]

Utiliser la syntaxe de tableau

L'objet Collection implémente l'interface ArrayAccess et IteratorAggregate , ce qui lui permet d'être utilisé comme un tableau.

Élément de collection d'accès:

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

Résultat: 2

Attribuer un nouvel élément:

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

Résultat: $collection est [1, 2, 3, 4]

Collection de boucles:

$collection = collect(["a" => "one", "b" => "two"]);
$result = "";
foreach($collection as $key => $value){
    $result .= "(".$key.": ".$value.") ";        
}

Résultat: $result est (a: one) (b: two)

Conversion de tableau en collection:

Pour convertir une collection en un tableau PHP natif, utilisez:

$array = $collection->all();
//or
$array = $collection->toArray()

Pour convertir un tableau en collection, utilisez:

$collection = collect($array);

Utilisation de collections avec des fonctions de tableau

Sachez que les collections sont des objets normaux qui ne seront pas convertis correctement lorsqu'ils sont utilisés par des fonctions nécessitant explicitement des tableaux, comme array_map($callback) .

Assurez-vous de convertir d'abord la collection ou, si disponible, utilisez plutôt la méthode fournie par la classe Collection : $collection->map($callback)