La puissance de la fonction array_chunk en PHP

PHP possède une grande collection de fonctions intégrées pour les arrays, et array_chunk() est l'une des plus utiles pour travailler avec de grands ensembles de données. Elle divise un seul array en une série de plus petits arrays (des « morceaux ») de taille fixe, ce qui facilite la pagination, le traitement par lots et la mise en page des données. Ce chapitre explique la syntaxe, présente des exemples exécutables, couvre le paramètre preserve_keys et signale les erreurs courantes.

Qu'est-ce que la fonction array_chunk ?

La fonction array_chunk() divise un array en plus petits arrays contenant chacun un nombre d'éléments spécifié. Elle est utile chaque fois que vous devez découper une longue liste en groupes de taille égale — par exemple, afficher une grille de N colonnes, traiter des enregistrements par lots ou construire une sortie paginée.

Syntaxe

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

Valeur de retour : un nouvel array multidimensionnel. L'array d'origine n'est jamais modifié — array_chunk() ne fonctionne pas en place.

Comment fonctionne array_chunk ?

array_chunk() parcourt l'array d'entrée dans l'ordre et copie les éléments dans un nouveau sous-array jusqu'à atteindre $length éléments, puis commence un nouveau morceau. Le dernier morceau contient ce qui reste, il peut donc être plus petit que les autres.

Par défaut, le troisième paramètre, preserve_keys, vaut false, ce qui réindexe les clés de chaque morceau à partir de 0. Le passer à true conserve les clés d'origine de l'array — important lorsque ces clés ont une signification (comme des clés de type string ou des identifiants non séquentiels).

Par exemple, considérons l'array suivant :

PHP define an array

Si nous appelons array_chunk sur cet array en passant 3 comme deuxième argument, nous obtenons le résultat suivant :

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

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

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

Comme vous pouvez le voir, l'array d'origine a été divisé en trois plus petits arrays contenant chacun trois éléments (à l'exception du dernier array, qui n'en contient qu'un seul).

Conserver les clés d'origine

Par défaut, chaque morceau est réindexé à partir de 0. Passez true comme troisième argument pour conserver les clés d'origine à la place :

<?php

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

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

?>

Sortie :

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

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

Gardez preserve_keys à true chaque fois que les clés identifient les données (clés de type string, identifiants de base de données, etc.) ; sinon elles sont perdues lors du prochain réindexage.

Pourquoi utiliser array_chunk ?

La fonction array_chunk est extrêmement utile pour diverses applications, notamment :

• Découper de grands arrays en parties plus petites et plus faciles à traiter.
• Afficher de grandes quantités de données de manière paginée (par exemple, diviser un array de résultats en plus petits arrays à afficher sur plusieurs pages).
• Améliorer les performances des algorithmes qui opèrent sur des arrays en réduisant la taille des arrays traités à un instant donné.

Exemple d'utilisation : pagination

L'un des cas d'utilisation les plus courants de la fonction array_chunk est la pagination. Considérons l'exemple suivant, où nous avons un array de 12 résultats à afficher sur 2 pages :

Example of php array_chunk function

array_chunk() divise les 12 résultats en 2 pages : le premier morceau contient 10 éléments et le second contient les 2 restants. Chaque morceau correspond directement à une page, vous pouvez donc afficher $pages[0] pour la page 1, $pages[1] pour la page 2, et utiliser count($pages) pour construire les liens de pagination.

Erreurs courantes

• $length doit être au moins 1. Une valeur de 0 ou un nombre négatif lève une ValueError en PHP 8 et émettait un avertissement en PHP 7.
• L'array d'origine n'est pas modifié. array_chunk() retourne un nouvel array ; assignez le résultat, ne vous attendez pas à ce qu'il modifie l'entrée.
• L'ordre est préservé, les clés ne le sont pas (par défaut). Les éléments restent dans leur ordre d'origine, mais les clés numériques sont réinitialisées de 0..n sauf si vous passez preserve_keys = true.
• Le dernier morceau peut être plus petit. Gérez toujours un morceau final plus petit que $length lors d'une itération.

Fonctions associées

• array_slice() — extraire une seule portion contiguë d'un array au lieu de le diviser entièrement.
• array_splice() — supprimer ou remplacer une portion d'un array en place.
• array_merge() — combiner plusieurs arrays en un seul.
• array_map() — appliquer une fonction de rappel à chaque morceau après la division.
• PHP Arrays — une révision des arrays indexés et associatifs.

Conclusion

La fonction array_chunk() est un moyen simple et efficace de diviser un grand array en parties plus petites de taille égale. Que vous paginiez des résultats, traitiez des enregistrements par lots ou mettiez en page une grille, elle garde la manipulation des arrays lisible et prévisible. Souvenez-vous des deux règles qui piègent les développeurs : la taille du morceau doit être au moins 1, et les clés sont réindexées sauf si vous demandez à les conserver.

Pratique