Tomemos una aventura en un tutorial de colecciones de Laravel. Después de haber usado el marco de Laravel durante algún tiempo, me he acostumbrado a trabajar con sus diversas características. Una de las cosas en las que he querido profundizar es el aspecto de Colecciones de Laravel. Estarás lidiando con colecciones de laravel todo el tiempo, y hasta este punto, tal vez seas como yo y descubras lo que necesitabas a medida que avanzaste. ¡No más! Ahora nos convertiremos en maestros profesionales de Laravel Collection al sumergirnos en profundidad, hacer doble clic, profundizar o cualquier otra frase de moda que le gustaría usar en Laravel Collections.

La clase de colección

Antes incluso de comenzar a ver todos los métodos que podemos usar, veamos el archivo de clase en sí. Podemos ver que tiene todas estas declaraciones de uso en la parte superior.

1
2
3
4
5
6
7
8
9
use Countable;
use ArrayAccess;
use ArrayIterator;
use CachingIterator;
use JsonSerializable;
use IteratorAggregate;
use InvalidArgumentException;
use Illuminate\Contracts\Support\Jsonable;
use Illuminate\Contracts\Support\Arrayable;

Entonces, ¿qué significan todos estos y de dónde vienen? Bueno, vamos a atacarlos uno por uno. Primero, tenemos use Countable;. Con PHP Storm, podemos usar la práctica herramienta "Ir a la declaración" para ver.

usar contable

Esto nos lleva SPL.phpy nos muestra la Countableinterfaz.

¡Muy genial! Podemos ver que la interfaz Contable es parte de la Biblioteca PHP estándar (SPL) . Al utilizar esta técnica, podemos descifrar todas estas declaraciones de uso.

También tenga en cuenta que la clase Collection vive en el espacio de nombres Illuminate \ Support . Genial, sacamos las cosas administrativas del camino y sabemos lo que significa.

Probar los ejemplos de Laravel

La documentación de Laravel es fantástica y la usaremos como guía para este tutorial de colecciones. Al leer los documentos, podemos ver que para crear una colección, podemos usar el collectayudante conveniente para hacerlo. Ahora que no soy tan bueno para aceptar que las cosas simplemente funcionan, cuando no sé cómo funcionan, incluso debo indagar en cómo funciona este ayudante. Si nos ponemos nuestra gorra de detective, podemos ver que viene directamente de este código aquí .

El helpers.phparchivo tiene una use Illuminate\Support\Collection;declaración en la parte superior, por lo que nuestra función auxiliar puede crear una nueva Collectionpara nosotros usando este fragmento.

1
2
3
4
5
6
7
8
9
10
11
12
if (! function_exists('collect')) {
    /**
     * Create a collection from the given value.
     *
     * @param  mixed  $value
     * @return \Illuminate\Support\Collection
     */
    function collect($value = null)
    {
        return new Collection($value);
    }
}

Nueva colección

Con nuestro nuevo conocimiento de esta conveniente función de ayuda, permítanos crear una Colección Laravel para divertirnos y obtener ganancias.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    $sites = collect([
        'http://google.com',
        'http://plus.google.com',
        'http://facebook.com',
        'http://twitter.com',
        'http://search.twitter.com',
        'http://apple.com'
    ]);
 
    dd($sites);
 
/*
Collection {#110 ▼
  #items: array:6 [▼
    0 => "http://google.com"
    1 => "http://plus.google.com"
    2 => "http://facebook.com"
    3 => "http://twitter.com"
    4 => "http://search.twitter.com"
    5 => "http://apple.com"
  ]
}
*/

Como puede ver, ahora tenemos una colección con la que podemos trabajar. Una de las primeras cosas que se explicarán en la documentación es cómo mapear cada elemento de la colección y aplicarle una función mientras se rechazan los valores que no especifican un criterio determinado. Usando este ejemplo, echemos un vistazo a nuestra propia colección de sitios. Cambiaremos el formato de todas las URL para incluir un prefijo www mientras eliminamos cualquier URL que contenga la palabra facebook. Vamos a intentarlo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
    $sites = collect([
        'http://google.com',
        'http://plus.google.com',
        'http://facebook.com',
        'http://twitter.com',
        'http://search.twitter.com',
        'http://apple.com'
    ])->map(function ($site) {
        return str_replace('http://', 'http://www.', $site);
    })->reject(function ($site) {
        return str_contains($site, 'facebook') == true;
    });
 
    dd($sites);
 
/*
Collection {#113 ▼
  #items: array:5 [▼
    0 => "http://www.google.com"
    1 => "http://www.plus.google.com"
    3 => "http://www.twitter.com"
    4 => "http://www.search.twitter.com"
    5 => "http://www.apple.com"
  ]
}
*/

¡Frio! Tenga en cuenta que en esta iteración, hacemos uso de la interfaz fluida. ¿Qué significa ser fluido? Todo lo que significa es que puede encadenar comandos para obtener el resultado deseado. Es como encadenar métodos en jQuery. Aplicamos dos métodos a la colección para lograr nuestro resultado deseado. mapa y rechazo . Dentro de lamapiteración, aplicamos lastr_replacefunción a cada elemento de la colección, eliminando http: // y reemplazándolo por http: // www. Durante larejectiteración usamos el método auxiliar de Laravel str_contains para filtrar cualquier elemento que contenga la palabra facebook. Tenga en cuenta que la expresión debe ser igual a verdadera para que el rejectmétodo elimine el elemento. Así que casi podemos leer esto como, si la cadena contiene facebook, entonces lo rechazamos. Podemos ver en la captura de pantalla anterior que obtuvimos el resultado deseado.

Los métodos de colección de Laravel

Con una comprensión básica de lo que es una colección de Laravel, veamos ahora todos los métodos disponibles uno por uno.

1. todos ()

La clase Collection tiene una propiedad protegida denominada $itemsque contiene una matriz. De esto se construye la Colección. El all()método simplemente devuelve esa propiedad. Esto es útil si desea cambiar una colección de Laravel en una matriz PHP nativa.

1
2
3
4
    public function all()
    {
        return $this->items;
    }

Al probar esto en nuestra propia pequeña colección, podemos ver que se nos devuelve la matriz en la que se basa la colección.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    $sites = collect([
        'http://google.com',
        'http://plus.google.com',
        'http://facebook.com',
        'http://twitter.com',
        'http://search.twitter.com',
        'http://apple.com'
    ]);
 
    $all = $sites->all();
 
    dd($all);
 
/*
array:6 [▼
  0 => "http://google.com"
  1 => "http://plus.google.com"
  2 => "http://facebook.com"
  3 => "http://twitter.com"
  4 => "http://search.twitter.com"
  5 => "http://apple.com"
]
*/

2. avg ()

El avgmétodo hace exactamente lo que crees que haría, calcula el promedio de una colección. Aquí está el código que lo impulsa.

1
2
3
4
5
6
    public function avg($key = null)
    {
        if ($count = $this->count()) {
            return $this->sum($key) / $count;
        }
    }

Podemos hacer uso de él en una colección estrictamente numérica como tal.

1
2
3
    collect(['1234', '546', '777'])->avg();
 
    //852.33333333333

También puede proporcionar una clave a la que aplicar el promedio. En el ejemplo de una matriz asociativa, necesitaría hacer esto.

1
2
3
4
5
6
7
8
9
    $avg = collect([
        ['size' => 'tall', 'price' => 2.50],
        ['size' => 'grande', 'price' => 3.45],
        ['size' => 'venti', 'price' => 4.75]
    ])->avg('price');
 
    dd($avg);
 
    // 3.5666666666667

La visita promedio de Starbucks le costará $ 3.56.

3. trozo ()

Nunca encontré mucho uso para chunk hasta que leí la documentación, que tiene un gran caso de uso. Como era de esperar, chunk toma un grupo de cosas y lo divide en grupos más pequeños. El caso de uso que menciona la documentación trata con una cuadrícula de Bootstrap, por ejemplo. Si alguna vez ha tenido una cuadrícula llena de elementos y se encuentra recorriendo un conjunto de resultados y luego verificando el valor de un iterador para determinar dónde terminar una fila, ¡este es para usted! De hecho, este es para mí, ¡ya que hago esto todo el tiempo! En lugar de preocuparse por esto, simplemente use chunk () en su lugar. Así es como funciona.

1
2
3
4
5
6
7
8
    public function chunk($size)
    {
        $chunks = [];
        foreach (array_chunk($this->items, $size, true) as $chunk) {
            $chunks[] = new static($chunk);
        }
        return new static($chunks);
    }

Tenga en cuenta el uso de la función PHP array_chunk () .

Probarlo por nosotros mismos produce estos resultados.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
    $chunk = collect([
        (object)['site' => 'google.com'],
        (object)['site' => 'facebook.com'],
        (object)['site' => 'yahoo.com'],
        (object)['site' => 'digg.com'],
        (object)['site' => 'twitter.com'],
        (object)['site' => 'moz.com']
 
    ])->chunk(2);
 
    dd($chunk);
 
/*
Collection {#120 ▼
  #items: array:3 [▼
    0 => Collection {#117 ▼
      #items: array:2 [▼
        0 => {#110 ▼
          +"site": "google.com"
        }
        1 => {#111 ▼
          +"site": "facebook.com"
        }
      ]
    }
    1 => Collection {#118 ▼
      #items: array:2 [▼
        2 => {#112 ▼
          +"site": "yahoo.com"
        }
        3 => {#113 ▼
          +"site": "digg.com"
        }
      ]
    }
    2 => Collection {#119 ▼
      #items: array:2 [▼
        4 => {#114 ▼
          +"site": "twitter.com"
        }
        5 => {#115 ▼
          +"site": "moz.com"
        }
      ]
    }
  ]
}
*/

Al recorrer los resultados fragmentados, tenga en cuenta que necesitará un foreach anidado ya que ahora tiene una colección de colecciones más pequeñas. Por lo tanto, debe recorrer cada fragmento y luego recorrer el contenido de cada fragmento individualmente.

1
2
3
4
5
6
7
8
9
10
11
12
    foreach ($chunk as $chunk) {
        foreach ($chunk as $chunk) {
            echo $chunk->site.'<br>';
        }
    }
 
    // google.com
    // facebook.com
    // yahoo.com
    // digg.com
    // twitter.com
    // moz.com

4. colapso ()

Este método hace uso de una llamada a un método estático como vemos aquí.

1
2
3
4
    public function collapse()
    {
        return new static(Arr::collapse($this->items));
    }

El código al que hace referencia está aquí.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    public static function collapse($array)
    {
        $results = [];
 
        foreach ($array as $values) {
            if ($values instanceof Collection) {
                $values = $values->all();
            }
 
            $results = array_merge($results, $values);
        }
 
        return $results;
    }

Tome nota especial de la función PHP array_merge () .

Aquí está nuestra pequeña prueba rápida del colapso.

1
2
3
4
5
    $collection = collect([
        ['color' => 'blue', 4, 2],
        ['x', 'y', 'color' => 'red', 'shape' => 'circle', 300],
        ['make' => 'Acura', 'type' => 'NSX']
    ]);

Antes del colapso.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
dd($collection);
 
/*
Collection {#110 ▼
  #items: array:3 [▼
    0 => array:3 [▼
      "color" => "blue"
      0 => 4
      1 => 2
    ]
    1 => array:5 [▼
      0 => "x"
      1 => "y"
      "color" => "red"
      "shape" => "circle"
      2 => 300
    ]
    2 => array:2 [▼
      "make" => "Acura"
      "type" => "NSX"
    ]
  ]
}
*/

Después del colapso.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
dd($collection->collapse());
*/
Collection {#111 ▼
  #items: array:9 [▼
    "color" => "red"
    0 => 4
    1 => 2
    2 => "x"
    3 => "y"
    "shape" => "circle"
    4 => 300
    "make" => "Acura"
    "type" => "NSX"
  ]
}
*/

5. contiene ()

¿Cuántas veces necesita verificar si una matriz contiene un valor? Todo el tiempo, ¿verdad? El práctico método contains en Laravel Collections hace que sea fácil de hacer cuando se trabaja con una matriz que ha sido recopilada.

El contiene código.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    public function contains($key, $value = null)
    {
        if (func_num_args() == 2) {
            return $this->contains(function ($k, $item) use ($key, $value) {
                return data_get($item, $key) == $value;
            });
        }
 
        if ($this->useAsCallable($key)) {
            return ! is_null($this->first($key));
        }
 
        return in_array($key, $this->items);
    }

En primer lugar, podemos ver que el código hace uso del PHP nativo func_get_args () . El método data_get () es un método auxiliar personalizado en el marco de trabajo illuminate. Finalmente, podemos ver que in_array () se pone en uso. Visite cada uno de los enlaces anteriores uno por uno para asegurarse de que comprende cada paso del proceso.

Probar contiene () con la siguiente colección.

1
2
3
4
5
6
7
8
9
10
11
    $collection = collect([
        'color' => 'blue',
        4,
        2,
        'x',
        'y',
        'shape' => 'circle',
        300,
        'make' => 'Acura',
        'type' => 'NSX'
    ]);

1
2
dd($collection->contains('color'));
//  false

Parece que el método contiene solo verifica el valor, no la clave de la colección.

1
2
dd($collection->contains('color', ''));
// true

Al pasar una cadena vacía como segundo parámetro, puede verificar la existencia de una clave específica.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    $collection = collect([
        [
            'color' => 'blue',
            4,
            2,
            'xray',
            'y',
            'shape' => 'circle',
            300,
            'make' => 'Acura',
            'type' => 'NSX'
        ]
    ]);
    
    dd($collection->contains('make', 'Acura'));
    // true

Puede pasar dos parámetros de manera sensible a mayúsculas y minúsculas para verificar la existencia de un par clave-valor. Tenga en cuenta que esto solo se aplica a las colecciones anidadas, por lo que el fragmento anterior funciona, pero el fragmento siguiente no.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    $collection = collect([
        'color' => 'blue',
        4,
        2,
        'xray',
        'y',
        'shape' => 'circle',
        300,
        'make' => 'Acura',
        'type' => 'NSX'
    ]);
 
    dd($collection->contains('make', 'Acura'));
    // false

Para ser un poco más granular, puede hacer uso de su propia función de devolución de llamada. Echale un vistazo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    $collection = collect([
        'color' => 'blue',
        4,
        2,
        'xray',
        'y',
        'shape' => 'circle',
        300,
        'make' => 'Acura',
        'type' => 'NSX'
    ]);
 
    $result = $collection->contains(function ($key, $value){
        return ($key == 'hiphop' or $value == 'NSX');
    });
 
    dd($result);
    // true

No hay ninguna clave con el nombre de hiphop en nuestra colección. Sin embargo, tenemos un valor NSX en la colección, de ahí el retorno de verdad. Esto también nos permite buscar un par clave-valor en una colección plana como esta.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    $collection = collect([
        'color' => 'blue',
        4,
        2,
        'xray',
        'y',
        'shape' => 'circle',
        300,
        'make' => 'Acura',
        'type' => 'NSX'
    ]);
 
    $result = $collection->contains(function ($key, $value){
        return ($key == 'color' and $value == 'blue');
    });
 
    dd($result);
    // true

6. contar ()

Simple pero útil, contar hace exactamente lo que dice, cuenta la cantidad de elementos de la colección. ¿Como funciona? Como así.

1
2
3
4
    public function count()
    {
        return count($this->items);
    }

El método usa la función nativa de PHP count () . Entonces, en la clase Colección Laravel, simplemente miramos la propiedad $ items y devolvemos la cantidad de elementos que contiene. Observa nuestro ejemplo.

1
2
3
4
5
6
7
8
9
10
    $collection = collect([
        'color' => 'blue',
        'size' => 'extra large',
        'comedian' => 'Seinfeld',
        'search engine' => 'google'
    ]);
 
 
    dd($collection->count());
    // 4

7. diff ()

Este método hace uso de array_diff () para comparar matrices. Este es el código que lo hace funcionar.

1
2
3
4
    public function diff($items)
    {
        return new static(array_diff($this->items, $this->getArrayableItems($items)));
    }

Por ejemplo, imagine que un candidato tiene una variedad de empresas para las que le gustaría trabajar. Ella necesita comparar esto con una variedad de empresas que actualmente no están contratando, luego tratar de entrevistar solo a aquellas que están contratando. ¿Cómo podría hacer esto?

1
2
3
4
5
6
7
    $want = collect(['Apple', 'Google', 'Twitter', 'Cisco', 'Dell', 'HP']);
    $nothiring = collect(['Apple', 'Google']);
 
    $interview = $want->diff($nothiring);
 
    dd($interview);
    // Twitter, Cisco, Dell, HP

8. cada uno ()

Este método le permite aplicar una devolución de llamada a cada elemento de la colección y se alimenta con este código.

1
2
3
4
5
6
7
8
9
10
    public function each(callable $callback)
    {
        foreach ($this->items as $key => $item) {
            if ($callback($item, $key) === false) {
                break;
            }
        }
 
        return $this;
    }

Por ejemplo, tendremos una colección de números. Siempre que el número sea menor que 5, usaremos una devolución de llamada para cuadrarlo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
 
    $collection->each(function ($value) {
        if ($value > 5) {
            return false;
        }
        echo $value * $value . '<br>';
    });
 
    //  1
    //  4
    //  9
    //  16
    //  25

El mismo resultado con un foreach se llevaría a cabo así:

1
2
3
4
5
6
7
    $collection = collect([1, 2, 3, 4, 5, 6, 7, 8, 9]);
 
    foreach ($collection as $collection) {
        if ($collection < 6) {
            echo $collection * $collection . '<br>';
        }
    }

Ya ve, each()solo agregue un poco de azúcar para que pueda codificar en un estilo más moderno si lo prefiere. Elige tu veneno.

9. cada ()

Este método interesante se asoma a su colección y crea una nueva colección en cada enésimo elemento que especifique. La fuente está aquí.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    public function every($step, $offset = 0)
    {
        $new = [];
 
        $position = 0;
 
        foreach ($this->items as $key => $item) {
            if ($position % $step === $offset) {
                $new[] = $item;
            }
 
            $position++;
        }
 
        return new static($new);
    }

A medida que probamos todos los métodos, podemos ver cómo funciona.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
    $collection = collect([
        ['red', 'green', 'blue'],
        ['apple', 'orage', 'lemon'],
        ['yaba', 'daba', 'doo'],
        ['hip', 'hop', 'hooray'],
        ['meat', 'potatoes', 'gravy'],
        ['apple pie', 'pumpkin latte', 'apple cider'],
    ]);
 
    dd($collection->every(2));
 
/*
Collection {#111 ▼
  #items: array:3 [▼
    0 => array:3 [▼
      0 => "red"
      1 => "green"
      2 => "blue"
    ]
    1 => array:3 [▼
      0 => "yaba"
      1 => "daba"
      2 => "doo"
    ]
    2 => array:3 [▼
      0 => "meat"
      1 => "potatoes"
      2 => "gravy"
    ]
  ]
}
*/

Al pasar un desplazamiento, podemos cambiar el punto de partida para contar.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
dd($collection->every(2, 1));
/*
Collection {#111 ▼
  #items: array:3 [▼
    0 => array:3 [▼
      0 => "apple"
      1 => "orage"
      2 => "lemon"
    ]
    1 => array:3 [▼
      0 => "hip"

Breaking

Post Top Ad

martes, 29 de septiembre de 2020

Tutorial de colecciones de Laravel