El poder de la función array_chunk de PHP

PHP cuenta con una gran colección de funciones de array integradas, y array_chunk() es una de las más útiles para trabajar con grandes conjuntos de datos. Divide un array en una serie de arrays más pequeños ("fragmentos") de tamaño fijo, lo que facilita la paginación, el procesamiento por lotes y la disposición de datos. Este capítulo explica la sintaxis, recorre ejemplos ejecutables, aborda el indicador preserve_keys y señala los errores más comunes.

¿Qué es la función array_chunk?

La función array_chunk() divide un array en arrays más pequeños, cada uno con un número específico de elementos. Es útil cuando necesitas dividir una lista larga en grupos de igual tamaño; por ejemplo, para renderizar una cuadrícula de N columnas, procesar registros en lotes o construir salidas paginadas.

Sintaxis

array_chunk(array $array, int $length, bool $preserve_keys = false): array

Valor de retorno: un nuevo array multidimensional. El array original nunca se modifica — array_chunk() no opera en su lugar.

¿Cómo funciona array_chunk?

array_chunk() recorre el array de entrada en orden y copia los elementos en un nuevo subarray hasta alcanzar $length elementos, momento en el que comienza un nuevo fragmento. El último fragmento contiene lo que queda, por lo que puede ser más pequeño que los demás.

Por defecto, el tercer parámetro, preserve_keys, es false, lo que reindexa las claves de cada fragmento comenzando desde 0. Establecerlo en true conserva las claves originales del array, algo importante cuando esas claves tienen significado (como claves de tipo string o IDs no secuenciales).

Por ejemplo, considera el siguiente array:

PHP define un array

Si llamamos a array_chunk sobre este array pasando el valor 3 como segundo argumento, obtenemos el siguiente resultado:

Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
            [2] => c
        )

    [1] => Array
        (
            [0] => d
            [1] => e
            [2] => f
        )

    [2] => Array
        (
            [0] => g
        )
)

Como puedes ver, el array original ha sido dividido en tres arrays más pequeños, cada uno con tres elementos (a excepción del último, que contiene solo uno).

Preservar las claves originales

Por defecto, cada fragmento se reindexa desde 0. Pasa true como tercer argumento para conservar las claves originales:

<?php

$data = array("id10" => "a", "id20" => "b", "id30" => "c");

print_r(array_chunk($data, 2, true));

?>

Salida:

Array
(
    [0] => Array
        (
            [id10] => a
            [id20] => b
        )

    [1] => Array
        (
            [id30] => c
        )
)

Mantén preserve_keys en true siempre que las claves identifiquen los datos (claves de tipo string, IDs de base de datos, etc.); de lo contrario, se perderán en el siguiente reindexa.

¿Por qué usar array_chunk?

La función array_chunk es increíblemente útil para una variedad de aplicaciones, entre ellas:

• Dividir arrays grandes en partes más pequeñas y manejables para su procesamiento.
• Mostrar grandes cantidades de datos de forma paginada (p. ej., dividir un array de resultados en arrays más pequeños para mostrarlos en varias páginas).
• Mejorar el rendimiento de los algoritmos que operan sobre arrays al reducir el tamaño de los arrays procesados en un momento dado.

Ejemplo de uso: Paginación

Uno de los casos de uso más comunes de la función array_chunk es la paginación. Considera el siguiente ejemplo, donde tenemos un array de 12 resultados que queremos mostrar en 2 páginas:

Ejemplo de la función array_chunk de PHP

array_chunk() divide los 12 resultados en 2 páginas: el primer fragmento contiene 10 elementos y el segundo los 2 restantes. Cada fragmento corresponde directamente a una página, por lo que puedes renderizar $pages[0] para la página 1, $pages[1] para la página 2, y usar count($pages) para construir los enlaces de paginación.

Errores comunes

• $length debe ser al menos 1. Un valor de 0 o un número negativo lanza un ValueError en PHP 8 y emitía una advertencia en PHP 7.
• El array original no se modifica. array_chunk() devuelve un nuevo array; asigna el resultado, no esperes que mute la entrada.
• El orden se conserva, las claves no (por defecto). Los elementos mantienen su orden original, pero las claves numéricas se reinician a 0..n a menos que pases preserve_keys = true.
• El último fragmento puede ser más corto. Siempre maneja un fragmento final más pequeño que $length al iterar.

Funciones relacionadas

• array_slice() — extrae una porción contigua de un array en lugar de dividir todo el array.
• array_splice() — elimina o reemplaza una porción de un array en su lugar.
• array_merge() — combina varios arrays en uno solo.
• array_map() — aplica una función de retorno a cada fragmento tras la división.
• PHP Arrays — un repaso sobre arrays indexados y asociativos.

Conclusión

La función array_chunk() es una forma sencilla y eficaz de dividir un array grande en partes más pequeñas y de tamaño uniforme. Ya sea que estés paginando resultados, procesando registros en lotes o diseñando una cuadrícula, mantiene el manejo de arrays legible y predecible. Recuerda las dos reglas que suelen causar problemas: el tamaño del fragmento debe ser al menos 1, y las claves se reindexa a menos que pidas conservarlas.

Práctica