laravel collection macros

Eine Reihe nützlicher Laravel-Sammlungsmakros

Dieses Repository enthält einige nützliche Sammlungsmakros.

Spatie ist eine Webdesign-Agentur mit Sitz in Antwerpen, Belgien. Eine Übersicht aller unserer Open-Source-Projekte finden Sie auf unserer Website.

Unterstützen Sie uns

Wir investieren viele Ressourcen in die Erstellung erstklassiger Open-Source-Pakete. Sie können uns unterstützen, indem Sie eines unserer kostenpflichtigen Produkte kaufen.

Wir freuen uns sehr, dass Sie uns eine Postkarte aus Ihrer Heimatstadt schicken und erwähnen, welches unserer Pakete Sie verwenden. Unsere Adresse finden Sie auf unserer Kontaktseite. Wir veröffentlichen alle erhaltenen Postkarten auf unserer virtuellen Postkartenwand.

Installation

Sie können das Paket über Composer abrufen:

composer require spatie/laravel-collection-macros

Das Paket registriert sich automatisch.

Makros

• after
• at
  • second
  • third
  • fourth
  • fifth
  • sixth
  • seventh
  • eighth
  • ninth
  • tenth
  • getNth
• before
• catch
• chunkBy
• collectBy
• containsAny
• containsAll
• eachCons
• extract
• filterMap
• firstOrFail
• firstOrPush
• fromPairs
• getCaseInsensitive
• glob
• groupByModel
• hasCaseInsensitive
• head
• if
• ifAny
• ifEmpty
• insertAfter
• insertAfterKey
• insertAt
• insertBefore
• insertBeforeKey
• none
• paginate
• path
• pluckMany
• pluckManyValues
• pluckToArray
• prioritize
• recursive
• rotate
• sectionBy
• simplePaginate
• sliceBefore
• tail
• try
• toPairs
• transpose
• validate
• weightedRandom
• withSize

after

Holen Sie sich das nächste Element aus der Sammlung.

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

$ currentItem = 2 ;

$ currentItem = $ collection -> after ( $ currentItem ); // return 3;
$ collection -> after ( $ currentItem ); // return null;

$ currentItem = $ collection -> after ( function ( $ item ) {
    return $ item > 1 ;
}); // return 3;

Sie können auch einen zweiten Parameter übergeben, der als Fallback verwendet wird.

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

$ currentItem = 3 ;

$ collection -> after ( $ currentItem , $ collection -> first ()); // return 1;

at

Rufen Sie ein Element an einem Index ab.

 $ data = new Collection ([ 1 , 2 , 3 ]);

$ data -> at ( 0 ); // 1
$ data -> at ( 1 ); // 2
$ data -> at (- 1 ); // 3

second

Element am zweiten Index abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> second (); // 2

third

Element am dritten Index abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> third (); // 3

fourth

Element am vierten Index abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> fourth (); // 4

fifth

Element am fünften Index abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> fifth (); // 5

sixth

Element am sechsten Index abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> sixth (); // 6

seventh

Element am siebten Index abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> seventh (); // 7

eighth

Element am achten Index abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> eighth (); // 8

ninth

Element am neunten Index abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> ninth (); // 9

tenth

Element am zehnten Index abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 ]);

$ data -> tenth (); // 10

getNth

Element beim n-ten Element abrufen.

 $ data = new Collection ([ 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11 ]);

$ data -> getNth ( 11 ); // 11

before

Holen Sie sich das vorherige Element aus der Sammlung.

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

$ currentItem = 2 ;

$ currentItem = $ collection -> before ( $ currentItem ); // return 1;
$ collection -> before ( $ currentItem ); // return null;

$ currentItem = $ collection -> before ( function ( $ item ) {
    return $ item > 2 ;
}); // return 2;

Sie können auch einen zweiten Parameter übergeben, der als Fallback verwendet wird.

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

$ currentItem = 1 ;

$ collection -> before ( $ currentItem , $ collection -> last ()); // return 3;

catch

Siehe Try

chunkBy

Unterteilt die Werte aus einer Sammlung in Gruppen, solange der angegebene Rückruf wahr ist. Wenn der optionale Parameter $preserveKeys als true übergeben wird, bleiben die ursprünglichen Schlüssel erhalten.

 collect ([ ' A ' , ' A ' , ' B ' , ' A ' ])-> chunkBy ( function ( $ item ) {
    return $ item == ' A ' ;
}); // return Collection([['A', 'A'],['B'], ['A']])

collectBy

Holen Sie sich einen Gegenstand mit einem bestimmten Schlüssel und sammeln Sie ihn ein.

 $ collection = collect ([
    ' foo ' => [ 1 , 2 , 3 ],
    ' bar ' => [ 4 , 5 , 6 ],
]);

$ collection -> collectBy ( ' foo ' ); // Collection([1, 2, 3])

Sie können auch einen zweiten Parameter übergeben, der als Fallback verwendet wird.

 $ collection = collect ([
    ' foo ' => [ 1 , 2 , 3 ],
    ' bar ' => [ 4 , 5 , 6 ],
]);

$ collection -> collectBy ( ' baz ' , [ ' Nope ' ]); // Collection(['Nope'])

containsAny

Gibt true zurück, wenn einer oder mehrere der angegebenen Werte in der Sammlung vorhanden sind.

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

$ collection -> containsAny ([ ' b ' , ' c ' , ' d ' ]); // returns true
$ collection -> containsAny ([ ' c ' , ' d ' , ' e ' ]); // returns true
$ collection -> containsAny ([ ' d ' , ' e ' , ' f ' ]); // returns false
$ collection -> containsAny ([]); // returns false

containsAll

Gibt true zurück, wenn alle angegebenen Werte in der Sammlung vorhanden sind.

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

$ collection -> containsAll ([ ' b ' , ' c ' ,]); // returns true
$ collection -> containsAll ([ ' c ' , ' d ' ]); // returns false
$ collection -> containsAll ([ ' d ' , ' e ' ]); // returns false
$ collection -> containsAll ([]); // returns true

eachCons

Rufen Sie die folgenden aufeinanderfolgenden Nachbarn in einer Sammlung aus einer bestimmten Blockgröße ab. Wenn der optionale Parameter $preserveKeys als true übergeben wird, bleiben die ursprünglichen Schlüssel erhalten.

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

extract

Extrahieren Sie Schlüssel aus einer Sammlung. Dies ist sehr ähnlich zu only , mit zwei wesentlichen Unterschieden:

• extract gibt ein Array von Werten zurück, kein assoziatives Array
• Wenn ein Wert nicht vorhanden ist, wird der Wert mit null aufgefüllt, anstatt ihn wegzulassen

extract ist nützlich, wenn list() -Syntax von PHP 7.1 verwendet wird.

[ $ name , $ role ] = collect ( $ user )-> extract ( ' name ' , ' role.name ' );

filterMap

Ordnen Sie eine Sammlung zu und entfernen Sie falsche Werte auf einmal.

 $ collection = collect ([ 1 , 2 , 3 , 4 , 5 , 6 ])-> filterMap ( function ( $ number ) {
    $ quotient = $ number / 3 ;

    return is_integer ( $ quotient ) ? $ quotient : null ;
});

$ collection -> toArray (); // returns [1, 2]

firstOrFail

Holen Sie sich den ersten Artikel. Löst SpatieCollectionMacrosExceptionsCollectionItemNotFound aus, wenn das Element nicht gefunden wurde.

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

$ collection -> toArray (); // returns [1]

collect ([])-> firstOrFail (); // throws SpatieCollectionMacrosExceptionsCollectionItemNotFound

firstOrPush

Rufen Sie das erste Element mit dem als ersten Parameter angegebenen Callable ab. Wenn kein Wert vorhanden ist, übertragen Sie den Wert des zweiten Parameters in die Sammlung. Als zweiten Parameter können Sie ein Callable übergeben.

Diese Methode ist sehr nützlich, wenn Sie mit zwischengespeicherten Klasseneigenschaften arbeiten, bei denen Sie einen von einer API oder einer rechenintensiven Funktion abgerufenen Wert in einer Sammlung speichern möchten, um ihn mehrmals zu verwenden.

 $ collection = collect ([ 1 , 2 , 3 ])-> firstOrPush ( fn ( $ item ) => $ item === 4 , 4 );

$ collection -> toArray (); // returns [1, 2, 3, 4]

Gelegentlich möchten Sie die Zielsammlung angeben, an die gepusht werden soll. Sie können dies als dritten Parameter übergeben.

 $ collection = collect ([ 1 , 2 , 3 ]);
$ collection -> filter ()-> firstOrPush ( fn ( $ item ) => $ item === 4 , 4 , $ collection );

$ collection -> toArray (); // returns [1, 2, 3, 4]

fromPairs

Wandelt eine Sammlung in ein assoziatives Array-Form-Sammlungselement um.

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

$ collection -> toArray (); // returns ['a' => 'b', 'c' => 'd', 'e' => 'f']

getCaseInsensitive

Ermitteln Sie den Wert eines bestimmten Schlüssels.

Wenn der Schlüssel eine Zeichenfolge ist, suchen wir mithilfe eines Vergleichs ohne Berücksichtigung der Groß- und Kleinschreibung nach dem Schlüssel.

 $ collection = collect ([
    ' foo ' => ' bar ' ,
]);

$ collection -> getCaseInsensitive ( ' Foo ' ); // returns 'bar';

glob

Gibt eine Sammlung eines glob() -Ergebnisses zurück.

Collection:: glob ( ' config/*.php ' );

groupByModel

Ähnlich wie groupBy , gruppiert die Sammlung jedoch nach einem Eloquent-Modell. Da der Schlüssel ein Objekt und keine Ganzzahl oder Zeichenfolge ist, werden die Ergebnisse in separate Arrays aufgeteilt.

 $ posts -> groupByModel ( ' category ' );

// [
//     [$categoryA, [/*...$posts*/]],
//     [$categoryB, [/*...$posts*/]],
// ];

Vollständige Signatur: groupByModel($callback, $preserveKeys, $modelKey, $itemsKey)

hasCaseInsensitive

Stellen Sie fest, ob die Sammlung einen Schlüssel mit einem bestimmten Namen enthält.

Wenn $key eine Zeichenfolge ist, suchen wir mithilfe eines Vergleichs ohne Berücksichtigung der Groß- und Kleinschreibung nach dem Schlüssel.

 $ collection = collect ([
    ' foo ' => ' bar ' ,
]);

$ collection -> hasCaseInsensitive ( ' Foo ' ); // returns true;

head

Ruft das erste Element aus der Sammlung ab.

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

$ collection -> head (); // return 1

$ collection = collect ([]);

$ collection -> head (); // return null

if

Das if Makro kann dabei helfen, Sammlungsketten zu verzweigen. Dies ist die Signatur dieses Makros:

 if (mixed $ if , mixed $ then = null , mixed $ else = null ): mixed

$if , $then und $else können einen beliebigen Typ haben. Wenn einem dieser Parameter ein Abschluss übergeben wird, wird dieser Abschluss ausgeführt und das Makro verwendet seine Ergebnisse.

Wenn $if einen wahren Wert zurückgibt, wird $then zurückgegeben, andernfalls wird $else zurückgegeben.

Hier einige Beispiele:

 collect ()-> if ( true , then: true , else: false ); // returns true
collect ()-> if ( false , then: true , else: false ); // returns false

Wenn ein Abschluss an $if , $then oder $else übergeben wird, wird die gesamte Sammlung als Argument an diesen Abschluss übergeben.

 // the `then` closure will be executed
// the first element of the returned collection now contains "THIS IS THE VALUE"
$ collection = collect ([ ' this is a value ' ])
    -> if (
        fn ( Collection $ collection ) => $ collection -> contains ( ' this is a value ' ),
        then: fn ( Collection $ collection ) => $ collection -> map ( fn ( string $ item ) => strtoupper ( $ item )),
        else: fn ( Collection $ collection ) => $ collection -> map ( fn ( string $ item ) => Str:: kebab ( $ item ))
    );

// the `else` closure will be executed
// the first element of the returned collection now contains "this-is-another-value"
$ collection = collect ([ ' this is another value ' ])
    -> if (
        fn ( Collection $ collection ) => $ collection -> contains ( ' this is a value ' ),
        then: fn ( Collection $ collection ) => $ collection -> map ( fn ( string $ item ) => strtoupper ( $ item )),
        else: fn ( Collection $ collection ) => $ collection -> map ( fn ( string $ item ) => Str:: kebab ( $ item ))
    );

ifAny

Führt den übergebenen Callable aus, wenn die Sammlung nicht leer ist. Die gesamte Sammlung wird zurückgegeben.

 collect ()-> ifAny ( function ( Collection $ collection ) { // empty collection so this won't get called
   echo ' Hello ' ;
});

collect ([ 1 , 2 , 3 ])-> ifAny ( function ( Collection $ collection ) { // non-empty collection so this will get called
   echo ' Hello ' ;
});

ifEmpty

Führt das übergebene Callable aus, wenn die Sammlung leer ist. Die gesamte Sammlung wird zurückgegeben.

 collect ()-> ifEmpty ( function ( Collection $ collection ) { // empty collection so this will called
   echo ' Hello ' ;
});

collect ([ 1 , 2 , 3 ])-> ifEmpty ( function ( Collection $ collection ) { // non-empty collection so this won't get called
   echo ' Hello ' ;
});

insertAfter

Fügt ein Element nach dem ersten Vorkommen eines bestimmten Elements ein und gibt die aktualisierte Collection-Instanz zurück. Optional kann ein Schlüssel angegeben werden.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertAfter ( ' zero ' , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertAfter ( 0 , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

insertAfterKey

Fügt ein Element nach einem bestimmten Schlüssel ein und gibt die aktualisierte Collection-Instanz zurück. Optional kann ein Schlüssel für den neuen Artikel angegeben werden.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertAfterKey ( 0 , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertAfterKey ( ' zero ' , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

insertAt

Fügt ein Element an einem bestimmten Index ein und gibt die aktualisierte Collection-Instanz zurück. Optional kann ein Schlüssel angegeben werden.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertAt ( 1 , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertAt ( 1 , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

insertBefore

Fügt ein Element vor dem ersten Vorkommen eines bestimmten Elements ein und gibt die aktualisierte Collection-Instanz zurück. Optional kann ein Schlüssel angegeben werden.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertBefore ( ' two ' , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertBefore ( 2 , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

insertBeforeKey

Fügt ein Element vor einem bestimmten Schlüssel ein und gibt die aktualisierte Collection-Instanz zurück. Optional kann ein Schlüssel für den neuen Artikel angegeben werden.

 collect ([ ' zero ' , ' two ' , ' three ' ])-> insertBeforeKey ( 1 , ' one ' );
// Collection contains ['zero', 'one', 'two', 'three']

collect ([ ' zero ' => 0 , ' two ' => 2 , ' three ' => 3 ]-> insertBeforeKey ( ' two ' , 5 , ' five ' );
// Collection contains ['zero' => 0, 'five' => 5, 'two' => 2, 'three' => 3]

none

Überprüft, ob eine Sammlung keine Vorkommen eines bestimmten Elements, Schlüssel-Wert-Paares oder bestandenen Wahrheitstests enthält. Die Funktion akzeptiert dieselben Parameter wie die Sammlungsmethode contains .

 collect ([ ' foo ' ])-> none ( ' bar ' ); // returns true
collect ([ ' foo ' ])-> none ( ' foo ' ); // returns false

collect ([[ ' name ' => ' foo ' ]])-> none ( ' name ' , ' bar ' ); // returns true
collect ([[ ' name ' => ' foo ' ]])-> none ( ' name ' , ' foo ' ); // returns false

collect ([ ' name ' => ' foo ' ])-> none ( function ( $ key , $ value ) {
   return $ key === ' name ' && $ value === ' bar ' ;
}); // returns true

paginate

Erstellen Sie eine LengthAwarePaginator -Instanz für die Elemente in der Sammlung.

 collect ( $ posts )-> paginate ( 5 );

Dadurch wird der Inhalt von $posts mit 5 Elementen pro Seite paginiert. paginate bietet eine ganze Reihe von Optionen. Eine ausführliche Anleitung finden Sie in der Laravel-Dokumentation.

 paginate(int $perPage = 15, string $pageName = 'page', ?int $page = null, ?int $total = null, array $options = [])

path

Gibt ein Element aus der Sammlung mit mehrdimensionalen Daten unter Verwendung der „Punkt“-Notation zurück. Funktioniert auf die gleiche Weise wie die pull -Methode der nativen Sammlung, jedoch ohne das Entfernen eines Elements aus der Sammlung.

 $ collection = new Collection ([
    ' foo ' => [
        ' bar ' => [
            ' baz ' => ' value ' ,
        ]
    ]
]);

$ collection -> path ( ' foo.bar.baz ' ) // 'value'

pluckMany

Gibt eine Sammlung nur mit den angegebenen Schlüsseln zurück.

 $ collection = collect ([
    [ ' a ' => 1 , ' b ' => 10 , ' c ' => 100 ],
    [ ' a ' => 2 , ' b ' => 20 , ' c ' => 200 ],
]);

$ collection -> pluckMany ([ ' a ' , ' b ' ]);

// returns
// collect([
//     ['a' => 1, 'b' => 10],
//     ['a' => 2, 'b' => 20],
// ]);

pluckManyValues

Gibt eine Sammlung nur mit den Werten der angegebenen Schlüssel zurück.

 $ collection = collect ([
    [ ' a ' => 1 , ' b ' => 10 , ' c ' => 100 ],
    [ ' a ' => 2 , ' b ' => 20 , ' c ' => 200 ],
]);

$ collection -> pluckMany ([ ' a ' , ' b ' ]);

// returns
// collect([
//     [1, 10],
//     [2, 20],
// ]);

pluckToArray

Gibt ein Array von Werten eines bestimmten Schlüssels zurück.

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

$ collection -> pluckToArray ( ' a ' ); // returns [1, 2, 3]

prioritize

Elemente an den Anfang der Sammlung verschieben.

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

$ collection
   -> prioritize ( function ( array $ item ) {
      return $ item [ ' id ' ] === 2 ;
   })
   -> pluck ( ' id ' )
   -> toArray (); // returns [2, 1, 3]

recursive

Konvertieren Sie ein Array und seine untergeordneten Elemente mithilfe der Rekursion in eine Sammlung.

 collect ([
  ' item ' => [
     ' children ' => []
  ]   
])-> recursive ();

// subsequent arrays are now collections

In manchen Fällen möchten Sie möglicherweise nicht alle untergeordneten Elemente in eine Sammlung umwandeln. Sie können die Konvertierung nur bis zu einer bestimmten Tiefe durchführen, indem Sie der rekursiven Methode eine Zahl bereitstellen.

 collect ([
  ' item ' => [
     ' children ' => [
        ' one ' => [ 1 ],
        ' two ' => [ 2 ]
     ]
  ]   
])-> recursive ( 1 ); // Collection(['item' => Collection(['children' => ['one' => [1], 'two' => [2]]])])

Dies kann nützlich sein, wenn Sie wissen, dass dies ab einer bestimmten Tiefe nicht mehr erforderlich ist oder Ihren Code beschädigen könnte.

 collect ([
  ' item ' => [
     ' children ' => [
        ' one ' => [ 1 ],
        ' two ' => [ 2 ]
     ]
  ]   
])
  -> recursive ( 1 )
  -> map ( function ( $ item ) {
    return $ item -> map ( function ( $ children ) {
      return $ children -> mapInto (Model::class);
    });
  }); // Collection(['item' => Collection(['children' => ['one' => Model(), 'two' => Model()]])])

// If we do not pass a max depth we will get the error "Argument #1 ($attributes) must be of type array"

rotate

Drehen Sie die Elemente in der Sammlung mit dem angegebenen Versatz

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

$ rotate = $ collection -> rotate ( 1 );

$ rotate -> toArray ();

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

sectionBy

Teilt eine Sammlung in Abschnitte auf, die nach einem bestimmten Schlüssel gruppiert sind. Ähnlich wie groupBy respektiert jedoch die Reihenfolge der Elemente in der Sammlung und verwendet vorhandene Schlüssel wieder.

 $ collection = collect ([
    [ ' name ' => ' Lesson 1 ' , ' module ' => ' Basics ' ],
    [ ' name ' => ' Lesson 2 ' , ' module ' => ' Basics ' ],
    [ ' name ' => ' Lesson 3 ' , ' module ' => ' Advanced ' ],
    [ ' name ' => ' Lesson 4 ' , ' module ' => ' Advanced ' ],
    [ ' name ' => ' Lesson 5 ' , ' module ' => ' Basics ' ],
]);

$ collection -> sectionBy ( ' module ' );

// [
//     ['Basics', [
//         ['name' => 'Lesson 1', 'module' => 'Basics'],
//         ['name' => 'Lesson 2', 'module' => 'Basics'],
//     ]],
//     ['Advanced', [
//         ['name' => 'Lesson 3', 'module' => 'Advanced'],
//         ['name' => 'Lesson 4', 'module' => 'Advanced'],
//     ]],
//     ['Basics', [
//         ['name' => 'Lesson 5', 'module' => 'Basics'],
//     ]],
// ];

Vollständige Signatur: sectionBy($callback, $preserveKeys, $sectionKey, $itemsKey)

simplePaginate

Erstellen Sie eine Paginator -Instanz für die Elemente in der Sammlung.

 collect ( $ posts )-> simplePaginate ( 5 );

Dadurch wird der Inhalt von $posts mit 5 Elementen pro Seite paginiert. simplePaginate bietet eine ganze Reihe von Optionen. Eine ausführliche Anleitung finden Sie in den Laravel-Dokumenten.

 simplePaginate(int $perPage = 15, string $pageName = 'page', ?int $page = null, ?int $total = null, array $options = [])

Eine ausführliche Anleitung zur Paginierung finden Sie in den Laravel-Dokumenten.

sliceBefore

Schneiden Sie die Werte aus einer Sammlung heraus, bevor der angegebene Rückruf wahr ist. Wenn der optionale Parameter $preserveKeys als true übergeben wird, bleiben die ursprünglichen Schlüssel erhalten.

 collect ([ 20 , 51 , 10 , 50 , 66 ])-> sliceBefore ( function ( $ item ) {
    return $ item > 50 ;
}); // return collect([[20],[51, 10, 50], [66])

tail

Extrahieren Sie den Schwanz aus einer Sammlung. Also alles bis auf das erste Element. Es ist eine Abkürzung für slice(1)->values() , aber dennoch sehr praktisch. Wenn der optionale Parameter $preserveKeys als true übergeben wird, bleiben die Schlüssel erhalten und es wird auf slice(1) zurückgegriffen.

 collect ([ 1 , 2 , 3 ])-> tail (); // return collect([2, 3])

toPairs

Verwandeln Sie eine Sammlung in ein Array mit Paaren.

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

$ collection -> toArray (); // returns ['a', 'b'], ['c', 'd'], ['e', 'f']

transpose

Das Ziel der Transponierung besteht darin, ein mehrdimensionales Array zu drehen und dabei die Zeilen in Spalten und die Spalten in Zeilen umzuwandeln.

 collect ([
    [ ' Jane ' , ' Bob ' , ' Mary ' ],
    [ ' [email protected] ' , ' [email protected] ' , ' [email protected] ' ],
    [ ' Doctor ' , ' Plumber ' , ' Dentist ' ],
])-> transpose ()-> toArray ();

// [
//     ['Jane', '[email protected]', 'Doctor'],
//     ['Bob', '[email protected]', 'Plumber'],
//     ['Mary', '[email protected]', 'Dentist'],
// ]

try

Wenn eine der Methoden zwischen try und catch eine Ausnahme auslöst, kann die Ausnahme in catch behandelt werden.

 collect ([ ' a ' , ' b ' , ' c ' , 1 , 2 , 3 ])
    -> try ()
    -> map ( fn ( $ letter ) => strtoupper ( $ letter ))
    -> each ( function () {
        throw new Exception ( ' Explosions in the sky ' );
    })
    -> catch ( function ( Exception $ exception ) {
        // handle exception here
    })
    -> map ( function () {
        // further operations can be done, if the exception wasn't rethrow in the `catch`
    });

Während die Methoden aus Gründen der Vertrautheit mit PHP den Namen try / catch tragen, verhält sich die Sammlung selbst eher wie eine Datenbanktransaktion. Wenn also eine Ausnahme ausgelöst wird, wird die ursprüngliche Sammlung (vor dem Versuch) zurückgegeben.

Sie können innerhalb von Catch Zugriff auf die Sammlung erhalten, indem Sie Ihrem Handler einen zweiten Parameter hinzufügen. Sie können die Sammlung auch innerhalb von Catch manipulieren, indem Sie einen Wert zurückgeben.

 $ collection = collect ([ ' a ' , ' b ' , ' c ' , 1 , 2 , 3 ])
    -> try ()
    -> map ( function ( $ item ) {
        throw new Exception ();
    })
    -> catch ( function ( Exception $ exception , $ collection ) {
        return collect ([ ' d ' , ' e ' , ' f ' ]);
    })
    -> map ( function ( $ item ) {
        return strtoupper ( $ item );
    });

// ['D', 'E', 'F']

validate

Gibt true zurück, wenn der angegebene $callback für jedes Element „true“ zurückgibt. Wenn $callback ein String oder ein Array ist, betrachten Sie es als Validierungsregel.

 collect ([ ' foo ' , ' foo ' ])-> validate ( function ( $ item ) {
   return $ item === ' foo ' ;
}); // returns true


collect ([ ' [email protected] ' , ' bla ' ])-> validate ( ' email ' ); // returns false
collect ([ ' [email protected] ' , ' [email protected] ' ])-> validate ( ' email ' ); // returns true

weightedRandom

Gibt ein zufälliges Element nach Gewicht zurück. In diesem Beispiel hat der Artikel mit a die größte Chance, ausgewählt zu werden, und der Artikel mit c die geringste.

 // pass the field name that should be used as a weight

$ randomItem = collect ([
    [ ' value ' => ' a ' , ' weight ' => 30 ],
    [ ' value ' => ' b ' , ' weight ' => 20 ],
    [ ' value ' => ' c ' , ' weight ' => 10 ],
])-> weightedRandom ( ' weight ' );

Alternativ können Sie einen Callable übergeben, um das Gewicht zu erhalten.

 $ randomItem = collect ([
    [ ' value ' => ' a ' , ' weight ' => 30 ],
    [ ' value ' => ' b ' , ' weight ' => 20 ],
    [ ' value ' => ' c ' , ' weight ' => 10 ],
])-> weightedRandom ( function ( array $ item ) {
   return $ item [ ' weight ' ];
});

withSize

Erstellen Sie eine neue Sammlung mit der angegebenen Anzahl an Artikeln.

Collection:: withSize ( 1 )-> toArray (); // return [1];
Collection:: withSize ( 5 )-> toArray (); // return [1,2,3,4,5]; 

Änderungsprotokoll

Weitere Informationen zu den letzten Änderungen finden Sie im CHANGELOG.

Testen

$ composer test 

Mitwirken

Weitere Informationen finden Sie unter BEITRAGEN.

Sicherheit

Wenn Sie einen Sicherheitsfehler gefunden haben, senden Sie bitte eine E-Mail an [email protected], anstatt den Issue-Tracker zu verwenden.

Credits

• Freek Van der Herten
• Sebastian De Deyne
• Alle Mitwirkenden

Über Spatie

Spatie ist eine Webdesign-Agentur mit Sitz in Antwerpen, Belgien. Eine Übersicht aller unserer Open-Source-Projekte finden Sie auf unserer Website.

Lizenz

Die MIT-Lizenz (MIT). Weitere Informationen finden Sie in der Lizenzdatei.