Wer in einem Webshop Suchergebnisse als Produktraster darstellen will, steht vor einer typischen Aufgabe: Ein Array mit Produkten soll nicht als einfache Liste erscheinen, sondern in Reihen mit jeweils vier Artikeln. Genau dafür gibt es array_chunk(). Die Funktion teilt ein Array in kleinere Teilarrays auf, die du anschließend einzeln verarbeiten kannst.
Neben Produktrastern eignet sich array_chunk() auch für Paginierung, Batch-Verarbeitung von Datenbankeinträgen und überall dort, wo du große Datenmengen portionsweise abarbeiten musst. In diesem Tutorial lernst du die Syntax, alle Parameter, typische Edge Cases und praxisnahe Anwendungsbeispiele kennen.
Syntax von array_chunk()
Die Funktion array_chunk() erwartet zwei Pflichtparameter und einen optionalen dritten:
array_chunk(array $array, int $length, bool $preserve_keys = false): array
Der Rückgabewert ist immer ein numerisch indiziertes Array (ab Index 0), dessen Elemente die einzelnen Teilarrays sind.
Parameter im Detail
Der erste Parameter $array ist das Eingabearray, das du aufteilen möchtest. Es kann numerisch oder assoziativ sein. Der zweite Parameter $length bestimmt, wie viele Elemente jedes Teilarray maximal enthalten soll. Ist die Gesamtzahl der Elemente nicht durch $length teilbar, enthält das letzte Teilarray entsprechend weniger Elemente.
Der optionale dritte Parameter $preserve_keys steuert die Schlüsselvergabe. Steht er auf false (Standard), werden die Schlüssel in jedem Teilarray bei 0 neu nummeriert. Bei true bleiben die ursprünglichen Schlüssel erhalten.
Grundlagen: So funktioniert array_chunk()
Ein einfaches Beispiel zeigt, wie array_chunk() ein Array in Teilarrays zerlegt:
<?php
$planeten = ['merkur', 'venus', 'erde', 'mars', 'jupiter'];
$gruppen = array_chunk($planeten, 2);
print_r($gruppen);
?>
Ausgabe:
Array
(
[0] => Array
(
[0] => merkur
[1] => venus
)
[1] => Array
(
[0] => erde
[1] => mars
)
[2] => Array
(
[0] => jupiter
)
)
Das Array mit fünf Planeten wird in drei Teilarrays zerlegt. Die ersten beiden enthalten je zwei Elemente, das letzte nur eines. Die Schlüssel werden in jedem Teilarray bei 0 neu vergeben.
Schlüssel beibehalten mit $preserve_keys
Wenn du $preserve_keys = true übergibst, bleiben die Original-Schlüssel in den Teilarrays erhalten. Das ist wichtig, wenn die Schlüssel eine Bedeutung tragen, zum Beispiel als Datenbank-IDs:
<?php
$produkte = [
101 => 'T-Shirt',
102 => 'Jeans',
103 => 'Sneaker',
104 => 'Jacke',
105 => 'Mütze'
];
$chunks = array_chunk($produkte, 2, true);
print_r($chunks);
?>
Ausgabe:
Array
(
[0] => Array
(
[101] => T-Shirt
[102] => Jeans
)
[1] => Array
(
[103] => Sneaker
[104] => Jacke
)
[2] => Array
(
[105] => Mütze
)
)
Die Produkt-IDs 101 bis 105 bleiben als Schlüssel erhalten. Ohne $preserve_keys = true würden sie auf 0, 1, 2 zurückgesetzt.
Praktische Anwendung: Produktraster im Webshop
Der häufigste Einsatz von array_chunk() ist die Darstellung von Daten in einem Raster. Im folgenden Beispiel werden Produkte aus einer Datenbank in Viererreihen angezeigt:
<?php
$produkte = [
['id' => 101, 'name' => 'T-Shirt', 'preis' => 19.99],
['id' => 102, 'name' => 'Jeans', 'preis' => 49.99],
['id' => 103, 'name' => 'Sneaker', 'preis' => 79.99],
['id' => 104, 'name' => 'Jacke', 'preis' => 99.99],
['id' => 105, 'name' => 'Mütze', 'preis' => 14.99],
['id' => 106, 'name' => 'Schal', 'preis' => 24.99],
];
$produktReihen = array_chunk($produkte, 4);
foreach ($produktReihen as $reihe) {
echo '<div class="produktreihe">';
foreach ($reihe as $produkt) {
echo '<div class="produkt">';
echo '<h3>' . htmlspecialchars($produkt['name']) . '</h3>';
$preis = number_format($produkt['preis'], 2, ',', '.');
echo '<p>Preis: ' . $preis . ' €</p>';
echo '</div>';
}
echo '</div>';
}
?>
Die äußere foreach-Schleife iteriert über die Reihen, die innere über die Produkte innerhalb einer Reihe. Der Preis wird mit number_format() formatiert. Du kannst die Anzahl der Produkte pro Zeile jederzeit anpassen, indem du den zweiten Parameter von array_chunk() änderst.
Edge Cases und Fehlerbehandlung
Bevor du array_chunk() in produktivem Code einsetzt, solltest du die Grenzfälle kennen. Seit PHP 8.0 wirft die Funktion einen ValueError, wenn der Parameter $length kleiner als 1 ist.
$length = 0 oder negativ (ValueError seit PHP 8.0)
<?php
try {
$ergebnis = array_chunk([1, 2, 3], 0);
} catch (ValueError $e) {
echo $e->getMessage();
/* array_chunk(): Argument #2 ($length)
must be greater than 0 */
}
?>
Der gleiche Fehler tritt bei negativen Werten auf. In PHP 7.x wurde stattdessen eine E_WARNING ausgegeben und null zurückgegeben.
$length größer als die Array-Länge
<?php
$farben = ['rot', 'blau', 'gruen'];
$chunks = array_chunk($farben, 10);
print_r($chunks);
/* Ergebnis: Ein äußeres Array mit einem
einzigen Teilarray, das alle Elemente enthält */
?>
Leeres Eingabe-Array
<?php
$leer = [];
$chunks = array_chunk($leer, 5);
print_r($chunks);
/* Ergebnis: Array() - ein leeres Array */
?>
Bei einem leeren Eingabe-Array gibt array_chunk() ein leeres Array zurück. Es werden keine leeren Teilarrays erzeugt.
Batch-Verarbeitung mit array_chunk()
Einer der wichtigsten Anwendungsfälle in der Praxis ist die Batch-Verarbeitung. Statt tausende Datensätze einzeln in die Datenbank einzufügen, teilst du sie in Gruppen auf und verarbeitest jede Gruppe mit einem einzigen Query:
<?php
$benutzer = [
['name' => 'Anna', 'email' => 'anna@test.de'],
['name' => 'Ben', 'email' => 'ben@test.de'],
['name' => 'Clara', 'email' => 'clara@test.de'],
['name' => 'David', 'email' => 'david@test.de'],
/* ... 500 weitere Einträge */
];
$batches = array_chunk($benutzer, 50);
foreach ($batches as $nr => $batch) {
$werte = [];
foreach ($batch as $user) {
$name = $pdo->quote($user['name']);
$email = $pdo->quote($user['email']);
$werte[] = "({$name}, {$email})";
}
$sql = 'INSERT INTO users (name, email) VALUES '
. implode(', ', $werte);
$pdo->exec($sql);
echo 'Batch ' . ($nr + 1) . ': '
. count($batch) . " Einträge eingefügt\n";
}
?>
Dieses Vorgehen hat mehrere Vorteile: Ein einzelner INSERT mit 50 Datensätzen ist deutlich schneller als 50 einzelne INSERTs. Gleichzeitig vermeidest du das Risiko, dass ein INSERT mit tausenden Werten die maximale Paketgröße der Datenbank überschreitet.
Paginierung mit array_chunk()
Für kleine Datenmengen, die bereits vollständig im Speicher liegen, kannst du array_chunk() zur Paginierung verwenden:
<?php
$alleArtikel = [/* 87 Artikel aus dem Cache */];
$proSeite = 10;
$seiten = array_chunk($alleArtikel, $proSeite);
$gesamtSeiten = count($seiten);
/* Aktuelle Seite aus der URL lesen und validieren */
$aktuelleSeite = max(1, min(
(int)($_GET['seite'] ?? 1),
$gesamtSeiten
));
$eintraege = $seiten[$aktuelleSeite - 1];
echo 'Seite ' . $aktuelleSeite
. ' von ' . $gesamtSeiten . "\n";
foreach ($eintraege as $artikel) {
echo $artikel . "\n";
}
?>
Bei großen Datenmengen (ab einigen tausend Einträgen) gehört die Paginierung allerdings in die SQL-Query mit LIMIT und OFFSET. array_chunk() ist nur dann sinnvoll, wenn die Daten ohnehin schon im Speicher liegen.
Chunks wieder zusammenführen
Manchmal musst du aufgeteilte Arrays wieder zu einem einzigen Array zusammensetzen. Dafür kombinierst du array_merge() mit dem Spread-Operator:
<?php
$chunks = [['a', 'b'], ['c', 'd'], ['e']];
$zusammen = array_merge(...$chunks);
print_r($zusammen);
/* Ergebnis: ['a', 'b', 'c', 'd', 'e'] */
?>
Der Spread-Operator ... entpackt die Teilarrays, sodass array_merge() sie zu einem flachen Array zusammenfügen kann.
Vergleich: array_chunk() vs. array_slice()
Auf den ersten Blick wirken array_chunk() und array_slice() ähnlich, denn beide arbeiten mit Teilbereichen eines Arrays. Der Unterschied liegt im Ergebnis: array_chunk() teilt das gesamte Array automatisch in gleichmäßige Portionen auf. array_slice() holt dagegen einen einzelnen Ausschnitt an einer bestimmten Position.
<?php
$zahlen = [10, 20, 30, 40, 50, 60];
/* array_chunk: Alle Elemente in 3er-Gruppen */
$chunks = array_chunk($zahlen, 3);
/* [[10, 20, 30], [40, 50, 60]] */
/* array_slice: Nur Element 2 bis 4 */
$ausschnitt = array_slice($zahlen, 1, 3);
/* [20, 30, 40] */
?>
Verwende array_chunk(), wenn du das komplette Array in Portionen aufteilen willst. Greife zu array_slice(), wenn du einen bestimmten Bereich aus dem Array benötigst.
Vergleich mit array_merge() und array_combine()
Während array_chunk() ein Array aufteilt, führen andere Funktionen Arrays zusammen. Ein kurzer Überblick über die Unterschiede:
array_merge() fügt mehrere Arrays zu einem einzigen Array zusammen. Numerische Schlüssel werden neu nummeriert, assoziative Schlüssel bleiben erhalten:
<?php
$a = ['rot', 'blau'];
$b = ['gruen', 'gelb'];
$zusammen = array_merge($a, $b);
/* ['rot', 'blau', 'gruen', 'gelb'] */
?>
array_combine() erstellt ein neues Array, indem ein Array von Schlüsseln mit einem Array von Werten kombiniert wird. Die Anzahl der Elemente muss in beiden Arrays gleich sein:
<?php
$keys = ['rot', 'gruen', 'blau'];
$values = ['Apfel', 'Blatt', 'Himmel'];
$kombiniert = array_combine($keys, $values);
/* ['rot' => 'Apfel', 'gruen' => 'Blatt', 'blau' => 'Himmel'] */
?>
Hinweis für sehr große Arrays
array_chunk() erstellt eine vollständige Kopie aller Daten in neuen Arrays. Bei Arrays mit hunderttausenden Elementen kann der Speicherverbrauch dadurch stark ansteigen. Für solche Fälle bieten sich Generatoren mit yield als Alternative an. Ein Generator liefert die Elemente portionsweise, ohne das gesamte Ergebnis im Speicher zu halten.
Bei Datenbank-Abfragen ist es in der Regel besser, die Portionierung direkt in der SQL-Query mit LIMIT und OFFSET zu erledigen, statt zuerst alle Daten zu laden und anschließend mit array_chunk() aufzuteilen.
Häufige Fragen zu array_chunk()
Warum sind die Schlüssel in meinen Chunks falsch?
Standardmäßig nummeriert array_chunk() die Schlüssel in jedem Teilarray neu (beginnend bei 0). Wenn du die Original-Schlüssel behalten willst, setze den dritten Parameter auf true:
<?php
$chunks = array_chunk($meinArray, 5, true);
?>
Kann ich array_chunk() rückgängig machen?
Ja. Verwende array_merge() mit dem Spread-Operator, um die Teilarrays wieder zu einem einzigen Array zusammenzuführen: array_merge(...$chunks).
Was passiert mit dem letzten Chunk?
Wenn die Gesamtzahl der Elemente nicht durch $length teilbar ist, enthält der letzte Chunk weniger Elemente. Es wird kein Padding mit leeren Werten durchgeführt. Die count()-Funktion verrät dir, wie viele Elemente ein Teilarray tatsächlich enthält.
Wie teile ich ein Array in genau N gleich große Teile?
Berechne die Chunk-Größe mit ceil():
<?php
$daten = range(1, 17);
$anzahlTeile = 4;
$groesse = (int)ceil(count($daten) / $anzahlTeile);
$teile = array_chunk($daten, $groesse);
/* 4 Teile mit je 5, 5, 5 und 2 Elementen */
?>
Fazit
array_chunk() ist ein vielseitiges Werkzeug, um Arrays in gleichmäßige Portionen aufzuteilen. Ob Produktraster, Batch-Inserts oder Paginierung: Die Funktion nimmt dir die manuelle Aufteilung ab und produziert saubere Teilarrays. Denke daran, $preserve_keys zu setzen, wenn die Schlüssel eine Bedeutung tragen, und verwende bei sehr großen Datenmengen lieber datenbankbasierte Paginierung oder Generatoren.
