Laravel
samlingar

Syntax

• $ collection = collect (['Value1', 'Value2', 'Value3']); // Tangenter som standard är 0, 1, 2, ...,

Anmärkningar

Skapa samlingar

Med hjälp av collect() kan du enkelt skapa nya samlingsinstanser genom att mata in en matris som:

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

Om du inte vill använda hjälpfunktioner kan du skapa en ny samling med klassen direkt:

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

Som nämnts i anmärkningarna returnerar modeller som standard en Collection instans, men du kan fritt skapa dina egna samlingar efter behov. Om ingen matris anges vid skapandet skapas en tom samling.

var()

Du kan välja vissa objekt ur en samling genom att använda metoden where() .

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

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

Denna kodkod kommer att välja alla objekt i samlingen där namnet är 'Matt'. I detta fall returneras bara den andra artikeln.

Nesting

Precis som de flesta matrismetoder i Laravel, where() stödjer också att söka efter kapslade element. Låt oss utöka exemplet ovan genom att lägga till en andra grupp:

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

Detta kommer bara att återvända Taylor, när han dricker kaffe hemma. Som du ser stöds häckning med dot-notation.

tillägg

När du skapar en samling av objekt i stället för matriser kan de filtreras med where() också. Samlingen försöker sedan ta emot alla önskade egenskaper.

Med hjälp av Get to lookup-värde eller returnera standard

Du befinner dig ofta i en situation där du behöver hitta en variabel motsvarande värde, och samlingarna fick dig täckt.

I exemplet nedan fick vi tre olika platser i en matris med en motsvarande samtalskod tilldelad. Vi vill kunna tillhandahålla ett språk och i gengäld få den tillhörande samtalskoden. Den andra parametern i get är en standardparameter om den första parametern inte hittas.

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

I exemplet ovan kan vi göra följande

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

Du kan till och med skicka ett återuppringning som standardvärde. Resultatet av återuppringningen returneras om den angivna tangenten inte finns:

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

Användning Innehåller för att kontrollera om en samling uppfyller vissa villkor

Ett vanligt problem är att ha en samling artiklar som alla behöver uppfylla vissa kriterier. I exemplet nedan har vi samlat två artiklar för en dietplan och vi vill kontrollera att kosten inte innehåller någon ohälsosam mat.

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

I ovanstående fall $isUnhealthy variabeln $isUnhealthy att ställas in som true eftersom choklad uppfyller villkoret och dieten är därmed ohälsosam.

Använd Pluck för att extrahera vissa värden från en samling

Du hittar ofta dig själv med en insamling av data där du bara är intresserad av delar av uppgifterna.

I exemplet nedan fick vi en lista över deltagare vid ett evenemang och vi vill ge en guide med en enkel lista med namn.

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

Du kan också använda pluck för samlingar av objekt eller kapslade matriser / objekt med pricknotation.

$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

Använda Map för att manipulera varje element i en samling

Ofta måste du ändra hur en uppsättning data är strukturerad och manipulera vissa värden.

I exemplet nedan fick vi en samling böcker med ett bifogat rabattbelopp. Men vi har snarare en lista över böcker med ett pris som redan är rabatterat.

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

Detta kan också användas för att ändra nycklarna, låt oss säga att vi ville ändra nyckeln title för att name detta skulle vara en lämplig lösning.

Använd summa, avg, min eller max på en samling för statistiska beräkningar

Samlingar ger dig också ett enkelt sätt att göra enkla statistiska beräkningar.

$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

Sortera en samling

Det finns flera olika sätt att sortera en samling.

Sortera()

sort sorterar samlingen:

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

$sorted = $collection->sort();

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

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

sort också möjligt att skicka in en anpassad återuppringning med din egen algoritm. Under huven använder sorts php's usort .

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

Sortera efter()

Metoden sortBy sorterar samlingen med den angivna nyckeln:

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

Metoden sortBy tillåter användning av punktnotationsformat för att komma åt djupare nyckel för att sortera en multidimensionell matris.

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

Den här metoden har samma signatur som sortBy metoden, men sorterar samlingen i motsatt ordning.

Använd reducera ()

reduce reducerar samlingen till ett enda värde, vilket överför resultatet av varje iteration till den efterföljande iterationen. Se reducera metoden .

reduce slingrar genom varje objekt med en samling och ger nytt resultat till nästa iteration. Varje resultat från den sista iterationen passeras genom den första parametern (i följande exempel, som $carry ).

Den här metoden kan göra mycket behandling på stora datamängder. Till exempel följande exempel kommer vi att använda följande exempelstudentdata:

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

Summa studentens totala poäng

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

Resultat: 220

Förklaring:

• $carry är resultatet från den senaste iterationen.
• Den andra parametern är standardvärdet för $ carry i den första iterationsrundan. I det här fallet är standardvärdet 0

Ge en student om alla deras poäng är> = 50

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

Resultat: false

Förklaring:

• Standardvärdet för $ carry är sant
• Om alla poäng är högre än 50 kommer resultatet att bli sant; om det är mindre än 50, returnera falskt.

Missa en student om någon poäng är <50

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

Resultat: true

Förklara:

• standardvärdet för $ carry är falskt
• om någon poäng är mindre än 50, returnera true; om alla poäng är större än 50, returnera falskt.

Returnera ämnet med högsta poäng

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

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

Förklara:

• Den andra parametern tillhandahålls inte i detta fall.

• Standardvärdet för $ transporter är noll, och därför kontrollerar vi det i våra villkorade.

Använda makro () för att utöka samlingar

Funktionen macro() låter dig lägga till ny funktionalitet till Illuminate\Support\Collection objekt

Användande:

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

Till exempel:

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

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

Resultat: ["HELLO", "WORLD"]

Använda Array Syntax

Collection implementerar ArrayAccess och IteratorAggregate , så att det kan användas som en matris.

Access-samlingselement:

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

Resultat: 2

Tilldela nytt element:

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

Resultat: $collection är [1, 2, 3, 4]

Loop collection:

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

Resultat: $result är (a: one) (b: two)

Array to Collection-konvertering:

För att konvertera en samling till en infödd PHP-array använder du:

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

För att konvertera en matris till en samling använder du:

$collection = collect($array);

Använda samlingar med arrayfunktioner

Observera att samlingar är normala objekt som inte kommer att konverteras ordentligt när de används av funktioner som uttryckligen kräver matriser, som array_map($callback) .

Se till att konvertera samlingen först, eller använd den metod som tillhandahålls av Collection istället: $collection->map($callback)