1. array_slice()
Die Funktion array_slice($arr, $offset, $length, $preserve_keys) gibt alle Elemente des Arrays $arr zurück, welche zwischen der Stelle $offset und $offset+$length liegen ($offset+$length nicht einschließlich). Der Parameter $preserve_keys legt fest, ob die Schlüssel beibehalten oder neu generiert werden sollen. (Im Falle des Neugenerierens werden sie von 0 an durchnummeriert, also 0, 1, 2, 3, ...) $length und $preserve_keys sind optional. Wird $length nicht angegeben, dann interpretiert dies PHP standardmäßig als „bis zum Ende des Arrays”. Der Default-Wert für $preserve_keys wiederum ist false — standardmäßig werden die Schlüssel also neu generiert.
Das nächste Beispiel zeigt die Anwendung von array_slice(). Es wird ein Array mit 10 Elementen definiert, sowie die Position $offset festgelegt, vor/nach der die Elemente abgeschnitten werden sollen. $elementsBefore enthält nach Anwendung von array_slice() alle Elemente vor $offset (x<offset), $elementsAfter wiederum alle ab $offset (offset≤x).
<?php $arr = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); $offset = 3; $elementsBefore = array_slice($arr, 0, $offset, true); $elementsAfter = array_slice($arr, $offset, null, true); print_r($elementsBefore); print_r($elementsAfter); ?>
Array
(
[0] => 0
[1] => 1
[2] => 2
)
Array
(
[3] => 3
[4] => 4
[5] => 5
[6] => 6
[7] => 7
[8] => 8
[9] => 9
)
2. array_splice()
array_splice(&$arr, $offset, $length, $replacement) nimmt ein Array als Referenz entgegen und ersetzt alle Elemente ab $offset bis $offset+$length (nicht einschließlich, also $offset≤x<$offset+$length) durch $replacement. Wird $replacement leer gelassen (oder wird ein leeres Array verwendet), dann werden entsprechend die Elemente aus $arr entfernt. Die Rückgabe von array_splice() ist ein Array, welches alle Elemente enthält, die durch $replacement ersetzt wurden. Wie bei array_slice() wird auch hier das nicht-Angeben von $length als „bis zum Ende des Arrays” interpretiert.
Das nächste Beispiel demonstriert array_splice() und ist eng an das vorherige angelehnt. Wieder wird ein Array mit 10 Elementen erzeugt, aus dem die ersten drei und die letzten sieben (alles vor und alles ab Position 3) extrahiert werden sollen. array_splice() ermöglicht es, dies „in einem Rutsch” zu erledigen, da es das Array als Referenz empfängt und die Ersetzung daran durchführt, gleichzeitig aber auch die ersetzten Elemente zurückgibt.
<?php $arr = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9); $elementsBefore = array(); $elementsAfter = $arr; $offset = 3; $elementsBefore = array_splice($elementsAfter, 0, $offset); print_r($elementsBefore); print_r($elementsAfter); ?>
Array
(
[0] => 0
[1] => 1
[2] => 2
)
Array
(
[0] => 3
[1] => 4
[2] => 5
[3] => 6
[4] => 7
[5] => 8
[6] => 9
)
3. foreach-Schleife
Mit einer foreach-Schleife kann bequem über die Elemente im Array iteriert werden. Zählt man dabei eine Variable hoch, dann lässt sich bestimmen, an welcher Position sich das Element gerade befindet. Abhängig von dieser Position kann nun das Element ignoriert oder zu einem anderen Array hinzugefügt werden.
Der Einsatz einer foreach-Schleife ist umständlicher und weniger performant als array_slice() oder array_splice(). Letztere sollten daher bevorzugt verwendet werden. Nur in Fällen in denen man die größere Flexibilität einer foreach-Schleife benötigt sollte diese eingesetzt werden.
Das nächste Beispiel zeigt die Anwendung der foreach-Schleife, wieder im gewohnten Aufbau wie bei den vorherigen Beispielen. Es wird ein Array mit 10 Elementen definiert, der $offset festgelegt als Punkt vor und ab dem die Elemente extrahiert werden sollen und die Rückgabearrays $elementsBefore (alles vor $offset) und elementsAfter (alles ab $offset) initialisiert. Die Schleife iteriert nun über alle Elemente in $arr, zählt dabei die Variable $x hoch und fügt zu $elementsBefore oder $elementsAfter hinzu, je nachdem ob $x unterhalb oder oberhalb von $offset liegt.
<?php
$arr = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
$offset = 3;
// Rueckgabearrays
$elementsBefore = array();
$elementsAfter = array();
// Zaehlvariable
// Statt der Zaehlvariable koennte in diesem Beispiel auch die Variable $key der foreach-Schleife
// verwendet werden. Das funktioniert aber nur korrekt, wenn die Schluessel von 0 an durchnummeriert
// sind (0, 1, 2, ...), daher wird hier die robustere Variante ueber die Zaehlvariable gezeigt.
$x = 0;
foreach ($arr as $key=>$val) {
// Alles vor $offset zu $elementsBefore hinzufuegen,
// alles ab $offset zu $elementsAfter
if ($x<$offset) {
$elementsBefore[$key] = $val;
} else {
$elementsAfter[$key] = $val;
}
$x++;
}
print_r($elementsBefore);
print_r($elementsAfter);
?>
Array
(
[0] => 0
[1] => 1
[2] => 2
)
Array
(
[3] => 3
[4] => 4
[5] => 5
[6] => 6
[7] => 7
[8] => 8
[9] => 9
)
Das if-else-Statement in der Schleife könnte übrigens auch ersetzt werden durch den Einzeiler „${($x<$offset ? 'elementsBefore' : 'elementsAfter')}[] = $val;”. Das Ergebnis wäre identisch.
4. for-Schleife mit current() und next()
Ähnlich zur foreach-Schleife wird hier die for-Schleife angewendet. In diesem Fall wird allerdings zusätzlich auf die Funktionen current($arr), next($arr) und key($arr) zurückgegriffen. Diese beziehen sich auf das Element, auf das der interne Zeiger des Arrays $arr gerade gerichtet ist. current($arr) gibt den Wert dieses Elements zurück, key($arr) hingegen seinen Schlüssel. next($arr) setzt den Zeiger auf das nächste Element.
Dementsprechend ändert sich in diesem Beispiel gegenüber foreach nur der Kopf der Schleife, welcher nun die Zählvariable enthält, mit next($arr) über die Elemente springt und mit current($arr) prüft, ob das Ende erreicht wurde. In der if-Abfrage wurden $val durch current($arr) und $key durch key($arr) ersetzt.
<?php
$arr = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
$offset = 3;
$elementsBefore = array();
$elementsAfter = array();
for ($x=0; current($arr)!==false; $x++, next($arr)) {
if ($x<$offset) {
$elementsBefore[key($arr)] = current($arr);
} else {
$elementsAfter[key($arr)] = current($arr);
}
}
print_r($elementsBefore);
print_r($elementsAfter);
?>
Array
(
[0] => 0
[1] => 1
[2] => 2
)
Array
(
[3] => 3
[4] => 4
[5] => 5
[6] => 6
[7] => 7
[8] => 8
[9] => 9
)
5. while-Schleife mit each()
Auch die dritte vorgestellte Schleife verhält sich ähnlich zu den vorherigen beiden. Diesmal wird allerdings die Funktion each($arr) benutzt. Diese gibt den Schlüssel und Wert desjenigen Elements als Array zurück, auf das der interne Array-Zeiger gerade gerichtet ist. Der Aufbau des Rückgabearrays ist array(0=>Schlüssel, "key"=>Schlüssel, 1=>Wert, "value"=>Wert) — sowohl Wert als auch Schlüssel sind also jeweils zwei mal enthalten. Nach Aufruf von each() wird der Array-Zeiger automatisch auf das nächste Element gesetzt. Wurde das Ende des Arrays erreicht, dann gibt each() false zurück.
<?php
$arr = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
$offset = 3;
$elementsBefore = array();
$elementsAfter = array();
$x = 0;
while ($pair = each($arr)) {
if ($x<$offset) {
$elementsBefore[$pair[0]] = $pair[1];
} else {
$elementsAfter[$pair[0]] = $pair[1];
}
$x++;
}
print_r($elementsBefore);
print_r($elementsAfter);
?>
Array
(
[0] => 0
[1] => 1
[2] => 2
)
Array
(
[3] => 3
[4] => 4
[5] => 5
[6] => 6
[7] => 7
[8] => 8
[9] => 9
)
6. array_filter()
Die Funktion array_filter($arr, $callback) unterscheidet sich von den vorherigen Methoden: Sie erwartet ein Array und eine Callback-Funktion, welche auf alle Elemente im Array angewendet werden soll. Gibt die Callback-Funktion für ein Element den Boolean-Wert false zurück, so wird dieses automatisch aus dem Array entfernt. Bei (bool)true bleibt es erhalten. Genauso wie bei den Schleifen wird auch hier eine Zählvariable benötigt, um zu erkennen, an welcher Position das Element steht. Einzig wenn sichergestellt ist, dass die Elemente von 0 an durchnummeriert sind (0, 1, 2, 3, ...), darf der Schlüssel des Arrays als Ersatz für die Zählvariable verwendet werden.
<?php
$arr = array(0, 1, 2, 3, 4, 5, 6, 7, 8, 9);
$offset = 3;
// alles vor $offset
$x = 0;
$elementsBefore = array_filter($arr, function($val) use (&$x, $offset) {
$x++;
return ($x-1 < $offset);
});
// alles ab $offset
$x = 0;
$elementsAfter = array_filter($arr, function($val) use (&$x, $offset) {
$x++;
return ($x -1 >= $offset);
});
print_r($elementsBefore);
print_r($elementsAfter);
?>
Array
(
[0] => 0
[1] => 1
[2] => 2
)
Array
(
[3] => 3
[4] => 4
[5] => 5
[6] => 6
[7] => 7
[8] => 8
[9] => 9
)