laravel collection macros

Un conjunto de macros útiles de colección de Laravel

Este repositorio contiene algunas macros de colección útiles.

Spatie es una agencia de diseño web con sede en Amberes, Bélgica. Encontrará una descripción general de todos nuestros proyectos de código abierto en nuestro sitio web.

Apóyanos

Invertimos muchos recursos en la creación de los mejores paquetes de código abierto. Puedes apoyarnos comprando uno de nuestros productos pagos.

Apreciamos mucho que nos envíe una postal desde su ciudad natal, mencionando cuál de nuestros paquetes está utilizando. Encontrarás nuestra dirección en nuestra página de contacto. Publicamos todas las postales recibidas en nuestro muro virtual de postales.

Instalación

Puede introducir el paquete a través del compositor:

composer require spatie/laravel-collection-macros

El paquete se registrará automáticamente.

macros

• 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

Consigue el siguiente artículo de la colección.

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

También puede pasar un segundo parámetro para usarlo como respaldo.

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

$ currentItem = 3 ;

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

at

Recuperar un elemento en un índice.

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

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

second

Recuperar artículo en el segundo índice.

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

$ data -> second (); // 2

third

Recuperar artículo en el tercer índice.

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

$ data -> third (); // 3

fourth

Recuperar artículo en el cuarto índice.

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

$ data -> fourth (); // 4

fifth

Recuperar artículo en el quinto índice.

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

$ data -> fifth (); // 5

sixth

Recuperar artículo en el sexto índice.

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

$ data -> sixth (); // 6

seventh

Recuperar artículo en el séptimo índice.

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

$ data -> seventh (); // 7

eighth

Recuperar artículo en el octavo índice.

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

$ data -> eighth (); // 8

ninth

Recuperar artículo en el noveno índice.

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

$ data -> ninth (); // 9

tenth

Recuperar artículo en el décimo índice.

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

$ data -> tenth (); // 10

getNth

Recuperar artículo en el enésimo artículo.

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

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

before

Consigue el artículo anterior de la colección.

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

También puede pasar un segundo parámetro para usarlo como respaldo.

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

$ currentItem = 1 ;

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

catch

Ver Try

chunkBy

Divide los valores de una colección en grupos siempre que la devolución de llamada dada sea verdadera. Si se pasa el parámetro opcional $preserveKeys como true , se conservarán las claves originales.

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

collectBy

Obtenga un artículo en una clave determinada y recójalo.

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

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

También puede pasar un segundo parámetro para usarlo como respaldo.

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

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

containsAny

Devolverá true si uno o más de los valores dados existen en la colección.

 $ 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

Devolverá true si todos los valores dados existen en la colección.

 $ 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

Obtenga los siguientes vecinos consecutivos en una colección a partir de un tamaño de fragmento determinado. Si se pasa el parámetro opcional $preserveKeys como true , se conservarán las claves originales.

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

extract

Extraer claves de una colección. Esto es muy similar a only , con dos diferencias clave:

• extract devuelve una matriz de valores, no una matriz asociativa
• Si un valor no existe, lo completará con null en lugar de omitirlo.

extract es útil cuando se utiliza la sintaxis list() de PHP 7.1.

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

filterMap

Asigne una colección y elimine valores falsos de una sola vez.

 $ 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

Consigue el primer artículo. Lanza SpatieCollectionMacrosExceptionsCollectionItemNotFound si no se encontró el elemento.

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

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

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

firstOrPush

Recupere el primer elemento utilizando el invocable proporcionado como primer parámetro. Si no existe ningún valor, inserte el valor del segundo parámetro en la colección. Puede pasar un invocable como segundo parámetro.

Este método es realmente útil cuando se trata de propiedades de clase almacenadas en caché, donde desea almacenar un valor recuperado de una API o una función computacionalmente costosa en una colección para usarla varias veces.

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

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

En ocasiones, querrás especificar la colección de destino a la que se enviará. Puede pasar esto como un tercer parámetro.

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

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

fromPairs

Transforme una colección en un elemento de colección de formulario de matriz asociativa.

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

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

getCaseInsensitive

Obtenga el valor de una clave determinada.

Si la clave es una cadena, buscaremos la clave mediante una comparación que no distingue entre mayúsculas y minúsculas.

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

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

glob

Devuelve una colección de un resultado glob() .

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

groupByModel

Similar a groupBy , pero agrupa la colección según un modelo Eloquent. Dado que la clave es un objeto en lugar de un número entero o una cadena, los resultados se dividen en matrices separadas.

 $ posts -> groupByModel ( ' category ' );

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

Firma completa: groupByModel($callback, $preserveKeys, $modelKey, $itemsKey)

hasCaseInsensitive

Determine si la colección contiene una clave con un nombre de pila.

Si $key es una cadena, buscaremos la clave usando una comparación que no distingue entre mayúsculas y minúsculas.

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

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

head

Recupera el primer elemento de la colección.

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

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

$ collection = collect ([]);

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

if

La macro if puede ayudar a ramificar las cadenas de recolección. Esta es la firma de esta macro:

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

$if , $then y $else pueden ser de cualquier tipo. Si se pasa un cierre a cualquiera de estos parámetros, ese cierre se ejecutará y la macro utilizará sus resultados.

Cuando $if devuelve un valor verdadero, entonces se devolverá $then ; de lo contrario, se devolverá $else .

A continuación se muestran algunos ejemplos:

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

Cuando se pasa un cierre a $if , $then o $else , se pasará toda la colección como argumento para ese cierre.

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

Ejecuta el invocable pasado si la colección no está vacía. Se devolverá toda la colección.

 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

Ejecuta el invocable pasado si la colección está vacía. Se devolverá toda la colección.

 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

Inserta un elemento después de la primera aparición de un elemento determinado y devuelve la instancia de Colección actualizada. Opcionalmente se puede entregar una clave.

 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

Inserta un elemento después de una clave determinada y devuelve la instancia de Colección actualizada. Opcionalmente se puede entregar una clave para el nuevo artículo.

 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

Inserta un elemento en un índice determinado y devuelve la instancia de Colección actualizada. Opcionalmente se puede entregar una clave.

 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

Inserta un elemento antes de la primera aparición de un elemento determinado y devuelve la instancia de Colección actualizada. Opcionalmente se puede entregar una clave.

 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

Inserta un elemento antes de una clave determinada y devuelve la instancia de Colección actualizada. Opcionalmente se puede entregar una clave para el nuevo artículo.

 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

Comprueba si una colección no contiene ninguna aparición de un elemento determinado, un par clave-valor o una prueba de verdad que pase. La función acepta los mismos parámetros que el método de colección 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

Cree una instancia LengthAwarePaginator para los elementos de la colección.

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

Esto pagina el contenido de $posts con 5 elementos por página. paginate acepta bastantes opciones, dirígete a los documentos de Laravel para obtener una guía detallada.

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

path

Devuelve un elemento de la colección con datos multidimensionales utilizando notación de "puntos". Funciona de la misma manera que el método pull de la colección nativa, pero sin eliminar un elemento de la colección.

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

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

pluckMany

Devuelve una colección con solo las claves especificadas.

 $ 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

Devuelve una colección con solo los valores de las claves especificadas.

 $ 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

Devuelve una matriz de valores de una clave determinada.

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

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

prioritize

Mueve elementos al inicio de la colección.

 $ 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

Convierta una matriz y sus hijos en una colección mediante recursividad.

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

// subsequent arrays are now collections

En algunos casos, es posible que no quieras convertir a todos los niños en una colección. Puede convertir solo hasta una cierta profundidad proporcionando un número al método recursivo.

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

Esto puede resultar útil cuando sabes que a cierta profundidad no será necesario o que puede romper tu código.

 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

Rotar los elementos de la colección con el desplazamiento dado.

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

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

$ rotate -> toArray ();

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

sectionBy

Divide una colección en secciones agrupadas por una clave determinada. Similar a groupBy pero respeta el orden de los elementos de la colección y reutiliza las claves existentes.

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

Firma completa: sectionBy($callback, $preserveKeys, $sectionKey, $itemsKey)

simplePaginate

Cree una instancia Paginator para los elementos de la colección.

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

Esto pagina el contenido de $posts con 5 elementos por página. simplePaginate acepta bastantes opciones; dirígete a los documentos de Laravel para obtener una guía detallada.

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

Para obtener una guía detallada sobre la paginación, consulte los documentos de Laravel.

sliceBefore

Separe los valores de una colección antes de que la devolución de llamada dada sea verdadera. Si se pasa el parámetro opcional $preserveKeys como true , se conservarán las claves originales.

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

tail

Extrae la cola de una colección. Entonces todo excepto el primer elemento. Es una abreviatura de slice(1)->values() , pero aun así es muy útil. Si se pasa el parámetro opcional $preserveKeys as true , preservará las claves y recurrirá a slice(1) .

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

toPairs

Transforma una colección en una matriz con pares.

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

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

transpose

El objetivo de la transposición es rotar una matriz multidimensional, convirtiendo las filas en columnas y las columnas en filas.

 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 alguno de los métodos entre try y catch genera una excepción, entonces la excepción se puede manejar en 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`
    });

Si bien los métodos se denominan try / catch para estar familiarizado con PHP, la colección en sí se comporta más como una transacción de base de datos. Entonces, cuando se produce una excepción, se devuelve la colección original (antes del intento).

Puede obtener acceso a la colección dentro de catch agregando un segundo parámetro a su controlador. También puedes manipular la colección dentro de catch devolviendo un valor.

 $ 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

Devuelve true si la $callback dada devuelve verdadero para cada elemento. Si $callback es una cadena o una matriz, considérelo como una regla de validación.

 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

Devuelve un elemento aleatorio por peso. En este ejemplo, el elemento con a tiene más posibilidades de ser elegido y el elemento con c tiene menos posibilidades.

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

Alternativamente, puede pasar un invocable para obtener el peso.

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

withSize

Crea una nueva colección con la cantidad especificada de artículos.

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

Registro de cambios

Consulte CHANGELOG para obtener más información sobre los cambios recientes.

Pruebas

$ composer test 

Contribuyendo

Consulte CONTRIBUCIÓN para obtener más detalles.

Seguridad

Si encuentra un error relacionado con la seguridad, envíe un correo electrónico a [email protected] en lugar de utilizar el rastreador de problemas.

Créditos

• Freek Van der Herten
• Sebastián De Deyne
• Todos los contribuyentes

Acerca de Spatie

Spatie es una agencia de diseño web con sede en Amberes, Bélgica. Encontrará una descripción general de todos nuestros proyectos de código abierto en nuestro sitio web.

Licencia

La Licencia MIT (MIT). Consulte el archivo de licencia para obtener más información.