groupBy()

groupBy-Methode gruppiert Sammlungselemente basierend auf einem angegebenen Schlüssel:

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

Sie können eine Rückruffunktion anstelle einer Zeichenfolge übergeben 键. Diese Rückruffunktion sollte den Wert des Schlüssels zurückgeben, nach dem Sie gruppieren möchten:

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

Ein Array kann für mehrere Gruppierungskriterien übergeben werden. Jedes Array-Element entspricht der entsprechenden Ebene innerhalb des mehrdimensionalen Arrays:

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

has()

has Die Methode ermittelt, ob der angegebene Schlüssel in der Sammlung vorhanden ist:

$collection = collect(['account_id' => 1, 'product' => 'Desk', 'amount' => 5]);
$collection->has('product');
// true
$collection->has(['product', 'amount']);
// true
$collection->has(['amount', 'price']);
// false

implode()

implode Methode wird zum Zusammenführen von Sammlungselementen verwendet. Seine Parameter hängen von der Art der Sammlungsgegenstände ab. Wenn die Sammlung Arrays oder Objekte enthält, sollten Sie die Schlüssel der Eigenschaften, die Sie kombinieren möchten, und die Zeichenfolge, die Sie zwischen den Werten einfügen möchten, an „splice“ übergeben:

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

Wenn die Sammlung einfache enthält Charaktere Zeichenfolge oder numerischer Wert, Sie müssen nur die zum „Spleißen“ verwendete Zeichenfolge als einzigen Parameter dieser Methode übergeben:

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

intersect()

intersect Die Methode entfernt aus der ursprünglichen Sammlung alle Werte, die in der angegebenen 数组 oder Sammlung nicht vorhanden sind. Die generierte Sammlung behält die Schlüssel der ursprünglichen Sammlung bei:

$collection = collect(['Desk', 'Sofa', 'Chair']);
$intersect = $collection->intersect(['Desk', 'Chair', 'Bookcase']);
$intersect->all();
// [0 => 'Desk', 2 => 'Chair']

intersectByKeys()

intersectByKeys Methode from Entfernt das angegebene 数组 aus der ursprünglichen Sammlung oder ein beliebiger Schlüssel, der nicht in der Sammlung vorhanden ist:

$collection = collect([
    'serial' => 'UX301', 
    'type' => 'screen', 
    'year' => 2009
  ]);
$intersect = $collection->intersectByKeys([ 
   'reference' => 'UX404', 
   'type' => 'tab', 
   'year' => 2011
 ]);
$intersect->all();
// ['type' => 'screen', 'year' => 2009]

isEmpty()

Wenn die Sammlung leer ist , isEmpty Die Methode gibt true zurück, andernfalls wird zurückgegeben false:

collect([])->isEmpty();
// true

isNotEmpty()

Wenn die Sammlung nicht leer ist, wird die isNotEmpty-Methode verwendet kehrt zurücktrue, andernfalls zurück false:

collect([])->isNotEmpty();
// false

keyBy()

keyBy Methode verwendet den angegebenen Schlüssel als Schlüssel von die Sammlung. Wenn mehrere Sammlungselemente denselben Schlüssel haben, wird in der neuen Sammlung nur das letzte Sammlungselement angezeigt:

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

Sie können in dieser Methode auch eine Callback-Funktion übergeben. Der von dieser Rückruffunktion zurückgegebene Wert wird als Schlüssel der Sammlung verwendet:

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

keys Die Methode gibt alle Schlüssel in der Sammlung zurück:

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

last gibt das letzte Element in der Sammlung zurück, das den angegebenen Bedingungstest besteht:

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

Sie können die Methode last auch ohne Übergabe aufrufen Parameter zum Abrufen des letzten Elements in . Gibt null zurück, wenn die Sammlung leer ist:

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

macro()

statischemacro Methode Ermöglicht Sie können der Klasse Collection zur Laufzeit Methoden hinzufügen. Weitere Informationen finden Sie in der Dokumentation zu Erweiterte Sammlungen.

make()

statische make-Methode erstellt eine neue Sammlungsinstanz. Weitere Informationen finden Sie im Abschnitt Sammlungen erstellen. Die Methode

map()

map durchläuft die Sammlung und übergibt jeden Wert an die angegebene Rückruffunktion . Diese Rückruffunktion kann die Sammlungselemente beliebig ändern und zurückgeben und dadurch eine neue Sammlung geänderter Sammlungselemente generieren:

$collection = collect([1, 2, 3, 4, 5]);
$multiplied = $collection->map(function ($item, $key) {
    return $item * 2;
  });
$multiplied->all();
// [2, 4, 6, 8, 10]

{note} Wie die meisten anderen Sammlungsmethoden gibt map eine neue Sammlungssammlung zurück Instanz; die ursprüngliche Sammlung wird dadurch nicht verändert. Wenn Sie die ursprüngliche Sammlung ändern möchten, verwenden Sie bitte die Methode transform.

mapInto()

mapInto() Methoden können eine Sammlung durchlaufen und neue Instanzen einer bestimmten Klasse erstellen, indem sie Werte an den Konstruktor übergeben:

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

mapSpread()< Die Methode 🎜>

kann die Sammlungselemente durchlaufen und den Wert jedes verschachtelten Elements der angegebenen Rückruffunktion zuweisen. Die Rückruffunktion kann das Sammlungselement frei ändern und zurückgeben, wodurch eine neue Sammlung geänderter Sammlungselemente generiert wird: mapSpread

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

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

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

$max = collect([['foo' => 10], ['foo' => 20]])->max('foo');
// 20
$max = collect([1, 2, 3, 4, 5])->max();
// 5

median()

median gibt den angegebenen Schlüssel zurück Median:

$median = collect([['foo' => 10], ['foo' => 10], ['foo' => 20], ['foo' => 40]])->median('foo');
// 15
$median = collect([1, 1, 2, 4])->median();
// 1.5

merge()

merge Die Methode führt die angegebenen Werte zusammen Array oder Sammlung zur ursprünglichen Sammlung hinzufügen. Wenn der Zeichenfolgenschlüssel des angegebenen Sammlungselements mit dem Zeichenfolgenschlüssel in der ursprünglichen Sammlung übereinstimmt, überschreibt der Wert des angegebenen Sammlungselements den Wert der ursprünglichen Sammlung:

$collection = collect(['product_id' => 1, 'price' => 100]);
$merged = $collection->merge(['price' => 200, 'discount' => false]);
$merged->all();
// ['product_id' => 1, 'price' => 200, 'discount' => false]

Wenn die angegebene Sammlung Die Schlüssel der Elemente sind Zahlen, und diese Werte werden am Ende der Sammlung angehängt:

$collection = collect(['Desk', 'Chair']);
$merged = $collection->merge(['Bookcase', 'Door']);
$merged->all();
// ['Desk', 'Chair', 'Bookcase', 'Door']

min()

min Die Methode gibt den Mindestwert des angegebenen Schlüssels zurück:

$min = collect([['foo' => 10], ['foo' => 20]])->min('foo');
// 10
$min = collect([1, 2, 3, 4, 5])->min();
// 1

mode()

mode Die Methode gibt den Mindestwert des angegebenen Schlüssels Mode zurück :

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

nth()

nthMethode erstellt von jedem n Eine neue Sammlung bestehend aus Elementen:

$collection = collect(['a', 'b', 'c', 'd', 'e', 'f']);
$collection->nth(4);
// ['a', 'e']

Sie können eine versetzte Position als zweiten Parameter übergeben:

$collection->nth(4, 1);
// ['b', 'f']

only()

only Die Methode gibt alle Sammlungselemente mit dem angegebenen Schlüssel in der Sammlung zurück:

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

und only entsprechen der Methode exclusive. Die Methode

pad()

pad füllt das Array mit den angegebenen Werten, bis das Array vollständig ist die angegebene Größe erreicht. Diese Methode verhält sich ähnlich wie die PHP-Funktion array_pad.

Um nach links zu füllen, sollten Sie negative Werte verwenden. Wenn der absolute Wert der angegebenen Größe kleiner oder gleich der Länge des Arrays ist, erfolgt keine Auffüllung:

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

Die partition()

partition-Methode kann mit list in der PHP-Funktion kombiniert werden Wird in Kombination verwendet, um Elemente, die die angegebene Bedingung erfüllen, von solchen zu trennen, die dies nicht tun:

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

pipe Die Methode übergibt die Sammlung an die angegebene Rückruffunktion und gibt das Ergebnis zurück:

$collection = collect([1, 2, 3]);
$piped = $collection->pipe(function ($collection) {
    return $collection->sum();
 });
 // 6

pluck()

pluck Die Methode kann alle Werte abrufen, die dem angegebenen Schlüssel in der Sammlung entsprechen:

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

Sie können auch den Schlüssel zum Generieren der Sammlung angeben, indem Sie den zweiten Parameter übergeben:

$plucked = $collection->pluck('name', 'product_id');
$plucked->all();
// ['prod-100' => 'Desk', 'prod-200' => 'Chair']

Wenn doppelte Schlüssel vorhanden sind, wird das letzte passende Element in den Popup-Satz eingefügt:

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

pop Die Methode entfernt das letzte Sammlungselement aus der Sammlung und gibt es zurück:

$collection = collect([1, 2, 3, 4, 5]);
$collection->pop();
// 5
$collection->all();
// [1, 2, 3, 4]

prepend()

prepend Die Methode fügt den angegebenen Wert am Anfang der Sammlung hinzu:

$collection = collect([1, 2, 3, 4, 5]);
$collection->prepend(0);
$collection->all();
// [0, 1, 2, 3, 4, 5]

Sie können auch einen zweiten Parameter übergeben, um den Schlüssel des neu hinzugefügten Sammlungselements festzulegen:

$collection = collect(['one' => 1, 'two' => 2]);
$collection->prepend(0, 'zero');
$collection->all();
// ['zero' => 0, 'one' => 1, 'two' => 2]

pull()

pull Die Methode entfernt den Wert, der dem angegebenen Schlüssel entspricht, aus der Sammlung und gibt Folgendes zurück:

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

push()

push Die Methode hängt den angegebenen Wert an das Ende des Sammlungselements an:

$collection = collect([1, 2, 3, 4]);
$collection->push(5);
$collection->all();
// [1, 2, 3, 4, 5]

put()

put Die Methode legt das angegebene Schlüssel-Wert-Paar innerhalb der Sammlung fest:

$collection = collect(['product_id' => 1, 'name' => 'Desk']);
$collection->put('price', 100);
$collection->all();
// ['product_id' => 1, 'name' => 'Desk', 'price' => 100]

random()

random Die Methode gibt ein zufälliges Element aus der Sammlung zurück:

$collection = collect([1, 2, 3, 4, 5]);
$collection->random();
// 4 - (retrieved randomly)

Sie können optional eine Ganzzahl an random übergeben, um die Anzahl der abzurufenden Zufallselemente anzugeben. Solange Sie die Menge, die Sie erhalten möchten, explizit übergeben, wird eine Sammlung von Elementen zurückgegeben:

$random = $collection->random(3);
$random->all();
// [2, 4, 5] - (retrieved randomly)

Wenn die Sammlung weniger als die angegebene Anzahl von Elementen enthält, löst die Methode InvalidArgumentException aus.

reduce()

reduce Methode übergibt das Ergebnis jeder Iteration an die nächste Iteration bis zur Sammlung Auf einen einzigen Wert reduzieren:

$collection = collect([1, 2, 3]);
$total = $collection->reduce(function ($carry, $item) {
    return $carry + $item;
 });
 // 6

bei der ersten Iteration $carry Der numerische Wert ist null; Sie können jedoch auch seinen Anfangswert angeben, indem Sie den zweiten Parameter an reduce übergeben:

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

reject()

reject Die Methode filtert die Sammlung mithilfe der angegebenen Rückruffunktion. Wenn die Callback-Funktion true zurückgibt, wird das entsprechende Sammlungselement aus der Sammlung entfernt: Die Methoden

$collection = collect([1, 2, 3, 4]);
$filtered = $collection->reject(function ($value, $key) {
    return $value > 2;
  });
$filtered->all();
// [1, 2]

und reject entsprechen der Methode filter.

reverse()

reverse Methode zum Umkehren der Reihenfolge der Sammlungselemente und Beibehaltung der Originalschlüssel:

$collection = collect(['a', 'b', 'c', 'd', 'e']);
$reversed = $collection->reverse();
$reversed->all();
/*
    [
        4 => 'e',
        3 => 'd',
        2 => 'c',
        1 => 'b',
        0 => 'a',
    ]
*/

search()

search durchsucht die Sammlung nach einem bestimmten Wert und gibt ihren Schlüssel zurück. Wenn nicht gefunden, wird false zurückgegeben.

$collection = collect([2, 4, 6, 8]);
$collection->search(4);
// 1

sucht auf „entspannte“ Weise, was bedeutet, dass Zeichenfolgen mit ganzzahligen Werten als gleichwertig mit ganzen Zahlen desselben Werts betrachtet werden. Verwenden Sie zum Suchen die „strenge“ Methode, übergeben Sie einfach true Als zweites Argument der Methode:

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

Alternativ können Sie nach dem ersten Sammlungselement suchen, das den Bedingungstest besteht, indem Sie eine Rückruffunktion übergeben:

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

shift()

shift Die Methode entfernt das erste Sammlungselement der Sammlung und gibt es zurück:

$collection = collect([1, 2, 3, 4, 5]);
$collection->shift();
// 1
$collection->all();
// [2, 3, 4, 5]

shuffle()

shuffle Methode mischt Sammlungselemente nach dem Zufallsprinzip:

$collection = collect([1, 2, 3, 4, 5]);
$shuffled = $collection->shuffle();
$shuffled->all();
// [3, 2, 5, 1, 4] - (generated randomly)

slice()

slice Die Methode gibt den Teil der Sammlung zurück, der am angegebenen Index beginnt:

$collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
$slice = $collection->slice(4);
$slice->all();
// [5, 6, 7, 8, 9, 10]

Wenn Sie die Größe des zurückgegebenen Inhalts begrenzen möchten, können Sie Ihre gewünschte Größe als zweites Argument an die Methode übergeben:

$slice = $collection->slice(4, 2);
$slice->all();
// [5, 6]

Standardmäßig behält der zurückgegebene Inhalt die Originalschlüssel bei. Wenn Sie die Originalschlüssel nicht behalten möchten, können Sie zur Neuindizierung die Methode values verwenden.

some()

contains Alias ​​​​für die Methode. Die Methode

sort()

sort sortiert die Sammlung. Die sortierte Sammlung behält die Schlüssel des ursprünglichen Arrays bei, daher verwenden wir in diesem Beispiel die Methode values, um die Schlüssel auf fortlaufend nummerierte Indizes zurückzusetzen:

$collection = collect([5, 3, 1, 2, 4]);
$sorted = $collection->sort();
$sorted->values()->all();
// [1, 2, 3, 4, 5]

Wenn Sie mehr haben Für erweiterte Sortieranforderungen können Sie die Rückruffunktion über Ihren eigenen Algorithmus an sort übergeben. Sehen Sie sich die PHP-Dokumentation für uasort an, das ist, was die sort-Methode der Sammlung unter der Haube aufruft.

{tip} Wenn Sie verschachtelte Arrays oder Objekte sortieren müssen, lesen Sie bitte die Methoden sortBy und sortByDesc.

sortBy()

sortBy sortiert die Sammlung basierend auf dem angegebenen Schlüssel. Die sortierte Sammlung behält die Schlüssel des ursprünglichen Arrays bei, daher verwenden wir in diesem Beispiel values Die Methode setzt den Schlüssel auf einen fortlaufend nummerierten Index zurück:

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

Sie können auch Ihre eigene Rückruffunktion übergeben, die bestimmt, wie die Werte der Sammlung sortiert werden sollen:

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

Diese Methode ist die gleiche wie sortBy Dieselbe Methode, aber sortiert die Sammlung in umgekehrter Reihenfolge.

sortKeys()

sortKeys Die Methode sortiert die Sammlung nach dem Schlüssel des zugrunde liegenden assoziativen Arrays:

$collection = collect([ 
   'id' => 22345,    
   'first' => 'John',    
   'last' => 'Doe',
  ]);
$sorted = $collection->sortKeys();$sorted->all();
/*
    [
        'first' => 'John',
        'id' => 22345,
        'last' => 'Doe',
    ]
*/

sortKeysDesc()

Diese Methode ist das Gleiche wie sortKeys Die Methode ist dieselbe, die Sammlung wird jedoch in umgekehrter Reihenfolge sortiert.

splice()

splice Die Methode entfernt das Sammlungselementfragment und gibt es zurück, beginnend am angegebenen Index:

$collection = collect([1, 2, 3, 4, 5]);
$chunk = $collection->splice(2);
$chunk->all();
// [3, 4, 5]
$collection->all();
// [1, 2]

Sie können einen zweiten Parameter übergeben, um die Größe des gelöschten Inhalts zu begrenzen:

$collection = collect([1, 2, 3, 4, 5]);
$chunk = $collection->splice(2, 1);
$chunk->all();
// [3]
$collection->all();
// [1, 2, 4, 5]

Darüber hinaus können Sie Sie können einen dritten Parameter übergeben, der ein neues Parameterelement enthält, um das gelöschte Sammlungselement in der Sammlung zu ersetzen:

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

split Die Methode teilt die Sammlung entsprechend dem angegebenen Wert auf:

$collection = collect([1, 2, 3, 4, 5]);
$groups = $collection->split(3);
$groups->toArray();
// [[1, 2], [3, 4], [5]]

sum()

sum Die Methode gibt die Summe aller Elemente in der Sammlung zurück:

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

Wenn die Sammlung verschachtelte Arrays oder Objekte enthält, sollten Sie einen Schlüssel übergeben, der den zu summierenden Wert angibt:

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

Zusätzlich , können Sie Ihre eigene Rückruffunktion übergeben, um zu entscheiden, welche Werte in der Sammlung zum Summieren verwendet werden sollen:

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

take Die Methode gibt eine neue Sammlung mit der angegebenen Anzahl von Elementen zurück:

$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(3);
$chunk->all();
// [0, 1, 2]

Sie können auch eine negative Ganzzahl übergeben, um die angegebene Anzahl von Elementen vom Ende der Sammlung abzurufen:

$collection = collect([0, 1, 2, 3, 4, 5]);
$chunk = $collection->take(-2);
$chunk->all();
// [4, 5]

tap()

tap Die Methode übergibt die angegebene Rückruffunktion an die Sammlung, sodass Sie an einem bestimmten Punkt auf die Sammlung „tippen“ und bestimmte Vorgänge an den Sammlungselementen ausführen können, ohne die Sammlung selbst zu beeinflussen:

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

times()

statische times-Methode erstellt eine neue Sammlung, indem sie eine Rückruffunktion eine bestimmte Anzahl von Malen aufruft:

$collection = Collection::times(10, function ($number) {
    return $number * 9;
 });
$collection->all();
// [9, 18, 27, 36, 45, 54, 63, 72, 81, 90]

Verwenden Sie diese Methode, um Eloquent in Verbindung mit einer Factory zu erstellen Modell:

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

toArray Methode wandelt die Sammlung in ein PHP 数组 um. Wenn der Wert der Sammlung ein Eloquent-Modell ist, wird dieses ebenfalls in ein Array konvertiert:

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

{note} toArray konvertiert außerdem alle verschachtelten Objekte der Sammlung in Arrays. Wenn Sie das ursprüngliche Array erhalten möchten, können Sie die Methode all verwenden.

toJson()

toJson-Methode konvertiert eine Sammlung in JSON Zeichenfolge: Die Methode

$collection = collect(['name' => 'Desk', 'price' => 200]);
$collection->toJson();
// '{"name":"Desk", "price":200}'

transform()

transform durchläuft die Sammlung und ruft sie für jede Sammlung auf item Die angegebene Rückruffunktion. Der Inhalt der Sammlung wird auch durch den Rückgabewert der Rückruffunktion ersetzt:

$collection = collect([1, 2, 3, 4, 5]);
$collection->transform(function ($item, $key) {
    return $item * 2;
  });
$collection->all();
// [2, 4, 6, 8, 10]

{note} Im Gegensatz zu den meisten Sammlungsmethoden ändert transform die Sammlung selbst. Wenn Sie eine neue Sammlung erstellen möchten, können Sie die Methode map verwenden. Die Methode fügt das angegebene Array zur Sammlung hinzu. Wenn das angegebene Array dieselben Schlüssel wie die ursprüngliche Sammlung enthält, werden die Werte der ursprünglichen Sammlung nicht geändert:

$collection = collect([1 => ['a'], 2 => ['b']]);
$union = $collection->union([3 => ['c'], 1 => ['b']]);
$union->all();
// [1 => ['a'], 2 => ['b'], 3 => ['c']]

union()

union

$collection = collect([1, 1, 2, 2, 3, 4, 2]);
$unique = $collection->unique();
$unique->values()->all();
// [1, 2, 3, 4]

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

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

Die Methode verwendet beim Überprüfen von Elementwerten einen Vergleich im „entspannten“ Modus, was bedeutet, dass Zeichenfolgen mit Ganzzahlwerten als gleich Ganzzahlen mit demselben Wert behandelt werden. Sie können die Methode unique()

verwenden, um einen „strengen“ Modusvergleich durchzuführen. uniquevalues

uniqueDiese Methode ist die gleiche wie die uniqueStrict-Methode Allerdings werden alle Werte im „strengen“ Modus verglichen.

unless()

unless-Methode führt die angegebene Rückruffunktion aus, wenn der erste übergebene Parameter nicht true ist:

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

und unless Entspricht dem when Methode.

unlessEmpty()

whenNotEmpty Alias ​​​​für die Methode.

unlessNotEmpty()

whenEmpty Alias ​​​​für die Methode.

unwrap()

statisch unwrap Die Methode gibt die verfügbaren Werte innerhalb der Sammlung zurück:

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

values()

values Die Return-Taste der Methode wird auf einen neuen Satz fortlaufender Zahlen zurückgesetzt:

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

when Methode, wenn der erste übergebene Parameter true ist , wird die angegebene Callback-Funktion ausgeführt:

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

und when entsprechen der Methode unless.

whenEmpty()

whenEmpty Methode Wenn die Sammlung leer ist, wird die angegebene Rückruffunktion ausgeführt :

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

entspricht whenEmpty whenNotEmpty Methode.

whenNotEmpty()

whenNotEmpty Methode Wenn die Sammlung nicht leer ist, wird der angegebene Rückruf ausgeführt Funktion:

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

und whenNotEmpty entsprechen whenEmpty Methode.

where()

where Methode filtert die Sammlung nach dem angegebenen Schlüssel/Wert-Paar:

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

where Die Methode verwendet beim Überprüfen der Sammlungselementwerte einen Vergleich im „entspannten“ Modus, was bedeutet, dass Zeichenfolgen mit ganzzahligen Werten als gleichwertig mit ganzen Zahlen desselben Werts betrachtet werden. Sie können die Methode whereStrict für den „strengen“ Modusvergleich verwenden.

whereStrict()

Diese Methode ähnelt der where-Methode; different Der Vergleichsmodus „streng“ wird verwendet.

whereBetween()

whereBetween Die Methode filtert die Sammlung anhand des angegebenen Bereichs:

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

whereIn wird Basierend auf dem Schlüssel /, der das angegebene Array enthält Filtern Sie die Sammlung nach Wertepaaren: Die Methode

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

whereIn verwendet einen „entspannten“ Vergleich, um den Wert eines Sammlungselements zu überprüfen, was bedeutet, dass Zeichenfolgen mit ganzzahligen Werten als ganze Zahlen gleich behandelt werden gleichen Wert. Sie können die Methode whereInStrict für den „strengen“ Modusvergleich verwenden.

whereInStrict()

Diese Methode ähnelt der whereIn-Methode; different Zum Vergleich wird der „strenge“ Modus verwendet.

whereInstanceOf()

whereInstanceOf Methode zum Filtern der Sammlung basierend auf der angegebenen Klasse:

$collection = collect([
    new User,    
    new User,    
    new Post,
 ]);
return $collection->whereInstanceOf(User::class);

whereNotBetween()

whereNotBetween Methode zum Filtern der Sammlung innerhalb des angegebenen Bereichs:

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

whereNotIn Diese Methode filtert die Sammlung basierend auf Werten, die den angegebenen Schlüssel übergeben und nicht das angegebene Array enthalten:

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

whereNotIn Die Methode verwendet einen Vergleich im „entspannten“ Modus, um den Wert des Sammlungselements zu überprüfen. Dies bedeutet, dass es sich um einen ganzzahligen Wert handelt. Zeichenfolgen werden als ganze Zahlen behandelt, die demselben Wert entsprechen. Sie können die Methode whereNotInStrict verwenden, um einen „strengen“ Modusvergleich durchzuführen.

whereNotInStrict()

Diese Methode ähnelt der whereNotIn-Methode; different Zum Vergleich wird der Modus „streng“ verwendet.

wrap()

statisch wrap Die Methode platziert den angegebenen Wert gegebenenfalls in der Sammlung:

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

zip Die Methode führt die Werte des angegebenen Arrays mit den Werten der ursprünglichen Sammlung am entsprechenden Index zusammen:

$collection = collect(['Chair', 'Desk']);
$zipped = $collection->zip([100, 200]);
$zipped->all();
// [['Chair', 100], ['Desk', 200]]

High-Level-Messaging

Sammlungen bieten auch Unterstützung für „High-Level-Messaging“, eine Sammlung von Verknüpfungen für allgemeine Vorgänge. Zu den Erfassungsmethoden, die Nachrichten höherer Ordnung unterstützen, gehören: average, avg, contains, each, every, filter, first, flatMap, groupBy, keyBy, map, max, min, partition, reject, some, sortBy, sortByDesc, sum und unique.

Auf jede Nachrichtenweitergabe höherer Ordnung kann als dynamische Eigenschaft der Sammlungsinstanz zugegriffen werden. Verwenden Sie beispielsweise each Nachrichten höherer Ordnung, um eine Methode für jedes Objekt in der Sammlung aufzurufen:

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

Ebenso können wir sum Nachrichten höherer Ordnung verwenden, um „Stimmen“ in der Benutzersammlung zu sammeln Gesamt:

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