Trozo de matriz

Usando un fragmento de matriz (array_chunk) podemos dividir fácilmente una matriz en una matriz multidimensional (una matriz de matrices).

La función de fragmento de matriz podría usarse para dividir una matriz en partes más pequeñas, tal vez para que sea más fácil de procesar.

Ejemplo básico

Suponiendo que configuramos una matriz según el ejemplo de código a continuación ($arrayen la línea 1), podemos dividir esta matriz en una nueva matriz multidimensional utilizando la array_chunkfunción en la línea 9.

Ejecutar este código daría como resultado la matriz multidimensional en la línea 15.

$array = [
    'Post 0', 
    'Post 1', 
    'Post 2', 
    'Post 3', 
    'Post 4', 
    'Post 5',
];
$chunked_array = array_chunk( $array, 2 );
print_r( $chunked_array ); // Output the new array.

/**
 * Output:
 *
 * Array
 * (*   [0] => Array
 * (*          [0] => Post 0
 *          [1] => Post 1
 *) *   [1] => Array
 * (*          [0] => Post 2
 *          [1] => Post 3
 *) *   [2] => Array
 * (*           [0] => Post 4
 *           [1] => Post 5
 *) *)
 **/

Composición

$chunked_array = array_chunk( $array, $chunk, $preserve_keys );

La array_chunkfunción acepta tres parámetros, $arrayy $chunk( $preserve_keysopcional, falso por defecto). Estos son los siguientes:

1. El $arrayparámetro acepta un arreglo, y es el arreglo inicial que deseamos transformar.
2. El $chunkacepta un número entero, y es el número que usamos para dividir el $arrayen partes de este valor.
3. El parámetro opcional $preserve_keysacepta un valor booleano y conservará las claves de la matriz si true.

Características y ejemplos específicos

Conservar llaves

Explorando el $preserve_keysparámetro, nuestro ejemplo anterior inicia el índice de cada matriz anidada en 0. Sin embargo, si tuviéramos que pasar truea este parámetro, el índice original de la matriz inicial se mantendría intacto:

$array = [
    'Post 0', 
    'Post 1', 
    'Post 2', 
    'Post 3', 
    'Post 4', 
    'Post 5',
];
$chunked_array = array_chunk( $array, 2, true );
print_r( $chunked_array ); // Output the new array.

/**
 * Output:
 *
 * Array
 * (*   [0] => Array
 * (*          [0] => Post 0
 *          [1] => Post 1
 *) *   [1] => Array
 * (*          [2] => Post 2
 *          [3] => Post 3
 *) *   [2] => Array
 * (*           [4] => Post 4
 *           [5] => Post 5
 *) *)
 **/

En la salida, las claves ahora son secuenciales, como lo serían en la matriz original (0, 1, 2, 3…).

Conservar claves cuando la matriz original tiene claves con nombre

Si nuestra matriz original tiene claves con nombre, podemos conservar las claves para mantenerlas en nuestra matriz fragmentada.

El siguiente ejemplo tiene un poco de diversión con esto. Digamos que de alguna manera tenemos una matriz con algunos ID de publicación y nombres de publicación mezclados.

Podríamos usar array_chunkcon el $preserve_keysparámetro establecido en truepara dividirlos en publicaciones individuales.

$array = [
    'id_0'   => '10', 
    'name_0' => 'Post 1', 
    'id_1'   => '20', 
    'name_1' => 'Post 2', 
    'id_2'   => '30', 
    'name_2' => 'Post 3',
];
$chunked_array = array_chunk( $array, 2, true);
print_r( $chunked_array ); 

Todavía divirtiéndonos con esta matriz, imaginemos cómo podríamos recorrer el $chunked_array, y generar solo los nombres.

foreach( $chunked_array as $key => $nested_array) {
    echo $nested_array[ 'name_'. $key ]. PHP_EOL;
}

Fragmentación de un arreglo grande para su procesamiento.

Si tenemos una matriz muy grande, podemos usarla array_chunkpara dividirla en partes más pequeñas que luego podríamos almacenar por separado. Veamos cómo podríamos hacer esto en WordPress:

$original_array = [...]; 
$post_id        = get_the_ID();
$chunked_array  = array_chunk( $original_array, 10, true );

foreach( $chunked_array as $key => $array) {
    update_post_meta( 
        $post_id,
        '_wc_chunked_array_partial_'. $post_id,
        $array
    );
}

Otras lecturas

Para obtener más información, puede consultar el manual de PHP.