PHP array_splice: Arrays in PHP manipulieren

Oft müssen wir in unseren Arrays Werte an bestimmten Stellen einfügen, löschen oder ersetzen.
Dafür stehen uns in PHP einige Funktionen zur Verfügung.
Eine der vielseitigsten ist array_splice, welche ich hier anhand von einigen Codebeispielen genauer zeigen möchte.

array_splice – einfache Anwendung

Die Funktion array_splice ist äußerst vielfältig. Mit ihr kannst du Elemente aus Arrays löschen, ersetzen und auch hinzufügen.

array_splice(&$array, $versatz, $anzahl=count($array), $ersatz=[])
    &$array (erforderlich)
        Das zu bearbeitende Array
    $versatz (erforderlich)
        Indexposition, ab der gelöscht oder ersetzt werden soll
    $anzahl (optional)
        Anzahl Elemente, die gelöscht oder ersetzt werden sollen
        Standardwert ist die Gesamtanzahl der Elemente von $array
    $ersatz (optional)
        Werte, mit denen ersetzt wird
        Standardwert ist ein leeres Array

Die Funktion gibt die aus dem übergebenen Array gelöschten Werte als Array zurück. Da das ursprüngliche Array per Referenz übergeben wurde, sind die von der Funktion zurückgegebenen Werte nicht mehr darin vorhanden. Du kannst auch ein Objekt statt ein Array übergeben, allerdings wird dieses dann in ein Array umgewandelt, was unter Umständen zu unvorhergesehenen Resultaten führen kann.
Teste unbedingt zuvor, wie sich dein Objekt verhält, wenn du es in ein Array konvertierst.

Elemente aus Arrays mit PHP array_splice löschen

Am Einfachsten ist das Löschen von Elementen, wozu du lediglich 2 Parameter angeben musst.
Das Array selbst und den $versatz-Parameter, also die Position ab der gelöscht wird.

$array = [0, 1, 2, 3];
$entfernt = array_splice($array, 2);

print_r($array);
// Array ( [0] => 0 [1] => 1 )

print_r($entfernt);
// Array ( [0] => 2 [1] => 3 )

Hier siehst du, dass alle Elemente ab der zweiten Position aus dem ursprünglichen Array entfernt wurden und in einem neuen Array ausgegeben wurden.
Du kannst für $versatz auch negative Zahlen angeben.
Bei negativen Zahlen verhält sich $versatz relativ zum Ende des Arrays.
Wenn du zum Beispiel -1 angibst, wird nur das letzte Element gelöscht.

$array = ['foo', 'bar', 'baz'];
$entfernt = array_splice($array, -1);

print_r($array);
// Array ( [0] => foo [1] => bar )

print_r($entfernt);
// Array ( [0] => baz )

Mit dem dritten Parameter kannst du genauer festlegen, wie viele Elemente gelöscht werden sollen. Wenn du beispielsweise 1 für $anzahl festlegst, wird nur ein Element entfernt.

$array = [0, 1, 2, 3];
$entfernt = array_splice($array, 2, 1);

print_r($array);
// Array ( [0] => 0 [1] => 1 [2] => 3 )

print_r($entfernt);
// Array ( [0] => 2 )

Auch diesen kannst du als negative Zahl übergeben.
Wenn du das tust, werden alle Elemente bis zum Ende des Arrays entfernt bis auf die Anzahl, die du angegeben hast.
Bei -1 werden alle Elemente ab $versatz entfernt, außer das Letzte.

$array = ['code', 'citrus', 'foo', 'bar', 'baz', 42];
$entfernt = array_splice($array, 2, -1);

print_r($array);
// Array ( [0] => code [1] => citrus [2] => 42 )

print_r($entfernt);
// Array ( [0] => foo [1] => bar [2] => baz )

Elemente in Arrays mit PHP array_splice einfügen

Für den vierten Parameter, $ersatz, kannst du verschiedene Werte angeben. Diese werden allerdings automatisch in ein Array konvertiert, was bei manchen Objekten zu unerwartetem Verhalten führen kann. Um einen Wert an einer bestimmten Stelle einzufügen, kannst du diese mit $versatz bestimmen, $anzahl auf 0 setzen und den Wert als $ersatz angeben.

$array = [0, 1, 2, 3, 4, 5];
$entfernt = array_splice($array, 2, 0, 42);

print_r($array);
// Array ( [0] => 0 [1] => 1 [2] => 42 [3] => 2 [4] => 3 [5] => 4 [6] => 5 )

print_r($entfernt);
// Array ( )

Elemente in Arrays mit PHP array_splice ersetzen

Wenn du sowohl den dritten wie auch den vierten Parameter festlegst, kannst du Werte ersetzen.

$array = [0, 1, 2, 3, 4, 5];
$entfernt = array_splice($array, 2, 2, 42);

print_r($array);
// Array ( [0] => 0 [1] => 1 [2] => 42 [3] => 4 [4] => 5 )

print_r($entfernt);
// Array ( [0] => 2 [1] => 3 )

Du siehst, hier wurde eigentlich weniger ersetzt, mehr Werte entfernt und dann ab da, wo sie entfernt wurden, wieder Werte eingesetzt.
Um alle Werte bis zum Ende des Arrays zu entfernen, kannst du zusätzlich mit der Funktion count die Anzahl der Werte im Array ermitteln.
Diese kannst du dann als $anzahl übergeben.

$array = [0, 1, 2, 3, 4, 5];
$entfernt = array_splice($array, 2, count($array), 42);

print_r($array);
// Array ( [0] => 0 [1] => 1 [2] => 42 )

print_r($entfernt);
// Array ( [0] => 2 [1] => 3 [2] => 4 [3] => 5 )

Genau so funktioniert die Ersetzung auch mit einem Array statt einer Zahl.

$array = [0, 1, 2, 3, 4, 5];
$entfernt = array_splice($array, 2, count($array), [42, 64]);

print_r($array);
// Array ( [0] => 0 [1] => 1 [2] => 42 [3] => 64 )

print_r($entfernt);
// Array ( [0] => 2 [1] => 3 [2] => 4 [3] => 5 )

PHP array_splice in Kombination mit assoziativen und mehrdimensionalen Arrays

array_splice kann auch auf assoziative Arrays angewendet werden. Zu beachten ist, dass sich der Wert von numerischen Schlüsseln im Rückgabearray ändern kann. Außerdem werden Schlüssel aus dem Ersatzarray nicht beibehalten. Das folgende Beispiel entfernt alle Elemente außer dem Ersten und dem Letzten und fügt zwei neue ein. Die Anwendung funktioniert hier genau so wie in den vorigen Beispielen.

$array = ['code'=>'citrus', 1=>2, 'a'=>'b', 'x'=>'y', 'foo'=>'bar'];
$entfernt = array_splice($array, 1, -1, [0=>1, 'z'=>'a']);

print_r($array);
// Array ( [code] => citrus [0] => 1 [1] => a [foo] => bar )

print_r($entfernt);
// Array ( [0] => 2 [a] => b [x] => y )

Ebenfalls kannst du Werte innerhalb mehrdimensionaler Arrays verändern.
Dabei musst du primär beachten, wie du das zu bearbeitende Array angibst.
Du solltest das innere Array, das bearbeitet wird hierbei mit seinem Schlüssel angeben.

$array = [
    ['code'=>'citrus'],
    'foo'=>['a'=>'b', 'w'=>'a', 's'=>'d','x'=>'y']
];
$entfernt = array_splice($array['foo'], 1, -1, [0=>1, 'z'=>'a']);

print_r($array);
/*
Array (
    [0] => Array ( [code] => citrus )
    [foo] => Array ( [a] => b [0] => 1 [1] => a [x] => y )
)
/**/

print_r($entfernt);
// Array ( [w] => a [s] => d )

Fazit

Die Funktion array_splice ist bestens geeignet zum löschen, hinzufügen und ersetzen von Elementen an vorgegebenen Stellen. Einzig bei assoziativen Arrays müssen wir hier vorsichtig sein, wenn wichtig ist, dass die Schlüssel der Schlüssel-Wert-Paare hier gleich bleiben.

Hast du Fragen, Anregungen, Lob, Kritik, Fehler gefunden? Lass es mich bitte in den Kommentaren wissen.