Beim Arbeiten mit Arrays in PHP steht man häufig vor der Aufgabe, nur einen bestimmten Ausschnitt der enthaltenen Daten weiterzuverarbeiten. Die Funktion array_slice() bietet genau diese Möglichkeit: Sie extrahiert ein Teilarray aus einem bestehenden Array, ohne das Original zu verändern. Pagination, das Aufteilen von Datensätzen oder das gezielte Herauslösen einzelner Abschnitte sind typische Einsatzgebiete. In diesem Tutorial werden Syntax, Parameter und typische Anwendungsfälle Schritt für Schritt erklärt.
Zuerst werden die vier Parameter der Funktion im Detail vorgestellt. Danach zeigen Beispiele, wie Offset, Length und negative Werte in der Praxis zusammenspielen.
Syntax und Parameter
Bevor die Funktion in der Praxis zum Einsatz kommt, lohnt sich ein Blick auf ihren Aufbau. Die Signatur von array_slice() umfasst vier Parameter, von denen zwei optional sind.
<?php
array_slice(
array $array,
int $offset,
?int $length = null,
bool $preserve_keys = false
);
Der erste Parameter ist das Quell-Array, aus dem der Ausschnitt entnommen werden soll. Der zweite Parameter, der Offset, legt die Startposition fest. Diese Position ist 0-basiert, das heißt, das erste Element hat den Index 0. Der dritte Parameter Length bestimmt, wie viele Elemente ab der Startposition entnommen werden. Wird er weggelassen oder auf null gesetzt, liefert die Funktion alle Elemente ab dem Offset bis zum Ende des Arrays. Der vierte Parameter preserve_keys steuert, ob die ursprünglichen numerischen Keys im neuen Array erhalten bleiben sollen.
Das folgende Diagramm veranschaulicht den grundlegenden Ablauf der Funktion.
flowchart TD
A[Quell-Array] --> B[Offset]
B --> C{Length?}
C -- Ja --> D[length Elemente]
C -- Nein --> E[Alle ab Offset]
D --> F{preserve_keys?}
E --> F
F -- Ja --> G[Original-Keys]
F -- Nein --> H[Neue Keys ab 0]
G --> I[Original bleibt]
H --> I
Grundlegende Beispiele
Die folgenden Beispiele zeigen die häufigsten Einsatzszenarien von array_slice() und verdeutlichen, wie Offset und Length zusammenwirken.
Elemente ab einer Position extrahieren
Wird nur ein Offset ohne Length angegeben, enthält das Ergebnis alle Elemente ab dieser Position bis zum Ende des Arrays. Das Original bleibt dabei unverändert.
<?php
$farben = ["Rot", "Grün", "Blau", "Gelb", "Lila"];
/* Alle Elemente ab Position 2 */
$ergebnis = array_slice($farben, 2);
print_r($ergebnis);
/*
Array
(
[0] => Blau
[1] => Gelb
[2] => Lila
)
*/
/* Das Original-Array ist unverändert */
print_r($farben);
/*
Array
(
[0] => Rot
[1] => Grün
[2] => Blau
[3] => Gelb
[4] => Lila
)
*/
Das Teilarray beginnt bei Position 2, also beim dritten Element. Die numerischen Keys werden im Ergebnis standardmäßig bei 0 neu begonnen.
Eine bestimmte Anzahl von Elementen
Durch Angabe des Length-Parameters lässt sich die Größe des Slice präzise festlegen. Das ist besonders nützlich für Pagination oder das Anzeigen einer begrenzten Ergebnismenge.
<?php
$staedte = ["Berlin", "Hamburg", "München", "Köln", "Frankfurt", "Stuttgart"];
/* 3 Elemente ab Position 1 */
$seite = array_slice($staedte, 1, 3);
print_r($seite);
/*
Array
(
[0] => Hamburg
[1] => München
[2] => Köln
)
*/
/* Pagination: Seite 2 mit 2 Einträgen pro Seite */
$pro_seite = 2;
$aktuelle_seite = 2;
$offset = ($aktuelle_seite - 1) * $pro_seite;
$seite_2 = array_slice($staedte, $offset, $pro_seite);
print_r($seite_2);
/*
Array
(
[0] => München
[1] => Köln
)
*/
Liegt der berechnete Offset außerhalb der Array-Länge, gibt array_slice() ein leeres Array zurück. Eine Fehlerbehandlung ist daher in der Regel nicht nötig.
Negative Werte für Offset und Length
Sowohl der Offset als auch der Length-Parameter akzeptieren negative Werte. Diese ermöglichen das Zählen vom Ende des Arrays aus und bieten damit eine flexible Alternative zur Berechnung absoluter Positionen.
Vom Ende des Arrays zählen
Ein negativer Offset bewirkt, dass die Startposition vom Ende des Arrays aus bestimmt wird. Der Wert -1 entspricht dabei dem letzten Element, -2 dem vorletzten und so weiter.
<?php
$monate = ["Jan", "Feb", "Mär", "Apr", "Mai", "Jun",
"Jul", "Aug", "Sep", "Okt", "Nov", "Dez"];
/* Die letzten 3 Monate */
$quartal_4 = array_slice($monate, -3);
print_r($quartal_4);
/*
Array
(
[0] => Okt
[1] => Nov
[2] => Dez
)
*/
/* 4 Elemente, beginnend beim 5.-letzten */
$auswahl = array_slice($monate, -5, 4);
print_r($auswahl);
/*
Array
(
[0] => Aug
[1] => Sep
[2] => Okt
[3] => Nov
)
*/
Negativer Offset ist besonders praktisch, wenn die genaue Länge des Arrays nicht bekannt ist oder sich dynamisch ändert.
Elemente vor dem Ende abschneiden
Ein negativer Wert für Length bedeutet, dass die angegebene Anzahl von Elementen am Ende des Arrays weggelassen wird. Das Ergebnis endet also nicht bei einer festen Länge, sondern vor einer bestimmten Position vom Ende aus gerechnet.
<?php
$zahlen = [10, 20, 30, 40, 50, 60, 70, 80];
/* Ab Position 1, aber die letzten 2 weglassen */
$mitte = array_slice($zahlen, 1, -2);
print_r($mitte);
/*
Array
(
[0] => 20
[1] => 30
[2] => 40
[3] => 50
[4] => 60
)
*/
/* Ab Position 2, das letzte Element weglassen */
$ohne_enden = array_slice($zahlen, 2, -1);
print_r($ohne_enden);
/*
Array
(
[0] => 30
[1] => 40
[2] => 50
[3] => 60
[4] => 70
)
*/
Diese Kombination aus positivem Offset und negativem Length eignet sich hervorragend, um sowohl den Anfang als auch das Ende eines Arrays abzuschneiden und nur den mittleren Bereich zu erhalten.
Keys beibehalten mit preserve_keys
Standardmäßig nummeriert array_slice() die numerischen Keys im Ergebnis neu, beginnend bei 0. Durch Setzen des vierten Parameters preserve_keys auf true bleiben die ursprünglichen Indizes erhalten. Das ist wichtig, wenn die Position eines Elements innerhalb des Original-Arrays eine Rolle spielt.
<?php
$werte = ["A", "B", "C", "D", "E"];
/* Ohne preserve_keys (Standard) */
$ohne = array_slice($werte, 2, 3);
print_r($ohne);
/*
Array
(
[0] => C
[1] => D
[2] => E
)
*/
/* Mit preserve_keys */
$mit = array_slice($werte, 2, 3, true);
print_r($mit);
/*
Array
(
[2] => C
[3] => D
[4] => E
)
*/
Eine wichtige Besonderheit: Der Parameter preserve_keys betrifft ausschließlich numerische Keys. String-Keys werden unabhängig von dieser Einstellung immer beibehalten. Wer also mit einem assoziativen Array arbeitet, muss sich um diesen Parameter nicht kümmern.
array_slice bei assoziativen Arrays
Bei assoziativen Arrays funktioniert array_slice() nach dem gleichen Prinzip. Der Offset bezieht sich auf die Reihenfolge der Elemente, nicht auf deren Keys. Die String-Keys bleiben im resultierenden Teilarray stets erhalten.
<?php
$person = [
"name" => "Anna Müller",
"alter" => 32,
"stadt" => "Berlin",
"beruf" => "Entwicklerin",
"sprache" => "PHP"
];
/* 2 Elemente ab Position 1 */
$ausschnitt = array_slice($person, 1, 2);
print_r($ausschnitt);
/*
Array
(
[alter] => 32
[stadt] => Berlin
)
*/
/* Die letzten 3 Einträge */
$ende = array_slice($person, -3);
print_r($ende);
/*
Array
(
[stadt] => Berlin
[beruf] => Entwicklerin
[sprache] => PHP
)
*/
Wie zu sehen ist, bleiben die String-Keys alter, stadt, beruf und sprache automatisch erhalten. Das Verhalten ist identisch, egal ob preserve_keys auf true oder false steht.
array_slice vs. array_splice
Beide Funktionen klingen ähnlich, unterscheiden sich jedoch in einem entscheidenden Punkt. array_slice() liest einen Ausschnitt aus dem Array und gibt diesen als neues Array zurück. Das Original-Array bleibt vollständig unverändert. array_splice() hingegen entfernt den angegebenen Bereich aus dem Original-Array und kann optional neue Elemente an der gleichen Stelle einfügen. Sie verändert das Array also destruktiv.
<?php
$original_a = [1, 2, 3, 4, 5];
$original_b = [1, 2, 3, 4, 5];
/* array_slice: Original bleibt unverändert */
$slice_ergebnis = array_slice($original_a, 1, 3);
echo "Nach array_slice:" . PHP_EOL;
print_r($original_a);
/*
Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
[4] => 5
)
*/
/* array_splice: Original wird verändert */
$splice_ergebnis = array_splice($original_b, 1, 3);
echo "Nach array_splice:" . PHP_EOL;
print_r($original_b);
/*
Array
(
[0] => 1
[1] => 5
)
*/
Die Verwechslung dieser beiden Funktionen ist eine häufige Stolperfalle. array_slice() ist die richtige Wahl, wenn das Quell-Array später noch in seiner ursprünglichen Form benötigt wird. array_splice() kommt dann zum Einsatz, wenn Elemente tatsächlich entfernt oder ersetzt werden sollen.
Weitere häufige Fehlerquellen sind die falsche Interpretation negativer Length-Werte, die nicht etwa eine negative Anzahl bedeuten, sondern das Weglassen von Elementen am Ende steuern. Außerdem sollte beachtet werden, dass ein Offset, der größer als die Länge des Arrays ist, kein Fehler auslöst, sondern schlicht ein leeres Array liefert.
Fazit
Die Funktion array_slice() ist ein zuverlässiges Werkzeug zum Extrahieren von Teilbereichen aus Arrays in PHP. Durch die flexible Kombination von Offset und Length lassen sich sowohl einfache als auch komplexe Ausschnitte definieren. Negative Werte ermöglichen das Zählen vom Ende des Arrays, und der Parameter preserve_keys gibt Kontrolle über die Indizierung des Ergebnisses. Da array_slice() das Original-Array nicht verändert, eignet sie sich besonders gut für Szenarien, in denen Daten nur gelesen und nicht manipuliert werden sollen. Wer hingegen Elemente entfernen oder ersetzen möchte, greift zu array_splice(). Mit dem Wissen aus diesem Tutorial lässt sich array_slice() gezielt und sicher in eigenen Projekten einsetzen.
