15 métodos impressionantes de coleção do Laravel

Laravel Collection Methods

O Laravel Eloquent usa Coleções para retornar os resultados. Coleções contém métodos muito úteis que os tornam muito poderosos e úteis de usar. Você pode filtrá-los, modificá-los e muito mais com eles de maneira conveniente. Veremos os métodos de coleta de laravel neste tutorial. As coleções não se limitam apenas a resultados eloquentes, mas podem ser usadas separadamente. Resultados eloquentes usam coleções. Você pode simplesmente criar uma coleção passando uma matriz para coletar a função auxiliar. Todos os próximos métodos de coleção listados abaixo são aplicáveis ​​tanto às coleções eloquentes quanto às próprias coleções. Digamos que você tenha um modelo de postagem. Você encontra todas as postagens com a categoria php.

    [
        'user_id' => '1',
        'title' => 'Helpers in Laravel',
        'content' => 'Create custom helpers in Laravel',
        'category' => 'php'
    ],
    [
        'user_id' => '2',
        'title' => 'Testing in Laravel',
        'content' => 'Testing File Uploads in Laravel',
        'category' => 'php'
    ],
    [
        'user_id' => '3',
        'title' => 'Telegram Bot',
        'content' => 'Crypto Telegram Bot in Laravel',
        'category' => 'php'
    ],
]);

A matriz acima é na verdade os valores do nosso modelo de postagem. Neste tutorial, usaremos essa matriz para simplificação. Lembre-se de que tudo também funcionará da mesma maneira para os eloquentes. Quando aplicamos métodos auxiliares em coleções eloquentes, eles não consultam o banco de dados. Todos os resultados que queremos obter do banco de dados são obtidos primeiro e depois usamos métodos de coleta para filtrar e modificá-los sem nenhuma consulta ao banco de dados.

Table of Contents

filter()
search()
chunk()
dump()
map()
zip()
whereNotIn()
max()
pluck()
each()
tap()
pipe()
contains()
forget()
avg()

filter()

filter, um dos métodos de coleta de laravel mais úteis, permite filtrar a coleção com um retorno de chamada. Apenas passa os itens que retornam verdadeiros. Todos os outros itens são removidos. O filtro retorna uma nova instância sem alterar a instância original. Ele aceita valor e chave como dois parâmetros no retorno de chamada.

$filter = $collection->filter(function($value, $key) {
if ($value['user_id'] == 2) {
        return true;
    }
});
 
$filter->all();

Retorno

[
1 => [
"user_id" => 2,
"title" => "Testing in Laravel",
"content" => "Testing File Uploads in Laravel",
"category" => "php"
]
]

search()

O método de pesquisa é usado para pesquisar na coleção um determinado valor. Se o valor estiver presente na coleção, a chave do valor será retornada. Se o valor não corresponder a nenhum item, será retornado false.


$names = collect(['Alex', 'John', 'Jason', 'Martyn', 'Hanlin']);
 
$names->search('Jason');

// 2

> Você também pode passar sua própria função de retorno de chamada para o método de pesquisa. Ele retornará a chave do primeiro item que passa no teste de verdade de retorno de chamada.
```php
$names = collect(['Alex', 'John', 'Jason', 'Martyn', 'Hanlin']);
 
$names->search(function($value, $key) {
    return strlen($value) == 6;
});
 
// 3
```

# chunk()
> O método chunk é usado para dividir a coleção em várias coleções menores de um determinado tamanho. É útil exibir coleções na grade.
```php
$prices = collect([18, 23, 65, 36, 97, 43, 81]);

$prices = $prices->chunk(3);

$prices->toArray();
```

Retorno

```
[
    0 => [
        0 => 18,
        1 => 23,
        2 => 65
    ],
    1 => [
        3 => 36,
        4 => 97,
        5 => 43
    ],
    2 => [
        6 => 81
    ]
]
```
# dump()
> o método dump despeja os itens da coleção. É útil para depurar e encontrar o que há dentro da coleção em qualquer ponto do pipeline de coleta.
```php
$collection->whereIn('user_id', [1, 2])
    ->dump()
    ->where('user_id', 1);

map()

O método map é usado para percorrer a coleção completa. Ele aceita um retorno de chamada como argumento. valor e a chave é passada para o retorno de chamada. O retorno de chamada pode modificar os valores e retorná-los. Finalmente, uma nova instância de coleção de itens modificados é retornada.


$changed = $collection->map(function ($value, $key) {
$value['user_id'] += 1;
    return $value;
});

return $changed->all(); ``` Basicamente, ele incrementou user_id em um. ``` [ [ "user_id" => 2, "title" => "Helpers in Laravel", "content" => "Create custom helpers in Laravel", "category" => "php" ], [ "user_id" => 3, "title" => "Testing in Laravel", "content" => "Testing File Uploads in Laravel", "category" => "php" ], [ "user_id" => 4, "title" => "Telegram Bot", "content" => "Crypto Telegram Bot in Laravel", "category" => "php" ] ]; ``` # zip() > O método Zip anexa os valores da matriz especificada aos valores da coleção. Os valores são adicionados ao mesmo índice, o que significa que o primeiro valor da matriz será mesclado com o primeiro valor da coleção. Aqui, estou usando a matriz de coleta que criamos acima. Funciona da mesma maneira com coleções eloquentes também. ```php $zipped = $collection->zip([1, 2, 3]); $zipped->all();

> Então, é basicamente isso. Se a contagem da matriz for menor que a contagem de coleções, o laravel adicionará nulo no final dos elementos restantes da coleção. Além disso, se a contagem da matriz for maior que a contagem de coleções, o laravel adicionará um nulo aos elementos da coleção, seguido pelo valor subsequente da matriz.

# whereNotIn()

> Você pode usar o método whereNotIn para simplesmente filtrar a coleção por um valor-chave não contido na matriz especificada. É basicamente o oposto de whereIn. Além disso, esse método usa uma comparação livre == ao combinar valores. 
Vamos filtrar a coleção $ em que user_id não é 1 nem 2.

```php 
$collection->whereNotIn('user_id', [1, 2]); 

A instrução acima retornará apenas o último item da coleção $ criada acima. O primeiro argumento é a chave e o segundo argumento é uma matriz de valores. No caso de eloquente, o primeiro argumento será o nome da coluna e o segundo argumento será uma matriz de valores. # max() > O método max retorna o valor máximo de uma determinada chave. Você pode encontrar o máximo user_id chamando max. É normalmente usado para itens como preço ou qualquer outro número, mas para fins de demonstração, vamos usar user_id. Também pode ser usado com strings e, nesse caso, Z> a. ```php $collection->max('user_id');


A declaração acima retornará o user_id máximo que, no nosso caso, é 3.

pluck()

O método pluck retorna todos os valores para uma chave. É útil para extrair valores de uma coluna.

$title = $collection->pluck('title');
$title->all();
```
Resultado
```
[
  "Helpers in Laravel",
  "Testing in Laravel",
  "Telegram Bot"
]
```
> Ao trabalhar com eloquente, você pode passar um nome de coluna como argumento para extrair seus valores. O comando pluck também aceita um segundo argumento e, no caso de coleções eloquentes, pode ser outro nome de coluna. Isso resultará em uma coleção codificada pelos valores do segundo argumento.

```php
$title = $collection->pluck('user_id', 'title');
$title->all();

Resultado

[
"Helpers in Laravel" => 1,
"Testing in Laravel" => 2,
"Telegram Bot" => 3
]

each()

Each é um método simples para iterar sobre a coleção completa. Ele aceita um retorno de chamada com dois argumentos: item pelo qual está iterando e a chave. Chave é o índice baseado em 0.

$collection->each(function ($item, $key) {
    info($item['user_id']);
});

Acima, é simplesmente registrar o user_id de cada item. Ao fazer logon em coleções eloquentes, é possível acessar todos os valores da coluna como propriedades do item. Veja como podemos percorrer todas as postagens.

$posts = App\Post::all();
 
$posts->each(function ($item, $key) {
// Do something
});

Se você retornar falso do seu retorno de chamada, ele interromperá a iteração nos itens.

$collection->each(function ($item, $key) {
    // Tasks
    if ($key == 1) {
        return false;
    }
});

tap()

O método tap () permite que você toque na coleção a qualquer momento. Ele aceita um retorno de chamada e passa e passa a coleção para ele. Você pode fazer qualquer coisa com os itens sem alterar a própria coleção. Portanto, você pode usar o toque para acessar a coleção a qualquer momento sem alterar a coleção.

$collection->whereNotIn('user_id', 3)
    ->tap(function ($collection) {
        $collection = $collection->where('user_id', 1);
        info($collection->values());
    })
    ->all();
    
```
> No método de toque usado acima, modificamos a coleção e registramos o valor. Você pode fazer o que quiser com a coleção dentro da torneira. A resposta do comando acima é:

```
[
    [
        "user_id" => "1",
        "title" => "Helpers in Laravel",
        "content" => "Create custom helpers in Laravel",
        "category" => "php"
    ],
    [
        "user_id" => "2",
        "title" => "Testing in Laravel",
        "content" => "Testing File Uploads in Laravel",
        "category" => "php"
    ]
]
```
# pipe()

> O método pipe é muito semelhante ao método de tap, no sentido de que ambos são usados ​​dentro do pipeline de coleta. O método pipe passa a coleção para o retorno de chamada e retorna o resultado.

```php
$collection->pipe(function($collection) {
    return $collection->min('user_id');
});

A resposta do comando acima é 1. Se você retornar uma instância de coleção do retorno de chamada do canal, poderá encadear outros métodos também.

contains()

O método simplesmente verifica se a coleção contém um determinado valor. Isso só é verdade quando você passa um único argumento.


$contains = collect(['country' => 'USA', 'state' => 'NY']);
 
$contains->contains('USA');
// true

$contains->contains('UK'); // false ``` > Se você passar um par de chave / valor para o método contains, ele verificará se o par fornecido existe ou não. ```php $collection->contains('user_id', '1'); // true

$collection->contains('title', 'Not Found Title'); // false ``` > Você também pode passar um retorno de chamada como argumento para o método de retorno de chamada. O retorno de chamada será executado para todos os itens da coleção e, se algum deles passar no teste de verdade, retornará true ou false. ```php $collection->contains(function ($value, $key) { return strlen($value['title']) < 13; }); // true ``` > O retorno de chamada aceita o valor de dois argumentos do item de iteração atualmente e a chave. Aqui, estamos simplesmente verificando se o tamanho do título é menor que 13. No Telegram Bot, ele é 12, e retornou verdadeiro. # forget() > simplesmente remove o item da coleção. Você simplesmente passa uma chave e ela remove esse item da coleção. ```php $forget = collect(['country' => 'usa', 'state' => 'ny']);

$forget->forget('country')->all(); ``` - Retorno ``` [ "state" => "ny" ] ``` O forget não funciona em matrizes multidimensionais. # avg() > O método avg retorna o valor médio. Você simplesmente passa uma chave como argumento e o método avg retorna a média. Você também pode usar o método da média, que é basicamente um alias para avg. ```php $avg = collect([ ['shoes' => 10], ['shoes' => 35], ['shoes' => 7], ['shoes' => 68], ])->avg('shoes');


> O código acima retorna 30, que é a média dos quatro números. Se você não passar nenhuma chave para o método avg e todos os itens forem números, ele retornará o avg de todos os números. Se a chave não for passada como argumento e a coleção contiver pares chave / valor, o método avg retornará 0.
```php
$avg = collect([12, 32, 54, 92, 37]);
 
$avg->avg();

O código acima retorna 45,4, que é a média dos cinco números.

  • Você pode usar esses métodos de coleção de laravel para trabalhar com coleção em seus próprios projetos.