laravel collection macros

Un ensemble de macros de collection Laravel utiles

Ce référentiel contient quelques macros de collection utiles.

Spatie est une agence de webdesign basée à Anvers, en Belgique. Vous trouverez un aperçu de tous nos projets open source sur notre site Internet.

Soutenez-nous

Nous investissons beaucoup de ressources dans la création des meilleurs packages open source de leur catégorie. Vous pouvez nous soutenir en achetant l'un de nos produits payants.

Nous apprécions grandement que vous nous envoyiez une carte postale de votre ville natale, mentionnant le(s) forfait(s) que vous utilisez. Vous trouverez notre adresse sur notre page contact. Nous publions toutes les cartes postales reçues sur notre mur virtuel de cartes postales.

Installation

Vous pouvez extraire le package via composer :

composer require spatie/laravel-collection-macros

Le package s’enregistrera automatiquement.

Macro

• 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

Obtenez l'élément suivant de la collection.

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

Vous pouvez également transmettre un deuxième paramètre à utiliser comme solution de secours.

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

$ currentItem = 3 ;

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

at

Récupérer un élément dans un index.

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

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

second

Récupérer l'élément au deuxième index.

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

$ data -> second (); // 2

third

Récupérer l'élément au troisième index.

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

$ data -> third (); // 3

fourth

Récupérer l'élément au quatrième index.

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

$ data -> fourth (); // 4

fifth

Récupérer l'élément au cinquième index.

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

$ data -> fifth (); // 5

sixth

Récupérer l'élément au sixième index.

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

$ data -> sixth (); // 6

seventh

Récupérer l'élément au septième index.

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

$ data -> seventh (); // 7

eighth

Récupérer l'élément au huitième index.

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

$ data -> eighth (); // 8

ninth

Récupère l'élément au neuvième index.

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

$ data -> ninth (); // 9

tenth

Récupérer l'élément au dixième index.

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

$ data -> tenth (); // 10

getNth

Récupérer l'élément au nième élément.

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

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

before

Récupérez l’élément précédent de la collection.

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

Vous pouvez également transmettre un deuxième paramètre à utiliser comme solution de secours.

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

$ currentItem = 1 ;

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

catch

Voir Try

chunkBy

Divise les valeurs d'une collection en groupes tant que le rappel donné est vrai. Si le paramètre facultatif $preserveKeys comme true est passé, il conservera les clés d'origine.

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

collectBy

Obtenez un objet à une clé donnée et récupérez-le.

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

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

Vous pouvez également transmettre un deuxième paramètre à utiliser comme solution de secours.

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

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

containsAny

Renvoie true si une ou plusieurs des valeurs données existent dans la collection.

 $ 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

Renvoie true si toutes les valeurs données existent dans la collection.

 $ 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

Obtenez les voisins consécutifs suivants dans une collection à partir d'une taille de bloc donnée. Si le paramètre facultatif $preserveKeys comme true est passé, il conservera les clés d'origine.

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

extract

Extraire les clés d'une collection. Ceci est très similaire à only , avec deux différences clés :

• extract renvoie un tableau de valeurs, pas un tableau associatif
• Si une valeur n'existe pas, il la remplira avec null au lieu de l'omettre

extract est utile lors de l'utilisation de la syntaxe PHP 7.1 short list() .

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

filterMap

Mappez une collection et supprimez les valeurs fausses en une seule fois.

 $ 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

Obtenez le premier élément. Lance SpatieCollectionMacrosExceptionsCollectionItemNotFound si l'élément n'a pas été trouvé.

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

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

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

firstOrPush

Récupérez le premier élément en utilisant l'appelable donné comme premier paramètre. Si aucune valeur n’existe, transférez la valeur du deuxième paramètre dans la collection. Vous pouvez passer un callable comme deuxième paramètre.

Cette méthode est très utile lorsqu'il s'agit de propriétés de classe mises en cache, où vous souhaitez stocker une valeur récupérée à partir d'une API ou d'une fonction coûteuse en termes de calcul dans une collection à utiliser plusieurs fois.

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

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

Parfois, vous souhaiterez spécifier la collection cible vers laquelle pousser. Vous pouvez passer ceci comme troisième paramètre.

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

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

fromPairs

Transformez une collection en un élément de collection sous forme de tableau associatif.

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

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

getCaseInsensitive

Obtenez la valeur d'une clé donnée.

Si la clé est une chaîne, nous la rechercherons en utilisant une comparaison insensible à la casse.

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

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

glob

Renvoie une collection d'un résultat glob() .

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

groupByModel

Similaire à groupBy , mais regroupe la collection par un modèle Eloquent. Puisque la clé est un objet au lieu d’un entier ou d’une chaîne, les résultats sont divisés en tableaux distincts.

 $ posts -> groupByModel ( ' category ' );

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

Signature complète : groupByModel($callback, $preserveKeys, $modelKey, $itemsKey)

hasCaseInsensitive

Déterminez si la collection contient une clé avec un nom donné.

Si $key est une chaîne, nous rechercherons la clé en utilisant une comparaison insensible à la casse.

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

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

head

Récupère le premier élément de la collection.

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

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

$ collection = collect ([]);

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

if

La macro if peut aider les chaînes de collecte de branches. Voici la signature de cette macro :

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

$if , $then et $else peuvent être de n'importe quel type. Si une fermeture est transmise à l'un de ces paramètres, alors cette fermeture sera exécutée et la macro utilisera ses résultats.

Lorsque $if renvoie une valeur véridique, alors $then sera renvoyé, sinon $else sera renvoyé.

Voici quelques exemples :

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

Lorsqu'une fermeture est transmise à $if , $then ou $else , la collection entière sera transmise comme argument à cette fermeture.

 // 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

Exécute l'appelable passé si la collection n'est pas vide. L'ensemble de la collection sera restitué.

 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

Exécute l'appelable passé si la collection est vide. L'ensemble de la collection sera restitué.

 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

Insère un élément après la première occurrence d'un élément donné et renvoie l'instance Collection mise à jour. En option, une clé peut être donnée.

 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

Insère un élément après une clé donnée et renvoie l'instance Collection mise à jour. En option, une clé pour le nouvel élément peut être donnée.

 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

Insère un élément à un index donné et renvoie l'instance Collection mise à jour. En option, une clé peut être donnée.

 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

Insère un élément avant la première occurrence d'un élément donné et renvoie l'instance Collection mise à jour. En option, une clé peut être donnée.

 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

Insère un élément avant une clé donnée et renvoie l'instance Collection mise à jour. En option, une clé pour le nouvel élément peut être donnée.

 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

Vérifie si une collection ne contient aucune occurrence d'un élément donné, d'une paire clé-valeur ou d'un test de vérité réussi. La fonction accepte les mêmes paramètres que la méthode de collection 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

Créez une instance LengthAwarePaginator pour les éléments de la collection.

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

Cela pagine le contenu de $posts avec 5 éléments par page. paginate accepte un certain nombre d'options, rendez-vous sur la documentation Laravel pour un guide détaillé.

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

path

Renvoie un élément de la collection avec des données multidimensionnelles en utilisant la notation « point ». Fonctionne de la même manière que la méthode pull de la collection native, mais sans supprimer un élément de la collection.

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

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

pluckMany

Renvoie une collection avec uniquement les clés spécifiées.

 $ 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

Renvoie une collection avec uniquement les valeurs des clés spécifiées.

 $ 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

Renvoie un tableau de valeurs d'une clé donnée.

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

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

prioritize

Déplacez les éléments au début de la collection.

 $ 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

Convertissez un tableau et ses enfants en collection en utilisant la récursion.

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

// subsequent arrays are now collections

Dans certains cas, vous ne souhaiterez peut-être pas regrouper tous les enfants dans une collection. Vous ne pouvez convertir que jusqu'à une certaine profondeur en fournissant un nombre à la méthode récursive.

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

Cela peut être utile lorsque vous savez qu'à une certaine profondeur, cela ne sera pas nécessaire ou que cela pourrait casser votre code.

 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

Faire pivoter les éléments de la collection avec un décalage donné

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

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

$ rotate -> toArray ();

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

sectionBy

Divise une collection en sections regroupées par une clé donnée. Similaire à groupBy mais respecte l'ordre des éléments de la collection et réutilise les clés existantes.

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

Signature complète : sectionBy($callback, $preserveKeys, $sectionKey, $itemsKey)

simplePaginate

Créez une instance Paginator pour les éléments de la collection.

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

Cela pagine le contenu de $posts avec 5 éléments par page. simplePaginate accepte un certain nombre d'options, rendez-vous sur la documentation Laravel pour un guide détaillé.

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

Pour un guide détaillé sur la pagination, consultez la documentation Laravel.

sliceBefore

Supprimez les valeurs d'une collection avant que le rappel donné ne soit vrai. Si le paramètre facultatif $preserveKeys comme true est passé, il conservera les clés d'origine.

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

tail

Extrayez la queue d’une collection. Donc tout sauf le premier élément. C'est un raccourci pour slice(1)->values() , mais néanmoins très pratique. Si le paramètre facultatif $preserveKeys comme true est passé, il conservera les clés et reviendra à slice(1) .

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

toPairs

Transformez une collection en un tableau avec des paires.

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

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

transpose

Le but de la transposition est de faire pivoter un tableau multidimensionnel, en transformant les lignes en colonnes et les colonnes en lignes.

 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

Si l’une des méthodes entre try et catch renvoie une exception, celle-ci peut être gérée dans catch .

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

Bien que les méthodes soient nommées try / catch pour se familiariser avec PHP, la collection elle-même se comporte davantage comme une transaction de base de données. Ainsi, lorsqu'une exception est levée, la collection originale (avant l'essai) est renvoyée.

Vous pouvez accéder à la collection dans catch en ajoutant un deuxième paramètre à votre gestionnaire. Vous pouvez également manipuler la collection dans catch en renvoyant une valeur.

 $ 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

Renvoie true si le $callback donné renvoie vrai pour chaque élément. Si $callback est une chaîne ou un tableau, considérez-le comme une règle de validation.

 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

Renvoie un élément aléatoire par poids. Dans cet exemple, l'élément avec a a le plus de chances d'être sélectionné, et l'élément avec c le moins.

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

Alternativement, vous pouvez passer un appel pour obtenir le poids.

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

withSize

Créez une nouvelle collection avec la quantité spécifiée d'éléments.

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

Journal des modifications

Veuillez consulter CHANGELOG pour plus d'informations sur ce qui a changé récemment.

Essai

$ composer test 

Contribuer

Veuillez consulter CONTRIBUER pour plus de détails.

Sécurité

Si vous avez trouvé un bug concernant la sécurité, veuillez envoyer un mail à [email protected] au lieu d'utiliser le suivi des problèmes.

Crédits

• Freek Van der Herten
• Sébastien De Deyne
• Tous les contributeurs

À propos de Spatie

Spatie est une agence de webdesign basée à Anvers, en Belgique. Vous trouverez un aperçu de tous nos projets open source sur notre site Internet.

Licence

La licence MIT (MIT). Veuillez consulter le fichier de licence pour plus d'informations.