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"
      1 => "hop"
      2 => "hooray"
    ]
    2 => array:3 [▼
      0 => "apple pie"
      1 => "pumpkin latte"
      2 => "apple cider"
    ]
  ]
}
*/

10. filtro ()

El método de filtro es otro que le permite aplicar una devolución de llamada a la colección, reteniendo solo los elementos que pasan una prueba de su elección. El código que lo hace posible está aquí.

1
2
3
4
5
6
7
8
    public function filter(callable $callback = null)
    {
        if ($callback) {
            return new static(array_filter($this->items, $callback));
        }
 
        return new static(array_filter($this->items));
    }

Como podemos ver, hace uso de la función nativa de PHP array_filter () . Tomar el método de filtro para una prueba de manejo nos da 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
    $collection = collect([
        ['red', 'green', 'blue'],
        ['apple', 'orange', 'lemon'],
        ['yaba', 'daba', 'doo'],
        ['hip', 'hop', 'hooray'],
        ['meat', 'potatoes', 'gravy'],
        ['apple pie', 'pumpkin latte', 'apple cider'],
    ]);
 
    $filterized = $collection->filter(function ($item) {
        return str_contains('lemon', $item);
    });
 
    dd($filterized);
 
/*
Collection {#112 ▼
  #items: array:1 [▼
    1 => array:3 [▼
      0 => "apple"
      1 => "orange"
      2 => "lemon"
    ]
  ]
}
*/

Aquí, básicamente decimos, solo devuelve los elementos que contienen la cadena de 'limón', y de hecho esto es exactamente lo que obtenemos.

11. primero ()

El método first () devuelve el primer elemento de la colección. El código fuente de este método está aquí.

1
2
3
4
5
6
7
    public function first(callable $callback = null, $default = null)
    {
        if (is_null($callback)) {
            return count($this->items) > 0 ? reset($this->items) : null;
        }
        return Arr::first($this->items, $callback, $default);
    }

Un ejemplo de first () en acción.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    $collection = collect([
        ['sunshine', 'blue sky', 'blue water'],
        ['apple pie', 'yellow', 'black roof'],
        [1,2,3],
        'random stuff',
        'not a number',
        ['apple crisp', 'jackolantern'],
    ]);
 
    $first = $collection->first();
 
    dd($first);
 
*/
array:3 [▼
  0 => "sunshine"
  1 => "blue sky"
  2 => "blue water"
]
*/

Como podemos ver en este ejemplo, se nos devuelve el primer elemento de la colección que es una matriz. Este método también le permite especificar una condición o prueba de verdad para que pueda devolver el primer elemento que pasa esa prueba. En el siguiente fragmento, comprobaremos si un elemento es una cadena y, de ser así, lo devolveremos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    $collection = collect([
        ['sunshine', 'blue sky', 'blue water'],
        ['apple pie', 'yellow', 'black roof'],
        [1, 2, 3],
        'random stuff',
        'not a number',
        ['apple crisp', 'jackolantern'],
    ]);
 
    $first = $collection->first(function ($key, $value) {
        return is_string($value);
    });
 
    dd($first);
 
    // random stuff

12. aplanar ()

Si tiene una matriz multidimensional muy anidada, puede usar flatten () para convertirla en una matriz de una sola dimensión. Considere esta colección.

1
2
3
4
5
    $collection = collect([
        'mobile' => 'iPhone',
        'grub' => ['restaurant' => 'Chipoltle', 'meal' => 'burrito'],
        ['editor' => ['vendor' => 'jetbrains', 'ide' => 'phpstorm']]
    ]);

Antes de aplanar ()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
dd($collection);
 
/*
Collection {#110 ▼
  #items: array:3 [▼
    "mobile" => "iPhone"
    "grub" => array:2 [▼
      "restaurant" => "Chipoltle"
      "meal" => "burrito"
    ]
    0 => array:1 [▼
      "editor" => array:2 [▼
        "vendor" => "jetbrains"
        "ide" => "phpstorm"
      ]
    ]
  ]
}
*/

Después de aplanar ()

1
2
3
4
5
6
7
8
9
10
11
12
13
dd($collection->flatten());
 
/*
Collection {#111 ▼
  #items: array:5 [▼
    0 => "iPhone"
    1 => "Chipoltle"
    2 => "burrito"
    3 => "jetbrains"
    4 => "phpstorm"
  ]
}
*/

Aquí está el código, que hace uso de una llamada a un método estático.

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

1
2
3
4
5
6
7
8
    public static function flatten($array)
    {
        $return = [];
 
        array_walk_recursive($array, function ($x) use (&$return) { $return[] = $x; });
 
        return $return;
    }

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

13. voltear ()

flip () se usa para tomar las claves de una colección e intercambiarlas con sus valores asociados. Veamos qué sucede si intentamos cambiar nuestra colección anterior.

1
2
3
4
5
6
7
8
9
    $collection = collect([
        'mobile' => 'iPhone',
        'grub' => ['restaurant' => 'Chipoltle', 'meal' => 'burrito'],
        ['editor' => ['vendor' => 'jetbrains', 'ide' => 'phpstorm']]
    ]);
 
    dd($collection->flip());
 
    // array_flip(): Can only flip STRING and INTEGER values!

Vemos que esto solo puede operar en valores enteros o de cadena, así que demos una oportunidad a ambos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    $collection = collect([
        'mobile' => 'iPhone',
        'integer' => 10,
        'string' => 'all day',
        'another integer' => 20
    ]);
 
    dd($collection->flip());
 
/*
Collection {#111 ▼
  #items: array:4 [▼
    "iPhone" => "mobile"
    10 => "integer"
    "all day" => "string"
    20 => "another integer"
  ]
}
*/

Ahora estamos en el negocio, está funcionando como un campeón.

Este método, por supuesto, hace uso de array_flip () y el código que nos muestra esto está aquí.

1
2
3
4
    public function flip()
    {
        return new static(array_flip($this->items));
    }

14. olvidar ()

Con este método puedes Fuhgettaboutit, pronunciado (Fuh-Get-About-It). Pasas la clave del elemento a eliminar y lo hace.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    $collection = collect([
        'mobile' => 'iPhone',
        'integer' => 10,
        'string' => 'all day',
        'another integer' => 20
    ]);
 
    dd($collection->forget('string'));
 
/*
Collection {#110 ▼
  #items: array:3 [▼
    "mobile" => "iPhone"
    "integer" => 10
    "another integer" => 20
  ]
}
*/

Examinar cómo funciona este método nos muestra este código aquí.

1
2
3
4
5
6
7
8
    public function forget($keys)
    {
        foreach ((array) $keys as $key) {
            $this->offsetUnset($key);
        }
 
        return $this;
    }

Que hace uso de unset como vemos aquí.

1
2
3
4
    public function offsetUnset($key)
    {
        unset($this->items[$key]);
    }

15. forPage ()

Este método interesante hace uso de array_slice () como podemos ver haciendo un trabajo de detective en el archivo de clase Collection a continuación.

1
2
3
4
    public function forPage($page, $perPage)
    {
        return $this->slice(($page - 1) * $perPage, $perPage);
    }

1
2
3
4
    public function slice($offset, $length = null, $preserveKeys = false)
    {
        return new static(array_slice($this->items, $offset, $length, $preserveKeys));
    }

Lo que hace es muy bueno. En un conjunto de resultados grande que puede paginarse, puede recuperar los elementos de cualquier página de los resultados. Supongamos que tiene 5 páginas de 5 elementos cada una. Puede especificar que solo desea los resultados que aparecerían en la página 3. Veamos cómo hacerlo.

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
49
50
51
    $collection = collect([
        ['url' => 'google.com'],
        ['url' => 'facebook.com'],
        ['url' => 'amazon.com'],
        ['url' => 'youtube.com'],
        ['url' => 'yahoo.com'],
        ['url' => 'wikipedia.org'],
        ['url' => 'ebay.com'],
        ['url' => 'twitter.com'],
        ['url' => 'craigslist.com'],
        ['url' => 'reddit.com'],
        ['url' => 'netflix.com'],
        ['url' => 'linkedin.com'],
        ['url' => 'bing.com'],
        ['url' => 'pinterest.com'],
        ['url' => 'apple.com'],
        ['url' => 'instagram.com'],
        ['url' => 'msn.com'],
        ['url' => 'walmart.com'],
        ['url' => 'yelp.com'],
        ['url' => 'weather.com'],
        ['url' => 'zillow.com'],
        ['url' => 'wordpress.com'],
        ['url' => 'target.com'],
        ['url' => 'buzzfeed.com'],
        ['url' => 'microsoft.com'],
    ]);
 
    dd($collection->forPage(3, 5));
 
/*
Collection {#111 ▼
  #items: array:5 [▼
    10 => array:1 [▼
      "url" => "netflix.com"
    ]
    11 => array:1 [▼
      "url" => "linkedin.com"
    ]
    12 => array:1 [▼
      "url" => "bing.com"
    ]
    13 => array:1 [▼
      "url" => "pinterest.com"
    ]
    14 => array:1 [▼
      "url" => "apple.com"
    ]
  ]
}
*/

¡Muy genial!

16. obtener ()

Este es uno de esos métodos que ha estado usando todo este tiempo sin siquiera pensarlo. get () simplemente obtiene el elemento que especifica por clave y devuelve nulo si la clave no está allí. Se alimenta a través del siguiente código fuente y hace uso de la función nativa PHP array_key_exists () .

1
2
3
4
5
6
7
8
    public function get($key, $default = null)
    {
        if ($this->offsetExists($key)) {
            return $this->items[$key];
        }
 
        return value($default);
    }

1
2
3
4
    public function offsetExists($key)
    {
        return array_key_exists($key, $this->items);
    }

Considere el ejemplo anterior donde teníamos una lista de 25 URL. La colección constaba de una matriz o matrices. Cada matriz interna usa 'url' como clave, por lo que no podemos hacerlo. Sin embargo, podemos proporcionar un número entero, y eso hará que el elemento se indexe a ese valor. Intentemos obtener apple.com de nuestro ejemplo anterior.

1
2
3
4
5
6
7
dd($collection->get(14));
 
/*
array:1 [▼
  "url" => "apple.com"
]
*/

Bingo: funciona. Un ejemplo más simple podría ser algo como esto.

1
2
3
4
5
6
7
8
9
10
    $collection = collect([
        'mobile' => 'iPhone',
        'integer' => 10,
        'string' => 'all day',
        'another integer' => 20
    ]);
 
    dd($collection->get('mobile'));
 
    // iPhone

17. groupBy ()

Puede pasar una cadena o una devolución de llamada al método groupBy, y le devolverá los resultados, agrupados por ese valor. Probemos esto usando el enfoque de cuerdas. Reconfiguraremos nuestra lista de URL y cambiaremos cada clave para que cada URL pertenezca a un cierto tipo de categoría. Podemos usar el método groupBy para obtener por categoría.

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 $collection = collect([
        ['search' => 'google.com'],
        ['social' => 'facebook.com'],
        ['shopping' => 'amazon.com'],
        ['entertainment' => 'youtube.com'],
        ['entertainment' => 'yahoo.com'],
        ['info' => 'wikipedia.org'],
        ['shopping' => 'ebay.com'],
        ['social' => 'twitter.com'],
        ['info' => 'craigslist.com'],
        ['entertainment' => 'reddit.com'],
        ['entertainment' => 'netflix.com'],
        ['career' => 'linkedin.com'],
        ['search' => 'bing.com'],
        ['entertainment' => 'pinterest.com'],
        ['shopping' => 'apple.com'],
        ['social' => 'instagram.com'],
        ['info' => 'msn.com'],
        ['shopping' => 'walmart.com'],
        ['info' => 'yelp.com'],
        ['info' => 'weather.com'],
        ['shopping' => 'zillow.com'],
        ['blogging' => 'wordpress.com'],
        ['shopping' => 'target.com'],
        ['entertainment' => 'buzzfeed.com'],
        ['software' => 'microsoft.com'],
    ]);
 
    dd($collection->groupBy('entertainment'));
 
/*
Collection {#119 ▼
  #items: array:7 [▼
    "" => Collection {#112 ▼
      #items: array:19 [▼
        0 => array:1 [▼
          "search" => "google.com"
        ]
        1 => array:1 [▼
          "social" => "facebook.com"
        ]
        2 => array:1 [▼
          "shopping" => "amazon.com"
        ]
        3 => array:1 [▼
          "info" => "wikipedia.org"
        ]
        4 => array:1 [▼
          "shopping" => "ebay.com"
        ]
        5 => array:1 [▼
          "social" => "twitter.com"
        ]
        6 => array:1 [▼
          "info" => "craigslist.com"
        ]
        7 => array:1 [▼
          "career" => "linkedin.com"
        ]
        8 => array:1 [▼
          "search" => "bing.com"
        ]
        9 => array:1 [▼
          "shopping" => "apple.com"
        ]
        10 => array:1 [▼
          "social" => "instagram.com"
        ]
        11 => array:1 [▼
          "info" => "msn.com"
        ]
        12 => array:1 [▼
          "shopping" => "walmart.com"
        ]
        13 => array:1 [▼
          "info" => "yelp.com"
        ]
        14 => array:1 [▼
          "info" => "weather.com"
        ]
        15 => array:1 [▼
          "shopping" => "zillow.com"
        ]
        16 => array:1 [▼
          "blogging" => "wordpress.com"
        ]
        17 => array:1 [▼
          "shopping" => "target.com"
        ]
        18 => array:1 [▼
          "software" => "microsoft.com"
        ]
      ]
    }
    "youtube.com" => Collection {#113 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "entertainment" => "youtube.com"
        ]
      ]
    }
    "yahoo.com" => Collection {#114 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "entertainment" => "yahoo.com"
        ]
      ]
    }
    "reddit.com" => Collection {#115 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "entertainment" => "reddit.com"
        ]
      ]
    }
    "netflix.com" => Collection {#116 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "entertainment" => "netflix.com"
        ]
      ]
    }
    "pinterest.com" => Collection {#117 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "entertainment" => "pinterest.com"
        ]
      ]
    }
    "buzzfeed.com" => Collection {#118 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "entertainment" => "buzzfeed.com"
        ]
      ]
    }
  ]
}
*/

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
dd($collection->groupBy('shopping'));
 
/*
Collection {#119 ▼
  #items: array:7 [▼
    "" => Collection {#112 ▼
      #items: array:19 [▼
        0 => array:1 [▼
          "search" => "google.com"
        ]
        1 => array:1 [▼
          "social" => "facebook.com"
        ]
        2 => array:1 [▼
          "entertainment" => "youtube.com"
        ]
        3 => array:1 [▼
          "entertainment" => "yahoo.com"
        ]
        4 => array:1 [▼
          "info" => "wikipedia.org"
        ]
        5 => array:1 [▼
          "social" => "twitter.com"
        ]
        6 => array:1 [▼
          "info" => "craigslist.com"
        ]
        7 => array:1 [▼
          "entertainment" => "reddit.com"
        ]
        8 => array:1 [▼
          "entertainment" => "netflix.com"
        ]
        9 => array:1 [▼
          "career" => "linkedin.com"
        ]
        10 => array:1 [▼
          "search" => "bing.com"
        ]
        11 => array:1 [▼
          "entertainment" => "pinterest.com"
        ]
        12 => array:1 [▼
          "social" => "instagram.com"
        ]
        13 => array:1 [▼
          "info" => "msn.com"
        ]
        14 => array:1 [▼
          "info" => "yelp.com"
        ]
        15 => array:1 [▼
          "info" => "weather.com"
        ]
        16 => array:1 [▼
          "blogging" => "wordpress.com"
        ]
        17 => array:1 [▼
          "entertainment" => "buzzfeed.com"
        ]
        18 => array:1 [▼
          "software" => "microsoft.com"
        ]
      ]
    }
    "amazon.com" => Collection {#113 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "shopping" => "amazon.com"
        ]
      ]
    }
    "ebay.com" => Collection {#114 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "shopping" => "ebay.com"
        ]
      ]
    }
    "apple.com" => Collection {#115 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "shopping" => "apple.com"
        ]
      ]
    }
    "walmart.com" => Collection {#116 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "shopping" => "walmart.com"
        ]
      ]
    }
    "zillow.com" => Collection {#117 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "shopping" => "zillow.com"
        ]
      ]
    }
    "target.com" => Collection {#118 ▼
      #items: array:1 [▼
        0 => array:1 [▼
          "shopping" => "target.com"
        ]
      ]
    }
  ]
}
*/

Siempre encontré que las operaciones groupBy type eran un poco complicadas y difíciles de predecir. El código fuente muestra que se trata de una operación un poco más compleja.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    public function groupBy($groupBy, $preserveKeys = false)
    {
        $groupBy = $this->valueRetriever($groupBy);
 
        $results = [];
 
        foreach ($this->items as $key => $value) {
            $groupKey = $groupBy($value, $key);
 
            if (! array_key_exists($groupKey, $results)) {
                $results[$groupKey] = new static;
            }
 
            $results[$groupKey]->offsetSet($preserveKeys ? $key : null, $value);
        }
 
        return new static($results);
    }

18. tiene ()

Ahora tenemos uno simple siguiendo el ejemplo más complejo de arriba. ¿Necesitas comprobar si existe una clave en tu colección? Simple, solo usa has ().

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    $collection = collect([
        'search' => 'google.com',
        'social' => 'facebook.com',
        'shopping' => 'amazon.com',
        'entertainment' => 'youtube.com',
        'info' => 'wikipedia.org',
        'career' => 'linkedin.com',
        'blogging' => 'wordpress.com',
        'software' => 'microsoft.com'
    ]);
 
    dd($collection->has('software'));
    
    // true

La fuente nos muestra cómo funciona esto.

1
2
3
4
    public function has($key)
    {
        return $this->offsetExists($key);
    }

1
2
3
4
    public function offsetExists($key)
    {
        return array_key_exists($key, $this->items);
    }

19. implosión ()

Probablemente esté acostumbrado a tomar una matriz en PHP nativo e implementarla en una lista o línea de elementos separados por algún carácter aleatorio o grupo de caracteres. Puedes hacer lo mismo con tus colecciones con este método. Veamos un ejemplo.

1
2
3
4
5
6
7
8
9
10
    $collection = collect([
        ['weather' => 'sunshine', 'activity' => 'swimming'],
        ['weather' => 'cloudy', 'activity' => 'working'],
        ['weather' => 'snow', 'activity' => 'skiing'],
        ['weather' => 'rain', 'activity' => 'coding'],
    ]);
 
    dd($collection->implode('activity', ' **** '));
 
    // swimming **** working **** skiing **** coding

Funciona tal como cree que lo haría, haciendo uso del PHP implode () nativo .

1
2
3
4
5
6
7
8
9
10
    public function implode($value, $glue = null)
    {
        $first = $this->first();
 
        if (is_array($first) || is_object($first)) {
            return implode($glue, $this->pluck($value)->all());
        }
 
        return implode($value, $this->items);
    }

20. intersecar ()

Este método hace uso de array_intersect () como podemos ver aquí en la fuente que calcula la intersección de matrices.

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

También podemos calcular la intersección de colecciones, veamos un ejemplo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    $collection1 = collect([1, 2, 3, 4, 5, 6]);
 
    $collection2 = collect([5, 6, 7, 8, 9, 10]);
 
    dd($collection1->intersect($collection2));
 
/*
Collection {#112 ▼
  #items: array:2 [▼
    4 => 5
    5 => 6
  ]
}
*/

21. está vacío ()

Muchas veces, una colección se pasa a una vista y no desea intentar recorrerla si está vacía. Este práctico método nos permite saber de inmediato si una colección tiene o no algo dentro. Vamos a ver cómo funciona.

1
2
3
4
5
6
7
8
9
    $collection1 = collect([1, 2, 3, 4, 5, 6]);
 
    $collection2 = collect([]);
 
    dd($collection1->isEmpty());
    // false
    
    dd($collection2->isEmpty());
    // true

La fuente nos muestra cómo hace uso de la función empty () de PHP .

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

22. keyBy ()

Al observar el código fuente de este método, podemos ver que hace uso del método valueRetriever (), así que echemos un vistazo a eso.

1
2
3
4
5
6
7
8
9
10
11
12
    public function keyBy($keyBy)
    {
        $keyBy = $this->valueRetriever($keyBy);
 
        $results = [];
 
        foreach ($this->items as $item) {
            $results[$keyBy($item)] = $item;
        }
 
        return new static($results);
    }

1
2
3
4
5
6
7
8
9
10
    protected function valueRetriever($value)
    {
        if ($this->useAsCallable($value)) {
            return $value;
        }
 
        return function ($item) use ($value) {
            return data_get($item, $value);
        };
    }

Una vez más vemos esa referencia al método data_get (), y es un poco extraño, así que inspeccionémoslo.

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
    function data_get($target, $key, $default = null)
    {
        if (is_null($key)) {
            return $target;
        }
 
        $key = is_array($key) ? $key : explode('.', $key);
 
        foreach ($key as $segment) {
            if (is_array($target)) {
                if (! array_key_exists($segment, $target)) {
                    return value($default);
                }
 
                $target = $target[$segment];
            } elseif ($target instanceof ArrayAccess) {
                if (! isset($target[$segment])) {
                    return value($default);
                }
 
                $target = $target[$segment];
            } elseif (is_object($target)) {
                if (! isset($target->{$segment})) {
                    return value($default);
                }
 
                $target = $target->{$segment};
            } else {
                return value($default);
            }
        }
 
        return $target;
    }

Este método parece ser uno de los caballos de batalla de la clase Collection y, como podemos ver, hace uso de is_null () , is_array () , array_key_exists () , isset () e is_object () entre otros.

Un ejemplo de cómo funciona keyBy () muestra que puede establecer las claves de la colección mediante la clave proporcionada a keyBy (). Observar.

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
    $collection = collect([
        ['url' => 'google.com'],
        ['url' => 'facebook.com'],
        ['url' => 'amazon.com'],
        ['url' => 'youtube.com'],
        ['url' => 'yahoo.com'],
        ['url' => 'wikipedia.org'],
        ['url' => 'ebay.com'],
        ['url' => 'twitter.com'],
        ['url' => 'craigslist.com'],
        ['url' => 'reddit.com'],
        ['url' => 'netflix.com'],
        ['url' => 'linkedin.com'],
        ['url' => 'bing.com'],
        ['url' => 'pinterest.com'],
        ['url' => 'apple.com'],
        ['url' => 'instagram.com'],
        ['url' => 'msn.com'],
        ['url' => 'walmart.com'],
        ['url' => 'yelp.com'],
        ['url' => 'weather.com'],
        ['url' => 'zillow.com'],
        ['url' => 'wordpress.com'],
        ['url' => 'target.com'],
        ['url' => 'buzzfeed.com'],
        ['url' => 'microsoft.com'],
    ]);
 
    dd($collection->keyBy('url'));
 
/*
Collection {#112 ▼
  #items: array:25 [▼
    "google.com" => array:1 [▼
      "url" => "google.com"
    ]
    "facebook.com" => array:1 [▼
      "url" => "facebook.com"
    ]
    "amazon.com" => array:1 [▼
      "url" => "amazon.com"
    ]
    "youtube.com" => array:1 [▼
      "url" => "youtube.com"
    ]
    "yahoo.com" => array:1 [▼
      "url" => "yahoo.com"
    ]
    "wikipedia.org" => array:1 [▼
      "url" => "wikipedia.org"
    ]
    "ebay.com" => array:1 [▼
      "url" => "ebay.com"
    ]
    "twitter.com" => array:1 [▼
      "url" => "twitter.com"
    ]
    "craigslist.com" => array:1 [▼
      "url" => "craigslist.com"
    ]
    "reddit.com" => array:1 [▼
      "url" => "reddit.com"
    ]
    "netflix.com" => array:1 [▼
      "url" => "netflix.com"
    ]
    "linkedin.com" => array:1 [▼
      "url" => "linkedin.com"
    ]
    "bing.com" => array:1 [▼
      "url" => "bing.com"
    ]
    "pinterest.com" => array:1 [▼
      "url" => "pinterest.com"
    ]
    "apple.com" => array:1 [▼
      "url" => "apple.com"
    ]
    "instagram.com" => array:1 [▼
      "url" => "instagram.com"
    ]
    "msn.com" => array:1 [▼
      "url" => "msn.com"
    ]
    "walmart.com" => array:1 [▼
      "url" => "walmart.com"
    ]
    "yelp.com" => array:1 [▼
      "url" => "yelp.com"
    ]
    "weather.com" => array:1 [▼
      "url" => "weather.com"
    ]
    "zillow.com" => array:1 [▼
      "url" => "zillow.com"
    ]
    "wordpress.com" => array:1 [▼
      "url" => "wordpress.com"
    ]
    "target.com" => array:1 [▼
      "url" => "target.com"
    ]
    "buzzfeed.com" => array:1 [▼
      "url" => "buzzfeed.com"
    ]
    "microsoft.com" => array:1 [▼
      "url" => "microsoft.com"
    ]
  ]
}
*/

23. llaves ()

Este práctico método le brinda la posibilidad de buscar solo las claves de la colección. Probémoslo en una de nuestras colecciones de tipos mixtos.

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
    $collection = collect([
        ['google' => 'alphabet', 4, 2],
        'four' => 4,
        1234,
        'name' => 'Jim',
        ['xray', 'redsox', 'color' => 'green', 'shape' => 'perfect circle', 500],
        ['make' => 'Acura', 'type' => 'NSX'],
        'weather' => 'sunny',
        'play' => 'videogames',
        'object' => (object)['soup' => 'french onion']
    ]);
 
    dd($collection->keys());
 
/*
Collection {#112 ▼
  #items: array:9 [▼
    0 => 0
    1 => "four"
    2 => 1
    3 => "name"
    4 => 2
    5 => 3
    6 => "weather"
    7 => "play"
    8 => "object"
  ]
}
*/

Una inspección revela una llamada a array_keys () .

1
2
3
4
    public function keys()
    {
        return new static(array_keys($this->items));
    }

24. último ()

Si desea acceder al último elemento de la colección, puede utilizar el método last (), que tiene el nombre adecuado. Algunos ejemplos están en orden. Primero no pasaremos ningún argumento, que simplemente captura el último elemento de la colección sin importar qué. El segundo ejemplo usará una devolución de llamada para encontrar el primer elemento comenzando desde el final de la colección que coincide con una prueba determinada.

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
    $collection = collect([
        ['url' => 'google.com'],
        ['url' => 'facebook.com'],
        ['url' => 'amazon.com'],
        ['url' => 'youtube.com'],
        ['url' => 'yahoo.com'],
        ['url' => 'wikipedia.org'],
        ['url' => 'ebay.com'],
        ['url' => 'twitter.com'],
        ['url' => 'craigslist.com'],
        ['url' => 'reddit.com'],
        ['url' => 'netflix.com'],
        ['url' => 'linkedin.com'],
        ['url' => 'bing.com'],
        ['url' => 'pinterest.com'],
        ['url' => 'apple.com'],
        ['url' => 'instagram.com'],
        ['url' => 'msn.com'],
        ['url' => 'walmart.com'],
        ['url' => 'yelp.com'],
        ['url' => 'weather.com'],
        ['url' => 'zillow.com'],
        ['url' => 'wordpress.com'],
        ['url' => 'target.com'],
        ['url' => 'buzzfeed.com'],
        ['url' => 'microsoft.com'],
    ]);
 
    dd($collection->last());
 
    //  "url" => "microsoft.com"

1
2
3
4
5
    dd($collection->last(function ($key, $value){
        return str_contains($value['url'], '.org');
    }));
 
    //  "url" => "wikipedia.org"

25. mapa ()

Con este método podemos iterar a través de la colección y pasar cada elemento a una devolución de llamada que puede modificarlo. Vamos a 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
    $collection = collect([
        ['url' => 'etsy.com'],
        ['url' => 'aol.com'],
        ['url' => 'diply.com'],
        ['url' => 'foxnews.com'],
        ['url' => 'bestbuy.com'],
    ]);
 
    dd($collection->map(function ($item){
        return strrev($item['url']);
    }));
 
/*
Collection {#112 ▼
  #items: array:5 [▼
    0 => "moc.yste"
    1 => "moc.loa"
    2 => "moc.ylpid"
    3 => "moc.swenxof"
    4 => "moc.yubtseb"
  ]
}
*/

Aquí está la fuente de map () que hace uso de array_keys () y array_map () .

1
2
3
4
5
6
7
8
    public function map(callable $callback)
    {
        $keys = array_keys($this->items);
 
        $items = array_map($callback, $this->items, $keys);
 
        return new static(array_combine($keys, $items));
    }

26. fusionar ()

Podemos ver que merge () hace uso de array_merge () aquí.

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

Probarlo en un par de colecciones nos muestra 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
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
    $collection1 = collect([
        ['url' => 'comcast.net'],
        ['url' => 'nfl.com'],
        ['url' => 'washingtonpost.com'],
        ['url' => 'homedepot.com'],
        ['url' => 'microsoftonline.com'],
    ]);
 
    $collection2 = collect([
        ['url' => 'wikia.com'],
        ['url' => 'indeed.com'],
        ['url' => 'usps.com'],
        ['url' => 'capitalone.com'],
        ['url' => 'att.com'],
    ]);
 
    dd($collection1->merge($collection2));
 
/*
Collection {#112 ▼
  #items: array:10 [▼
    0 => array:1 [▼
      "url" => "comcast.net"
    ]
    1 => array:1 [▼
      "url" => "nfl.com"
    ]
    2 => array:1 [▼
      "url" => "washingtonpost.com"
    ]
    3 => array:1 [▼
      "url" => "homedepot.com"
    ]
    4 => array:1 [▼
      "url" => "microsoftonline.com"
    ]
    5 => array:1 [▼
      "url" => "wikia.com"
    ]
    6 => array:1 [▼
      "url" => "indeed.com"
    ]
    7 => array:1 [▼
      "url" => "usps.com"
    ]
    8 => array:1 [▼
      "url" => "capitalone.com"
    ]
    9 => array:1 [▼
      "url" => "att.com"
    ]
  ]
}
*/

27. desplumar ()

Uno de mis favoritos es el método de extracción, que le permite obtener todos los valores de una clave proporcionada en la colección. Probémoslo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    $collection = collect([
        ['url' => 'comcast.net', 'industry' => 'telecom'],
        ['url' => 'nfl.com', 'industry' => 'entertainment'],
        ['url' => 'washingtonpost.com', 'industry' => 'news'],
        ['url' => 'homedepot.com', 'industry' => 'homebuilders'],
        ['url' => 'microsoftonline.com', 'industry' => 'software'],
    ]);
 
    dd($collection->pluck('industry'));
 
/*
Collection {#111 ▼
  #items: array:5 [▼
    0 => "telecom"
    1 => "entertainment"
    2 => "news"
    3 => "homebuilders"
    4 => "software"
  ]
}
*/

La fuente que hace posible pluck ().

1
2
3
4
    public function pluck($value, $key = null)
    {
        return new static(Arr::pluck($this->items, $value, $key));
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    public static function pluck($array, $value, $key = null)
    {
        $results = [];
 
        list($value, $key) = static::explodePluckParameters($value, $key);
 
        foreach ($array as $item) {
            $itemValue = data_get($item, $value);
 
            // If the key is "null", we will just append the value to the array and keep
            // looping. Otherwise we will key the array using the value of the key we
            // received from the developer. Then we'll return the final array form.
            if (is_null($key)) {
                $results[] = $itemValue;
            } else {
                $itemKey = data_get($item, $key);
 
                $results[$itemKey] = $itemValue;
            }
        }
 
        return $results;
    }

28. pop ()

Pop se vuelve loco desde el final de la colección. En otras palabras, pop () elimina el último elemento de la colección.

1
2
3
4
5
6
7
8
9
10
11
    $collection = collect([
        ['url' => 'americanexpress.com'],
        ['url' => 'pandora.com'],
        ['url' => 'ask.com'],
        ['url' => 'groupon.com'],
        ['url' => 'hulu.com'],
    ]);
 
    dd($collection->pop());
    
    // "url" => "hulu.com"

Podemos ver el uso de array_pop () para ayudarnos desde la fuente.

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

29. anteponer ()

Para agregar algo al principio de una matriz, usualmente usamos array_unshift () . El método prepend () usa un nombre mucho más amigable para darnos una indicación de lo que hará. Probarlo nos da 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
    $collection = collect([
        ['url' => 'ups.com'],
        ['url' => 'dropbox.com'],
        ['url' => 'verizonwireless.com'],
        ['url' => 'usatoday.com'],
        ['url' => 'answers.com'],
    ]);
 
    dd($collection->prepend(['url' => 'vegibit.com']));
 
/*
Collection {#110 ▼
  #items: array:6 [▼
    0 => array:1 [▼
      "url" => "vegibit.com"
    ]
    1 => array:1 [▼
      "url" => "ups.com"
    ]
    2 => array:1 [▼
      "url" => "dropbox.com"
    ]
    3 => array:1 [▼
      "url" => "verizonwireless.com"
    ]
    4 => array:1 [▼
      "url" => "usatoday.com"
    ]
    5 => array:1 [▼
      "url" => "answers.com"
    ]
  ]
}
*/

Una inspección rápida de la fuente confirma el uso de array_unshift () para nosotros.

1
2
3
4
5
6
    public function prepend($value)
    {
        array_unshift($this->items, $value);
 
        return $this;
    }

30. tirar ()

Pongámoslo pull()a prueba de inmediato.

1
2
3
4
5
6
7
    $collection = collect([
        'url' => 'cnet.com', 'industry' => 'tech news', 'reviews' => true
    ]);
 
    dd($collection->pull('industry'));
 
    // "tech news"

1
2
3
4
5
6
7
8
9
10
dd($collection);
 
*/
Collection {#110 ▼
  #items: array:2 [▼
    "url" => "cnet.com"
    "reviews" => true
  ]
}
*/

pull () saca un elemento de la colección y se lo devuelve en función de la clave que le proporcione. Utiliza este código para que funcione su magia.

1
2
3
4
    public function pull($key, $default = null)
    {
        return Arr::pull($this->items, $key, $default);
    }

1
2
3
4
5
6
7
8
    public static function pull(&$array, $key, $default = null)
    {
        $value = static::get($array, $key, $default);
 
        static::forget($array, $key);
 
        return $value;
    }

31. empujar ()

De nuevo, es muy probable que esté familiarizado con array_push () para poner cosas al final de una matriz. El método push () de laravel nos permite poner cosas al final de una colección. ¿Te gustaría ver?

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
    $collection = collect([
        ['url' => 'forbes.com'],
        ['url' => 'stackoverflow.com'],
        ['url' => 'office.com'],
    ]);
 
    dd($collection->push(['url' => 'adobe.com']));
 
/*
Collection {#110 ▼
  #items: array:4 [▼
    0 => array:1 [▼
      "url" => "forbes.com"
    ]
    1 => array:1 [▼
      "url" => "stackoverflow.com"
    ]
    2 => array:1 [▼
      "url" => "office.com"
    ]
    3 => array:1 [▼
      "url" => "adobe.com"
    ]
  ]
}
*/

Profundizar en la fuente nos da una idea de cómo funciona esto.

1
2
3
4
5
6
    public function push($value)
    {
        $this->offsetSet(null, $value);
 
        return $this;
    }

1
2
3
4
5
6
7
8
    public function offsetSet($key, $value)
    {
        if (is_null($key)) {
            $this->items[] = $value;
        } else {
            $this->items[$key] = $value;
        }
    }

32. poner ()

put () es casi como push () con una implementación ligeramente diferente. Con put (), también usa el método offsetSet (), pero usa una firma diferente.

1
2
3
4
5
6
    public function put($key, $value)
    {
        $this->offsetSet($key, $value);
 
        return $this;
    }

Probar esto nos muestra la diferencia en 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
    $collection = collect([
        ['url' => 'macys.com'],
        ['url' => 'cbssports.com'],
        ['url' => 'fedex.com'],
    ]);
 
    dd($collection->put(1, ['was put' => 'clobbered']));
 
/*
Collection {#110 ▼
  #items: array:3 [▼
    0 => array:1 [▼
      "url" => "macys.com"
    ]
    1 => array:1 [▼
      "was put" => "clobbered"
    ]
    2 => array:1 [▼
      "url" => "fedex.com"
    ]
  ]
}
*/

Con este ejemplo, puede ver que podemos sobrescribir los valores existentes en cualquier parte de la colección si lo deseamos, o simplemente agregar un nuevo elemento tanto de clave como de valor.

33. aleatorio ()

random () nos permite acceder a la colección y extraer un elemento completamente impredecible y aleatorio. Un vistazo rápido a la fuente nos muestra cómo completa esta tarea.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    public function random($amount = 1)
    {
        if ($amount > ($count = $this->count())) {
            throw new InvalidArgumentException("You requested {$amount} items, but there are only {$count} items in the collection");
        }
 
        $keys = array_rand($this->items, $amount);
 
        if ($amount == 1) {
            return $this->items[$keys];
        }
 
        return new static(array_intersect_key($this->items, array_flip($keys)));
    }

Hay un poco de lógica entre el uso de array_rand () , array_intersect_key () y array_flip () . Probémoslo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    $collection = collect([
        ['url' => 'slickdeals.net'],
        ['url' => 'mlb.com'],
        ['url' => 'amazonaws.com'],
        ['url' => 'twitch.tv'],
        ['url' => 'lowes.com'],
        ['url' => 'webmd.com'],
        ['url' => 'businessinsider.com'],
        ['url' => 'bleacherreport.com'],
        ['url' => 'salesforce.com'],
        ['url' => 'bbc.com'],
        ['url' => 'github.com'],
        ['url' => 'gap.com'],
    ]);
 
    dd($collection->random());
 
    // "url" => "businessinsider.com"
    // reload to get a new random item

34. reducir ()

Este método es como una iteración recursiva hasta un elemento de la colección utilizando la función array_reduce () de PHP . Lo determinamos viendo la fuente.

1
2
3
4
    public function reduce(callable $callback, $initial = null)
    {
        return array_reduce($this->items, $callback, $initial);
    }

Junto con una prueba rápida.

1
2
3
4
5
6
7
8
9
    $collection = collect([
        1234, 3456, 987, 3456, 92347
    ]);
 
    dd($collection->reduce(function ($carry, $item) {
        return $carry + $item;
    }));
 
    // 101480

35. rechazar ()

Vimos un ejemplo de este método al principio del artículo cuando rechazamos cualquier URL de la colección con un valor de cadena de facebook dentro. Veamos la fuente para ver cómo funciona.

1
2
3
4
5
6
7
8
9
10
11
12
    public function reject($callback)
    {
        if ($this->useAsCallable($callback)) {
            return $this->filter(function ($item) use ($callback) {
                return ! $callback($item);
            });
        }
 
        return $this->filter(function ($item) use ($callback) {
            return $item != $callback;
        });
    }

Probándolo de nuevo, esta vez rechazaremos cualquier elemento de la colección que contenga la cadena 'descubrir'.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
    $collection = collect([
        'http://wsj.com',
        'http://discovercard.com',
        'http://realtor.com',
        'http://theguardian.com',
        'http://newegg.com',
        'http://nbcnews.com'
    ])->reject(function ($site) {
        return str_contains($site, 'discover') == true;
    });
 
    dd($collection);
 
/*
Collection {#113 ▼
  #items: array:5 [▼
    0 => "http://wsj.com"
    2 => "http://realtor.com"
    3 => "http://theguardian.com"
    4 => "http://newegg.com"
    5 => "http://nbcnews.com"
  ]
}
*/

36. reverso ()

El método reverse () hace lo que esperas y es invertir el orden de los elementos de la colección. Lo hace usando array_reverse () como podemos ver aquí.

1
2
3
4
    public function reverse()
    {
        return new static(array_reverse($this->items));
    }

No olvides que todos estos métodos son fluidos, así que recordémoslo ahora.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    $collection = collect([
        'http://wsj.com',
        'http://discovercard.com',
        'http://realtor.com',
        'http://theguardian.com',
        'http://newegg.com',
        'http://nbcnews.com'
    ])->reverse();
 
    dd($collection);
 
/*
Collection {#111 ▼
  #items: array:6 [▼
    5 => "http://nbcnews.com"
    4 => "http://newegg.com"
    3 => "http://theguardian.com"
    2 => "http://realtor.com"
    1 => "http://discovercard.com"
    0 => "http://wsj.com"
  ]
}
*/

37. buscar ()

Convenientemente, también puede buscar a través de una colección de laravel determinada utilizando el práctico método search (). Buscó por valor y devuelve la clave si la encuentra. La función usa las funciones array_search () y call_user_func () para hacer que suceda la magia.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    public function search($value, $strict = false)
    {
        if (! $this->useAsCallable($value)) {
            return array_search($value, $this->items, $strict);
        }
 
        foreach ($this->items as $key => $item) {
            if (call_user_func($value, $item, $key)) {
                return $key;
            }
        }
 
        return false;
    }

Nuestra prueba muestra que funciona en acción.

1
2
3
4
5
6
7
8
9
10
11
12
13
    $collection = collect([
        'flickr.com',
        'taboola.com',
        'costco.com',
        'nordstrom.com',
        'ancestry.com',
        'stackexhange.com'
    ])->search('stackexhange.com');
 
    dd($collection);
    
    // 5
    // index 5 is the one that holds stackexhange.com

38. shift ()

shift () es un pequeño contenedor agradable para array_shift () que toma el primer elemento del comienzo de una matriz.

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

¿Funciona? Puedes apostar. Nuevamente, tenga en cuenta el estilo fluido.

1
2
3
4
5
6
7
8
9
10
    $collection = collect([
        'Deviantart.com',
        'Allrecipes.com',
        'Retailmenot.com',
        'Thesaurus.com',
    ])->shift();
 
    dd($collection);
 
    // Deviantart.com

39. barajar ()

Hace que sea conveniente usar el estilo fluido a través de la función PHP shuffle () incorporada.

1
2
3
4
5
6
7
8
    public function shuffle()
    {
        $items = $this->items;
 
        shuffle($items);
 
        return new static($items);
    }

Aquí está nuestra pequeña prueba.

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
    $collection = collect([
        'Southwest.com',
        'Wunderground.com',
        'Goodreads.com',
        'Ca.gov',
        'Npr.org',
        'Pch.com ',
        'Drudgereport.com',
        'Blackboard.com',
        'People.com'
    ])->shuffle();
 
    dd($collection);
 
/*
Collection {#111 ▼
  #items: array:9 [▼
    0 => "Pch.com "
    1 => "Blackboard.com"
    2 => "People.com"
    3 => "Goodreads.com"
    4 => "Southwest.com"
    5 => "Wunderground.com"
    6 => "Drudgereport.com"
    7 => "Ca.gov"
    8 => "Npr.org"
  ]
}
*/

40. rebanada ()

array_slice () se usa comúnmente en muchos proyectos PHP. Laravel incluye esto en su clase de colección a través del siguiente código.

1
2
3
4
    public function slice($offset, $length = null, $preserveKeys = false)
    {
        return new static(array_slice($this->items, $offset, $length, $preserveKeys));
    }

Este método es muy poderoso. Puede pasar un valor único para determinar dónde comenzará el segmento. En ese momento, devolverá el resto de los elementos de la colección a partir de ese punto que proporcionó. Sin embargo, cuando pienso en cortar, generalmente pienso que significa cuando se llega a una matriz o colección y se saca un número específico de elementos en un punto de partida específico. También puede hacer esto con slice (), todo lo que tiene que hacer es pasar la cantidad de elementos que le gustaría como segundo argumento. Finalmente, también tiene la opción de tener nuevas teclas numéricas basadas en el nuevo segmento o la capacidad de retener las claves originales. Pase verdadero como tercer argumento si desea mantener intactas las claves originales. Probemos los tres a la vez (tenga en cuenta que pasamos los tres parámetros).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
    $collection = collect([
        'Expedia.com' => 'Has fun commercials',
        'Soundcloud.com' => 'Cool music website.',
        'Intuit.com ' => 'Business software for all.',
        'Patch.com' => 'local news',
        'Trulia.com' => 'Search Real Estate',
        'Accuweather.com' => 'Get the forecast',
        'Staples.com' => 'buy some office supplies',
    ])->slice(3, 2, true);
 
    dd($collection);
 
/*
Collection {#111 ▼
  #items: array:2 [▼
    "Patch.com" => "local news"
    "Trulia.com" => "Search Real Estate"
  ]
}
*/

41. sort ()

Puedes ordenar tus colecciones usando el método sort (). El código de Laravel que lo alimenta usa uasort () como puede ver aquí.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
    public function sort(callable $callback = null)
    {
        $items = $this->items;
 
        $callback ? uasort($items, $callback) : uasort($items, function ($a, $b) {
 
            if ($a == $b) {
                return 0;
            }
 
            return ($a < $b) ? -1 : 1;
        });
 
        return new static($items);
    }

Aquí podemos verlo en acción.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
    $collection = collect([0, 4, 9, 22, 123, 432, 1, 5, 77 ])->sort();
 
    dd($collection);
 
/*
Collection {#111 ▼
  #items: array:9 [▼
    0 => 0
    6 => 1
    1 => 4
    7 => 5
    2 => 9
    3 => 22
    8 => 77
    4 => 123
    5 => 432
  ]
}
*/

42. sortBy ()

Este método es realmente útil para usar con Eloquent, ya que a menudo necesitamos ordenar los datos de una base de datos. La fuente está involucrada, así que tómese unos minutos para revisar.

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
    public function sortBy($callback, $options = SORT_REGULAR, $descending = false)
    {
        $results = [];
 
        $callback = $this->valueRetriever($callback);
 
        // First we will loop through the items and get the comparator from a callback
        // function which we were given. Then, we will sort the returned values and
        // and grab the corresponding values for the sorted keys from this array.
        foreach ($this->items as $key => $value) {
            $results[$key] = $callback($value, $key);
        }
 
        $descending ? arsort($results, $options)
                    : asort($results, $options);
 
        // Once we have sorted all of the keys in the array, we will loop through them
        // and grab the corresponding model so we can set the underlying items list
        // to the sorted version. Then we'll just return the collection instance.
        foreach (array_keys($results) as $key) {
            $results[$key] = $this->items[$key];
        }
 
        return new static($results);
    }

Probar sortBy () muestra que funciona muy bien.

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
    $collection = collect([
        ['url' => 'Overstock.com', 'votes' => 15],
        ['url' => 'Fidelity.com', 'votes' => 5],
        ['url' => 'Vimeo.com', 'votes' => 22],
        ['url' => 'Glassdoor.com', 'votes' => 5],
        ['url' => 'Sears.com', 'votes' => 10],
        ['url' => 'Ign.com ', 'votes' => 31],
        ['url' => 'Cbs.com', 'votes' => 1],
    ])->sortBy('votes');
 
    dd($collection);
 
/*
Collection {#112 ▼
  #items: array:7 [▼
    6 => array:2 [▼
      "url" => "Cbs.com"
      "votes" => 1
    ]
    3 => array:2 [▼
      "url" => "Glassdoor.com"
      "votes" => 5
    ]
    1 => array:2 [▼
      "url" => "Fidelity.com"
      "votes" => 5
    ]
    4 => array:2 [▼
      "url" => "Sears.com"
      "votes" => 10
    ]
    0 => array:2 [▼
      "url" => "Overstock.com"
      "votes" => 15
    ]
    2 => array:2 [▼
      "url" => "Vimeo.com"
      "votes" => 22
    ]
    5 => array:2 [▼
      "url" => "Ign.com "
      "votes" => 31
    ]
  ]
}
*/

43. sortByDesc ()

Por extraño que parezca, uno de mis favoritos personales, ordena los resultados como sortBy () pero en la dirección opuesta.

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
    $collection = collect([
        ['url' => 'Overstock.com', 'votes' => 15],
        ['url' => 'Fidelity.com', 'votes' => 5],
        ['url' => 'Vimeo.com', 'votes' => 22],
        ['url' => 'Glassdoor.com', 'votes' => 5],
        ['url' => 'Sears.com', 'votes' => 10],
        ['url' => 'Ign.com ', 'votes' => 31],
        ['url' => 'Cbs.com', 'votes' => 1],
    ])->sortByDesc('votes');
 
    dd($collection);
 
/*
Collection {#112 ▼
  #items: array:7 [▼
    5 => array:2 [▼
      "url" => "Ign.com "
      "votes" => 31
    ]
    2 => array:2 [▼
      "url" => "Vimeo.com"
      "votes" => 22
    ]
    0 => array:2 [▼
      "url" => "Overstock.com"
      "votes" => 15
    ]
    4 => array:2 [▼
      "url" => "Sears.com"
      "votes" => 10
    ]
    3 => array:2 [▼
      "url" => "Glassdoor.com"
      "votes" => 5
    ]
    1 => array:2 [▼
      "url" => "Fidelity.com"
      "votes" => 5
    ]
    6 => array:2 [▼
      "url" => "Cbs.com"
      "votes" => 1
    ]
  ]
}
*/

44. empalme ()

splice () funciona con la función PHP array_splice () como se ve aquí. Esto le permite eliminar un elemento o elementos de la colección y reemplazarlos con otra cosa.

1
2
3
4
5
6
7
8
    public function splice($offset, $length = null, $replacement = [])
    {
        if (func_num_args() == 1) {
            return new static(array_splice($this->items, $offset));
        }
 
        return new static(array_splice($this->items, $offset, $length, $replacement));
    }

Podemos probar esto mientras eliminamos dos elementos que comienzan en el índice 3 y reemplazamos el agujero que queda con dos nuevas URL.

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
49
    $collection = collect([
        ['url' => 'Spotify.com'],
        ['url' => 'Feedly.com'],
        ['url' => 'Lifehacker.com'],
        ['url' => 'Bloomberg.com'],
        ['url' => 'Foodnetwork.com'],
        ['url' => 'T-mobile.com'],
    ]);
 
    $chunk = $collection->splice(3, 2, [['url' => 'Gizmodo.com'], ['url' => 'Woot.com']]);
 
    var_dump($chunk);
 
    dd($collection);
 
/*
object(Illuminate\Support\Collection)[111]
  protected 'items' => 
    array (size=2)
      0 => 
        array (size=1)
          'url' => string 'Bloomberg.com' (length=13)
      1 => 
        array (size=1)
          'url' => string 'Foodnetwork.com' (length=15)
 
Collection {#110 ▼
  #items: array:6 [▼
    0 => array:1 [▼
      "url" => "Spotify.com"
    ]
    1 => array:1 [▼
      "url" => "Feedly.com"
    ]
    2 => array:1 [▼
      "url" => "Lifehacker.com"
    ]
    3 => array:1 [▼
      "url" => "Gizmodo.com"
    ]
    4 => array:1 [▼
      "url" => "Woot.com"
    ]
    5 => array:1 [▼
      "url" => "T-mobile.com"
    ]
  ]
}
*/

45. suma ()

Un método de suma rápido y sencillo que puede utilizar como tal.

1
2
3
4
5
    $collection = collect([2, 2])->sum();
 
    dd($collection);
 
    // 4

Cuando haya anidado matrices u objetos, simplemente pase la clave con la que desea sumar.

1
2
3
4
5
6
7
8
9
10
    $collection = collect([
        ['burger', 'cost' => 2.58],
        ['fries', 'cost' => 1.33],
        ['lemonade', 'cost' => 2.25],
        ['ice cream', 'cost' => 1.50]
    ])->sum('cost');
 
    dd($collection);
 
    // 7.66

46. tomar ()

Cuando tienes una gran colección en tus manos y solo necesitas una cantidad limitada de artículos, take () es tu amigo. ¿Tienes 100 artículos y solo necesitas 5? tomar (5). Quizás necesites perder una libra o dos. Tome solo los dos primeros de nuestro ejemplo anterior.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
    $collection = collect([
        ['burger', 'cost' => 2.58],
        ['fries', 'cost' => 1.33],
        ['lemonade', 'cost' => 2.25],
        ['ice cream', 'cost' => 1.50]
    ])->take(2);
 
    dd($collection);
 
/*
Collection {#111 ▼
  #items: array:2 [▼
    0 => array:2 [▼
      0 => "burger"
      "cost" => 2.58
    ]
    1 => array:2 [▼
      0 => "fries"
      "cost" => 1.33
    ]
  ]
}
*/

47. toArray ()

A veces, es posible que te quedes atascado trabajando con un problema de colección que no puedes resolver. Cuando necesite desplegar una matriz PHP simple y antigua, puede usar toArray () para hacerlo.

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
    $collection = collect([
        ['url' => 'google.com'],
        ['url' => 'facebook.com'],
        ['url' => 'amazon.com'],
        ['url' => 'youtube.com'],
        ['url' => 'twitter.com'],
        ['url' => 'craigslist.com'],
        ['url' => 'reddit.com'],
        ['url' => 'pinterest.com'],
        ['url' => 'apple.com'],
        ['url' => 'instagram.com'],
        ['url' => 'wordpress.com'],
        ['url' => 'target.com'],
        ['url' => 'buzzfeed.com'],
        ['url' => 'microsoft.com'],
    ]);
 
    dd($collection->toArray());
 
/*
array:14 [▼
  0 => array:1 [▼
    "url" => "google.com"
  ]
  1 => array:1 [▼
    "url" => "facebook.com"
  ]
  2 => array:1 [▼
    "url" => "amazon.com"
  ]
  3 => array:1 [▼
    "url" => "youtube.com"
  ]
  4 => array:1 [▼
    "url" => "twitter.com"
  ]
  5 => array:1 [▼
    "url" => "craigslist.com"
  ]
  6 => array:1 [▼
    "url" => "reddit.com"
  ]
  7 => array:1 [▼
    "url" => "pinterest.com"
  ]
  8 => array:1 [▼
    "url" => "apple.com"
  ]
  9 => array:1 [▼
    "url" => "instagram.com"
  ]
  10 => array:1 [▼
    "url" => "wordpress.com"
  ]
  11 => array:1 [▼
    "url" => "target.com"
  ]
  12 => array:1 [▼
    "url" => "buzzfeed.com"
  ]
  13 => array:1 [▼
    "url" => "microsoft.com"
  ]
]
*/

Tenga en cuenta que el resultado es una matriz, no una colección.

48. toJson ()

También puede convertir a JSON fácilmente.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
    $collection = collect([
        ['url' => 'google.com'],
        ['url' => 'facebook.com'],
        ['url' => 'amazon.com'],
        ['url' => 'youtube.com'],
        ['url' => 'twitter.com'],
        ['url' => 'craigslist.com'],
        ['url' => 'reddit.com'],
        ['url' => 'pinterest.com'],
        ['url' => 'apple.com'],
        ['url' => 'instagram.com'],
        ['url' => 'wordpress.com'],
        ['url' => 'target.com'],
        ['url' => 'buzzfeed.com'],
        ['url' => 'microsoft.com'],
    ]);
 
    dd($collection->toJson());
 
/*
"[{"url":"google.com"},{"url":"facebook.com"},{"url":"amazon.com"},{"url":"youtube.com"},{"url":"twitter.com"},{"url":"craigslist.com"},{"url":"reddit.com"},{"url":"pinterest.com"},{"url":"apple.com"},{"url":"instagram.com"},{"url":"wordpress.com"},{"url":"target.com"},{"url":"buzzfeed.com"},{"url":"microsoft.com"}]"
*/

49. transform ()

Con transform () puede modificar la colección directamente iterando sobre ella con una devolución de llamada.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
    $collection = collect([5, 10, 4, 15, 20]);
 
    $collection->transform(function ($item, $key) {
        return $item * 3;
    });
 
    dd($collection->all());
 
/*
array:5 [▼
  0 => 15
  1 => 30
  2 => 12
  3 => 45
  4 => 60
]
*/

50. único ()

unique () es otro método que disfruto bastante. Devolverá solo los valores únicos en la colección usando este código aquí.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
    public function unique($key = null)
    {
        if (is_null($key)) {
            return new static(array_unique($this->items, SORT_REGULAR));
        }
 
        $key = $this->valueRetriever($key);
 
        $exists = [];
 
        return $this->reject(function ($item) use ($key, &$exists) {
            if (in_array($id = $key($item), $exists)) {
                return true;
            }
 
            $exists[] = $id;
        });
    }

Una prueba rápida nos muestra su dominio en acción.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    $collection = collect(['pizza', 'pizza', 'water', 'fruit juice', 'water', 7, 7, 7]);
 
    $unique = $collection->unique();
 
    dd($unique);
 
/*
Collection {#111 ▼
  #items: array:4 [▼
    0 => "pizza"
    2 => "water"
    3 => "fruit juice"
    5 => 7
  ]
}
*/

51. valores ()

Este es un pequeño método genial que devuelve la colección con las claves configuradas para incrementar los números.

Primero sin valores ()

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
    $collection = collect([
        '123' => 'google.com',
        '234' => 'amazon.com',
        '345' => 'yahoo.com',
        '456' => 'ebay.com',
        '567' => 'twitter.com',
        '678' => 'craigslist.com',
        '789' => 'netflix.com',
    ]);
 
    dd($collection);
 
/*
Collection {#110 ▼
  #items: array:7 [▼
    123 => "google.com"
    234 => "amazon.com"
    345 => "yahoo.com"
    456 => "ebay.com"
    567 => "twitter.com"
    678 => "craigslist.com"
    789 => "netflix.com"
  ]
}
*/

Ahora con los valores () aplicados.

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
    $collection = collect([
        '123' => 'google.com',
        '234' => 'amazon.com',
        '345' => 'yahoo.com',
        '456' => 'ebay.com',
        '567' => 'twitter.com',
        '678' => 'craigslist.com',
        '789' => 'netflix.com',
    ])->values();
 
    dd($collection);
 
/*
Collection {#111 ▼
  #items: array:7 [▼
    0 => "google.com"
    1 => "amazon.com"
    2 => "yahoo.com"
    3 => "ebay.com"
    4 => "twitter.com"
    5 => "craigslist.com"
    6 => "netflix.com"
  ]
}
*/

52. donde ()

Este es un buen método que puede utilizar para encontrar un par clave-valor en su colección. Tenga en cuenta que esto no es lo mismo que la base de datos relacionada con where () ya que puede emplear operadores como mayor que, menor que, me gusta, etc. Vamos a probarlo.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
    $collection = collect([
        ['car' => 'Honda', 'mileage' => 2000],
        ['car' => 'Tesla', 'mileage' => 35000],
        ['car' => 'Subaru', 'mileage' => 15000],
        ['car' => 'Ford', 'mileage' => 100000],
        ['car' => 'Chevy', 'mileage' => 85000],
        ['car' => 'Kia', 'mileage' => 100250],
    ])->where('mileage', 15000);
 
    dd($collection); 
 
/*
Collection {#112 ▼
  #items: array:1 [▼
    2 => array:2 [▼
      "car" => "Subaru"
      "mileage" => 15000
    ]
  ]
}
*/

53. zip ()

Finalmente, tenemos el método zip () que combina valores de una matriz proporcionada con los valores de su colección donde las posiciones de índice son iguales. Agreguemos una garantía a todos los autos de nuestro ejemplo anterior como prueba.

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
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
    $collection = collect([
        ['car' => 'Honda', 'mileage' => 2000],
        ['car' => 'Tesla', 'mileage' => 35000],
        ['car' => 'Subaru', 'mileage' => 15000],
        ['car' => 'Ford', 'mileage' => 100000],
        ['car' => 'Chevy', 'mileage' => 85000],
        ['car' => 'Kia', 'mileage' => 100250],
    ])->zip([
        'warranty',
        'warranty',
        'warranty',
        'warranty',
        'warranty',
        'warranty',
    ]);
 
    dd($collection);
 
/*
Collection {#112 ▼
  #items: array:6 [▼
    0 => Collection {#113 ▼
      #items: array:2 [▼
        0 => array:2 [▼
          "car" => "Honda"
          "mileage" => 2000
        ]
        1 => "warranty"
      ]
    }
    1 => Collection {#114 ▼
      #items: array:2 [▼
        0 => array:2 [▼
          "car" => "Tesla"
          "mileage" => 35000
        ]
        1 => "warranty"
      ]
    }
    2 => Collection {#115 ▼
      #items: array:2 [▼
        0 => array:2 [▼
          "car" => "Subaru"
          "mileage" => 15000
        ]
        1 => "warranty"
      ]
    }
    3 => Collection {#116 ▼
      #items: array:2 [▼
        0 => array:2 [▼
          "car" => "Ford"
          "mileage" => 100000
        ]
        1 => "warranty"
      ]
    }
    4 => Collection {#117 ▼
      #items: array:2 [▼
        0 => array:2 [▼
          "car" => "Chevy"
          "mileage" => 85000
        ]
        1 => "warranty"
      ]
    }
    5 => Collection {#118 ▼
      #items: array:2 [▼
        0 => array:2 [▼
          "car" => "Kia"
          "mileage" => 100250
        ]
        1 => "warranty"
      ]
    }
  ]
}
*/

La motivación de este tutorial

Parece que cuando estás usando Laravel, ciertas cosas siguen apareciendo una y otra vez. Lo primero es sin duda la arquitectura que utiliza el marco, los proveedores de servicios y la comprensión de cómo funciona la inversión del contenedor de control. Hay algunas cosas fundamentales que todos intentamos tener en nuestro haber. Parecía que las colecciones eran las siguientes en cuanto a algo de lo que valdría la pena tener una comprensión realmente sólida. ¿Qué mejor manera de aprenderlo que completar el tutorial de colecciones de mega laravel? Además, siempre es realmente esclarecedor mirar bajo el capó la fuente para ver cómo ocurre la magia. Comprender la herramienta o el marco que utiliza le da confianza.

Resumen y lectura adicional

Hay muchos enlaces en este tutorial que enlazan directamente con las funciones PHP que se utilizan para crear la clase Colecciones. Lea sobre ellos o revíselos: puede aprender una cosa o dos o simplemente refrescar su memoria sobre un concepto que se había olvidado.
Si bien aquí cubrimos las colecciones de laravel simples de vainilla, asegúrese de consultar el tutorial de Dayle Rees sobre Eloquent Collections . Es el mejor que he visto.
Si aún no tiene una suscripción a Laracasts, obtenga una y revise su tutorial sobre Colecciones, es fantástico.
Jens Segers tiene este increíble tutorial sobre colecciones de laravel, ¡léelo!
Eric Barnes también tiene excelentes recursos para colecciones en laravel news.
Stupid Collection Tips (¡que son realmente geniales!) Por Jeff Madsen

¡Y con eso, nuestro Tutorial de colecciones de Laravel está completo!

Header Ads Widget

Tutorial de colecciones de Laravel