Laravel
collezioni

Sintassi

• $ collection = collect (['Value1', 'Value2', 'Value3']); // Chiavi predefinite su 0, 1, 2, ...,

Osservazioni

Creazione di raccolte

Usando l'helper collect() , puoi creare facilmente nuove istanze di raccolta passando un array come:

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

Se non si desidera utilizzare le funzioni di supporto, è possibile creare una nuova raccolta utilizzando direttamente la classe:

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

Come menzionato nelle note, Modelli per impostazione predefinita restituiscono un'istanza Collection , tuttavia sei libero di creare le tue raccolte in base alle esigenze. Se non viene specificato alcun array durante la creazione, verrà creata una raccolta vuota.

dove()

È possibile selezionare determinati elementi da una raccolta utilizzando il metodo where() .

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

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

Questo bit di codice selezionerà tutti gli elementi della raccolta in cui il nome è "Matt". In questo caso, viene restituito solo il secondo elemento.

annidamento

Proprio come la maggior parte dei metodi di array in Laravel, where() supporta anche la ricerca di elementi nidificati. Estendiamo l'esempio precedente aggiungendo un secondo array:

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

Questo restituirà solo Taylor, mentre beve il caffè a casa. Come puoi vedere, il nesting è supportato usando la notazione a punti.

aggiunte

Quando si crea una raccolta di oggetti invece di matrici, queste possono essere filtrate usando where() . La Collezione proverà quindi a ricevere tutte le proprietà desiderate.

Usando Ottieni valore di ricerca o restituisci valori predefiniti

Ti trovi spesso in una situazione in cui devi trovare un valore corrispondente alle variabili e le raccolte ti hanno coperto.

Nell'esempio seguente abbiamo ottenuto tre diverse localizzazioni in una matrice con un corrispondente codice di chiamata assegnato. Vogliamo essere in grado di fornire un locale e in cambio ottenere il codice di chiamata associato. Il secondo parametro in get è un parametro predefinito se il primo parametro non viene trovato.

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

Nell'esempio sopra possiamo fare quanto segue

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

È anche possibile passare una richiamata come valore predefinito. Il risultato della richiamata verrà restituito se la chiave specificata non esiste:

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

Utilizzare Contiene per verificare se una raccolta soddisfa determinate condizioni

Un problema comune è avere una raccolta di elementi che devono soddisfare tutti determinati criteri. Nell'esempio seguente abbiamo raccolto due articoli per un programma di dieta e vogliamo verificare che la dieta non contenga cibi malsani.

// 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;
});

Nel caso precedente, la variabile $isUnhealthy verrà impostata su true poiché il cioccolato soddisfa la condizione e la dieta è quindi malsana.

Usando Pluck per estrarre determinati valori da una collezione

Ti troverai spesso con una raccolta di dati in cui sei interessato solo a parti dei dati.

Nell'esempio seguente abbiamo ottenuto un elenco di partecipanti a un evento e vogliamo fornire una guida turistica con un semplice elenco di nomi.

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

Puoi anche usare il pluck per raccolte di oggetti o array / oggetti nidificati con notazione a punti.

$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

Utilizzo di Map per manipolare ciascun elemento in una raccolta

Spesso è necessario cambiare il modo in cui una serie di dati è strutturata e manipolare determinati valori.

Nell'esempio seguente abbiamo ottenuto una raccolta di libri con un importo di sconto allegato. Ma preferiamo avere un elenco di libri con un prezzo già scontato.

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

Questo potrebbe anche essere usato per cambiare le chiavi, diciamo che volevamo cambiare il title della chiave per name questa sarebbe una soluzione adatta.

Usando sum, avg, min o max su una collezione per i calcoli statistici

Le raccolte forniscono anche un modo semplice per eseguire calcoli statistici semplici.

$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

Ordinamento di una collezione

Esistono diversi modi per ordinare una raccolta.

Ordinare()

Il sort metodo ordina la collezione:

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

$sorted = $collection->sort();

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

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

Il metodo di sort consente anche di passare un callback personalizzato con il proprio algoritmo. Sotto il cappuccio usa l' usort php.

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

Ordina per()

Il metodo sortBy ordina la collezione con la chiave data:

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

Il metodo sortBy consente di utilizzare il formato di notazione a punti per accedere a una chiave più profonda al fine di ordinare una matrice multidimensionale.

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

Questo metodo ha la stessa firma del metodo sortBy , ma sortBy la raccolta nell'ordine opposto.

Utilizzo di reduce ()

Il reduce metodo riduce la raccolta di un singolo valore, passando il risultato di ogni iterazione nella successiva iterazione. Si prega di vedere ridurre il metodo .

Il metodo di reduce esegue il loop di ogni elemento con una raccolta e produce un nuovo risultato alla successiva iterazione. Ogni risultato dell'ultima iterazione viene passato attraverso il primo parametro (negli esempi seguenti, come $carry ).

Questo metodo può eseguire molta elaborazione su set di dati di grandi dimensioni. Ad esempio i seguenti esempi, utilizzeremo il seguente esempio di dati dello studente:

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

Somma il punteggio totale dello studente

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

Risultato: 220

Spiegazione:

• $carry è il risultato dell'ultima iterazione.
• Il secondo parametro è il valore predefinito per $ carry nel primo round di iterazione. In questo caso, il valore predefinito è 0

Passa uno studente se tutti i loro punteggi sono> = 50

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

Risultato: false

Spiegazione:

• Il valore predefinito di $ carry è true
• Se tutto il punteggio è superiore a 50, il risultato restituirà true; se inferiore a 50, restituisce falso.

Fallisci uno studente se il punteggio è <50

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

Risultato: true

Spiegare:

• il valore predefinito di $ carry è falso
• se un punteggio è inferiore a 50, restituisce true; se tutti i punteggi sono maggiori di 50, restituire false.

Restituire l'oggetto con il punteggio più alto

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

risultato: [ "subject" => "English", "score" => 61 ]

Spiegare:

• Il secondo parametro non è fornito in questo caso.

• Il valore predefinito di $ carry è nullo, quindi verifichiamo che ciò sia nel nostro condizionale.

Uso di macro () per estendere le raccolte

La funzione macro() consente di aggiungere nuove funzionalità agli oggetti Illuminate\Support\Collection

Uso:

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

Per esempio:

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

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

Risultato: ["HELLO", "WORLD"]

Utilizzando la sintassi di array

L'oggetto Collection implementa l'interfaccia ArrayAccess e IteratorAggregate , consentendone l'utilizzo come una matrice.

Accedi all'elemento di raccolta:

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

Risultato: 2

Assegna nuovo elemento:

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

Risultato: $collection è [1, 2, 3, 4]

Collezione Loop:

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

Risultato: $result è (a: one) (b: two)

Conversione da matrice a raccolta:

Per convertire una raccolta in un array PHP nativo, utilizzare:

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

Per convertire una matrice in una raccolta, utilizzare:

$collection = collect($array);

Utilizzo di collezioni con funzioni di array

Si prega di essere consapevoli del fatto che le collezioni sono oggetti normali che non verranno convertiti correttamente se usati da funzioni che richiedono esplicitamente array, come array_map($callback) .

Assicurati di convertire prima la raccolta, oppure, se disponibile, usa il metodo fornito dalla classe Collection : $collection->map($callback)