laravel collection macros

Um conjunto de macros de coleção úteis do Laravel

Este repositório contém algumas macros de coleção úteis.

Spatie é uma agência de webdesign com sede em Antuérpia, Bélgica. Você encontrará uma visão geral de todos os nossos projetos de código aberto em nosso site.

Apoie-nos

Investimos muitos recursos na criação dos melhores pacotes de código aberto. Você pode nos apoiar comprando um de nossos produtos pagos.

Agradecemos muito que você nos envie um cartão postal de sua cidade natal, mencionando qual(is) de nossos pacotes você está usando. Você encontrará nosso endereço em nossa página de contato. Publicamos todos os cartões postais recebidos em nosso mural virtual de cartões postais.

Instalação

Você pode obter o pacote via compositor:

composer require spatie/laravel-collection-macros

O pacote será registrado automaticamente.

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

Obtenha o próximo item da coleção.

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

Você também pode passar um segundo parâmetro para ser usado como substituto.

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

$ currentItem = 3 ;

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

at

Recuperar um item em um índice.

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

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

second

Recuperar item no segundo índice.

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

$ data -> second (); // 2

third

Recuperar item no terceiro índice.

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

$ data -> third (); // 3

fourth

Recuperar item no quarto índice.

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

$ data -> fourth (); // 4

fifth

Recuperar item no quinto índice.

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

$ data -> fifth (); // 5

sixth

Recuperar item no sexto índice.

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

$ data -> sixth (); // 6

seventh

Recuperar item no sétimo índice.

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

$ data -> seventh (); // 7

eighth

Recuperar item no oitavo índice.

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

$ data -> eighth (); // 8

ninth

Recuperar item no nono índice.

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

$ data -> ninth (); // 9

tenth

Recuperar item no décimo índice.

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

$ data -> tenth (); // 10

getNth

Recuperar item no enésimo item.

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

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

before

Obtenha o item anterior da coleção.

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

Você também pode passar um segundo parâmetro para ser usado como substituto.

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

$ currentItem = 1 ;

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

catch

Veja Try

chunkBy

Divide os valores de uma coleção em grupos, desde que o retorno de chamada fornecido seja verdadeiro. Se o parâmetro opcional $preserveKeys como true for passado, ele preservará as chaves originais.

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

collectBy

Obtenha um item com uma determinada chave e colete-o.

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

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

Você também pode passar um segundo parâmetro para ser usado como substituto.

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

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

containsAny

Retornará true se um ou mais dos valores fornecidos existirem na coleção.

 $ 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

Retornará true se todos os valores fornecidos existirem na coleção.

 $ 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

Obtenha os seguintes vizinhos consecutivos em uma coleção de um determinado tamanho de bloco. Se o parâmetro opcional $preserveKeys como true for passado, ele preservará as chaves originais.

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

extract

Extraia chaves de uma coleção. Isso é muito semelhante a only , com duas diferenças principais:

• extract retorna uma matriz de valores, não uma matriz associativa
• Se um valor não existir, ele preencherá o valor com null em vez de omiti-lo

extract é útil ao usar a sintaxe short list() do PHP 7.1.

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

filterMap

Mapeie uma coleção e remova valores falsos de uma só 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

Obtenha o primeiro item. Lança SpatieCollectionMacrosExceptionsCollectionItemNotFound se o item não foi encontrado.

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

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

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

firstOrPush

Recupere o primeiro item usando o chamável fornecido como primeiro parâmetro. Se não existir nenhum valor, envie o valor do segundo parâmetro para a coleção. Você pode passar um callable como segundo parâmetro.

Este método é realmente útil ao lidar com propriedades de classe em cache, onde você deseja armazenar um valor recuperado de uma API ou função computacionalmente cara em uma coleção para ser usada várias vezes.

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

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

Ocasionalmente, você desejará especificar a coleção de destino para a qual será enviado o push. Você pode passar isso como um terceiro 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 uma coleção em um item de coleção em forma de array associativo.

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

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

getCaseInsensitive

Obtenha o valor de uma determinada chave.

Se a chave for uma string, procuraremos a chave usando uma comparação que não diferencia maiúsculas de minúsculas.

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

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

glob

Retorna uma coleção de resultados glob() .

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

groupByModel

Semelhante a groupBy , mas agrupa a coleção por um modelo Eloquent. Como a chave é um objeto em vez de um número inteiro ou string, os resultados são divididos em matrizes separadas.

 $ posts -> groupByModel ( ' category ' );

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

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

hasCaseInsensitive

Determine se a coleção contém uma chave com um determinado nome.

Se $key for uma string, procuraremos a chave usando uma comparação que não diferencia maiúsculas de minúsculas.

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

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

head

Recupera o primeiro item da coleção.

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

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

$ collection = collect ([]);

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

if

A macro if pode ajudar a ramificar cadeias de coleta. Esta é a assinatura desta macro:

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

$if , $then e $else podem ser de qualquer tipo. Se um fechamento for passado para qualquer um desses parâmetros, esse fechamento será executado e a macro usará seus resultados.

Quando $if retornar um valor verdadeiro, então $then será retornado, caso contrário $else será retornado.

Aqui estão alguns exemplos:

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

Quando um encerramento é passado para $if , $then ou $else , toda a coleção será passada como argumento para esse encerramento.

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

Executa o callable passado se a coleção não estiver vazia. Toda a coleção será devolvida.

 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

Executa o callable passado se a coleção estiver vazia. Toda a coleção será devolvida.

 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

Insere um item após a primeira ocorrência de um determinado item e retorna a instância atualizada de Collection. Opcionalmente, uma chave pode ser fornecida.

 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

Insere um item após uma determinada chave e retorna a instância atualizada da coleção. Opcionalmente, uma chave para o novo item pode ser fornecida.

 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

Insere um item em um determinado índice e retorna a instância atualizada da coleção. Opcionalmente, uma chave pode ser fornecida.

 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

Insere um item antes da primeira ocorrência de um determinado item e retorna a instância atualizada de Collection. Opcionalmente, uma chave pode ser fornecida.

 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

Insere um item antes de uma determinada chave e retorna a instância atualizada da coleção. Opcionalmente, uma chave para o novo item pode ser fornecida.

 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

Verifica se uma coleção não contém nenhuma ocorrência de um determinado item, par de valores-chave ou aprovação no teste de verdade. A função aceita os mesmos parâmetros que o método de coleção 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

Crie uma instância LengthAwarePaginator para os itens da coleção.

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

Isso pagina o conteúdo de $posts com 5 itens por página. paginate aceita algumas opções, consulte a documentação do Laravel para obter um guia detalhado.

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

path

Retorna um item da coleção com dados multidimensionais usando a notação "ponto". Funciona da mesma forma que o método pull da coleção nativa, mas sem remover um item da coleção.

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

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

pluckMany

Retorna uma coleção apenas com as chaves 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

Retorna uma coleção apenas com os valores das chaves 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

Retorna uma matriz de valores de uma determinada chave.

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

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

prioritize

Mova os elementos para o início da coleção.

 $ 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

Converta um array e seus filhos em uma coleção usando recursão.

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

// subsequent arrays are now collections

Em alguns casos você pode não querer transformar todos os filhos em uma coleção. Você pode converter apenas até uma certa profundidade, fornecendo um número ao método recursivo.

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

Isso pode ser útil quando você sabe que em uma certa profundidade isso não será necessário ou que poderá quebrar seu 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

Gire os itens da coleção com determinado deslocamento

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

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

$ rotate -> toArray ();

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

sectionBy

Divide uma coleção em seções agrupadas por uma determinada chave. Semelhante ao groupBy , mas respeita a ordem dos itens na coleção e reutiliza as chaves 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'],
//     ]],
// ];

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

simplePaginate

Crie uma instância Paginator para os itens da coleção.

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

Isso pagina o conteúdo de $posts com 5 itens por página. simplePaginate aceita algumas opções, consulte a documentação do Laravel para obter um guia detalhado.

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

Para um guia detalhado sobre paginação, confira a documentação do Laravel.

sliceBefore

Divida os valores de uma coleção antes que o retorno de chamada fornecido seja verdadeiro. Se o parâmetro opcional $preserveKeys como true for passado, ele preservará as chaves originais.

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

tail

Extraia a cauda de uma coleção. Então, tudo, exceto o primeiro elemento. É uma abreviação de slice(1)->values() , mas mesmo assim é muito útil. Se o parâmetro opcional $preserveKeys como true for passado, ele preservará as chaves e retornará para slice(1) .

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

toPairs

Transforme uma coleção em um array com pares.

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

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

transpose

O objetivo da transposição é girar um array multidimensional, transformando as linhas em colunas e as colunas em linhas.

 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

Se algum dos métodos entre try e catch lançar uma exceção, a exceção poderá ser tratada em 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`
    });

Embora os métodos sejam nomeados try / catch para familiaridade com PHP, a coleção em si se comporta mais como uma transação de banco de dados. Assim, quando uma exceção é lançada, a coleção original (antes da tentativa) é retornada.

Você pode obter acesso à coleção dentro do catch adicionando um segundo parâmetro ao seu manipulador. Você também pode manipular a coleção dentro do catch retornando um 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

Retorna true se o $callback fornecido retornar verdadeiro para cada item. Se $callback for uma string ou array, considere isso como uma regra de validação.

 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

Retorna um item aleatório por peso. Neste exemplo, o item com a tem maior chance de ser escolhido e o item com c menor.

 // 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, você pode passar um callable para obter o peso.

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

withSize

Crie uma nova coleção com a quantidade especificada de itens.

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

Registro de alterações

Consulte CHANGELOG para obter mais informações sobre o que mudou recentemente.

Teste

$ composer test 

Contribuindo

Consulte CONTRIBUINDO para obter detalhes.

Segurança

Se você encontrou um bug relacionado à segurança, envie um email para [email protected] em vez de usar o rastreador de problemas.

Créditos

• Freek Van der Herten
• Sebastião De Deyne
• Todos os colaboradores

Sobre Spatie

Spatie é uma agência de webdesign com sede em Antuérpia, Bélgica. Você encontrará uma visão geral de todos os nossos projetos de código aberto em nosso site.

Licença

A licença MIT (MIT). Consulte Arquivo de licença para obter mais informações.