Aufbau von PHP-Arrays

Zusammensetzung von Arrays aus Teilen

PHP bietet zahlreiche spezialisierte Funktionen zur Bearbeitung von Arrays.
Auf dieser Seite werden Methoden zum Aufbau von Arrays aus verschiedenen Teilen vorgestellt. 		Einzelne spezialisierte Aspekte wurden weggelassen, dafür andere für die Praxis wichtige Punkte genauer vorgestellt.
Diese Seite kann daher References oder Tutorials nicht ersetzen, sondern nur ergänzen.
PHP PHP Hypertext Processor, PHP-Arrays
Merge Erzeugung eines neuen Arrays aus Teil-Arrays
Union Erzeugung eines neuen Arrays aus Teil-Arrays - andere Regeln
Splice Elemente entfernen und neue Elemente einfügen
Pad Mit neuen Elementen auffüllen
Verwandte Ähnliche Funktionen

Merge - Neues Array aus Teil-Arrays

Funktion   array_merge()

kombiniert mehrere einfache (eindimensionale) Arrays miteinander zu einem neuen Gesamt-Array.
Ganzzahlige Schlüssel:
Alle Werte werden übernommen, auch bei Duplikaten von Schlüsseln oder Werten.
Alte ganzzahlige Schlüssel werden gelöscht und im neuen Array ab [0] neu vergeben.
$a = array(11,22,33);
$b = array(22,55);
$z = array_merge($a,$b);
ergibt
(11,22,33,22,55)
Assoziative Arrays (Text-Schlüssel):
Wenn neue Schlüssel auftreten, werden die Elemente übernommen (im Beispiel [r],[b],[y] ).
Wenn bei der Verarbeitung Duplikate bereits vorhandener Schlüssel auftreten, dann werden die Elemente mit den neuen Werten überschrieben (im Beispiel [g] ) - d.h. von jedem Schlüssel wird nur der Wert des letzten Auftretens übernommen.
$a = array('r'=>100,'g'=>150,'b'=>255);
$b = array('g'=>0,'y'=>123);
$z = array_merge($a,$b);
ergibt
('r'=>100,'g'=>0,'b'=>255,'y'=>123)

Funktion   array_merge_recursive()

kombiniert mehrere Arrays rekursiv miteinander zu einem neuen Gesamt-Array.
Die Funktion arbeitet genauso wie array_merge(), jedoch auch dann, wenn die Arrays der Argumente-Liste mehrdimensional sind, d.h. selbst weitere Arrays enthalten (hier Array $c).
$c = array(6,7,array(888,999));
$z = array_merge_recursive($a,$b,$c);

Array-Operator Union (+)

Operator   + (Union)

kombiniert mehrere Arrays miteinander zu einem neuen Gesamt-Array. Vorhandene Schlüssel werden dabei nicht überschrieben, d.h. von jedem Schlüssel wird nur der Wert des ersten Auftretens übernommen.
$a = array('r'=>100,'g'=>150,'b'=>255);
$b = array('g'=>0,'y'=>123);
$z = $a + $b;
ergibt
('r'=>100,'g'=>150,'b'=>255,'y'=>123)

Splice - Elemente entfernen und neue Elemente einfügen

Funktion   array_splice()

ist sehr flexibel und daher etwas komplizierter zu demonstrieren. Sie schneidet einen Teil aus einem Array und fügt an der gleichen Stelle ein anderes Array ein.

Um Elemente aus einem Array $a zu entfernen erhält die splice-Funktion 3 Argumente($a, $offset, $len).
Aus dem Array $a wird ab (inkl.) Element $a[$offset] die Anzahl von $len Elementen entfernt. Die entfernten (!) Elemente werden von der Funktion splice() zurückgegeben (hier an das Array $x).

♦ Die Funktion array_slice() erzeugt bei ähnlicher Syntax eine Kopie und lässt das 'Original'-Array unverändert.
Entfernen von Elementen mit splice()
$a = array('a','b','c','d','e','f');
$x = array_splice($a,3,2);
entfernt 2 Elemente ab (inkl.) $a[3] und ergibt
$a = array('a','b','c','f');
$x = array('d','e');
Um neue Elemente einzufügen erhält die Funktion 4 Argumente ($a, $offset, 0, $b). In das Array $a werden vor dem Element $a[$offset] alle Elemente von Array $b eingefügt. Einfügen von Elementen mit splice()
$a = array('a','b','c','d','e','f');
$b = array('x','y');
$x = array_splice($a,3,0,$b);
fügt neue Elemente vor $a[3] ein und ergibt
$a = array('a','b','c','x','y','d','e','f');
$x = array();
Um Elemente sowohl einzufügen als auch zu entfernen erhält die Funktion 4 Argumente ($a, $offset, $len, $b).
Aus dem Array $a wird ab Element $a[$offset] die Anzahl von $len Elementen entfernt. An der gleichen Position werden alle Elemente von Array $b eingefügt. Die entfernten Elemente werden von der Funktion splice() zurückgegeben (hier an das Array $x). 		Entfernen und Einfügen von Elementen mit splice()
$a = array('a','b','c','d','e','f');
$b = array('x','y');
$x = array_splice($a,3,2,$b);
entfernt 2 Elemente ab (inkl.) $a[3] und fügt dort neue Elemente ein
$a = array('a','b','c','x','y','f');
$x = array('d','e');
Für negative Argumente gelten besondere Regeln:
Wenn $offset<0 wird die Position vom Ende des Arrays gezählt.
Beispiel: $offset=-1 bezeichnet das letzte Element (hier $a[5]='f'), $offset=-2 bezeichnet das vorletzte Element (hier $a[4]='e'). 		Entfernen von Elementen mit splice()
$a = array('a','b','c','d','e','f');
$x = array_splice($a,-5,2);
entfernt 2 Elemente ab $a[max-5] und ergibt
$a = array('a','b','e','f');
$x = array('c','d');
Wenn $len<0 werden alle folgenden Elemente bis auf die letzten -$len entfernt.
Beispiel: Für $len=-1 werden alle folgenden Elemente bis auf das letzte (hier $a[5]='f') entfernt, für $len=-2 werden alle Elemente bis auf die letzten beiden entfernt, usw. 		Entfernen von Elementen mit splice()
$a = array('a','b','c','d','e','f');
$x = array_splice($a,1,-2);
entfernt alle Elemente ab $a[1] bis auf die letzten 2 Elemente und ergibt
$a = array('a','e','f');
$x = array('b','c','d');

Pad - Mit neuen Elementen auffüllen

Funktion   array_pad()

erzeugt ein neues Array aus einem anderen Array und verlängert es bis zu einer festgelegten Anzahl von Elementen.
Die Funktion erhält 3 Argumente ($a, $cmax, $v).
Das neue Array (hier $b) enthält alle Elemente von $a.
Zusätzlich werden am Ende so viele neue Elemente mit dem Wert $v angehängt, bis die Anzahl der Elemente $cmax ist.
Ganzzahlige Schlüssel (wie im Beispiel rechts) werden gelöscht und neu ab [0] vergeben.
$a = array('a','b','c');
$b = array_pad($a,5,'x');
ergibt
$b = array('a','b','c','x','x');
Die Funktion array_pad() arbeitet analog mit assoziativen Arrays.
Allerdings werden Text-Schlüssel unverändert übernommen.
Alle evtl. vorhandenen ganzzahligen Schlüssel werden gelöscht und neu ab [0] vergeben.
Die neu angehängten Elemente erhalten fortlaufende ganzzahlige Schlüssel.
$a = array('r'=>50, 'g'=>100, 'b'=>150);
$b = array_pad($a,5,'x');
ergibt
$a = array("r"=>50, "g"=>100, "b"=>150, 0=>"x", 1=>"x");
Wenn $cmax<=count($a) werden keine neuen Elemente erzeugt, und alle Schlüssel bleiben unverändert erhalten.
$a = array('a','b','c');
$b = array_pad($a,2,'tutnix');
ergibt
$b = array('a','b','c');
In den meisten Fällen erfolgt die Rückgabe von array_pad() an das gleiche Array, welches bis zur gewünschten Größe mit neuen Elementen ergänzt wird.
$a = array_pad($a,100,'x');
Mit einem leeren Array erzeugt die Funktion ein Array der gewünschten Größe mit lauter gleichen Elementen.
$a = array_pad(array(),100,'x');
Einfügen der neuen Elemente am Anfang:
Wenn die neuen Elemente am Anfang des Arrays eingefügt werden sollen, dann kann man dafür eine Hilfsfunktion erzeugen, die mit der gleichen Syntax arbeitet.
function my_leftpad(&$a,$cmax,$v) {
$i = $cmax - count($a);
if($i>0) {
$c = array_pad(array(),$i,$v);
$b = array_merge($c,$a);
}
else {$b=$a;}
return $b;
}
$a = array('a','b','c');
$b = my_leftpad($a,5,'x');
ergibt
$b = array('x','x','a','b','c');


Verwandte Themen zum Aufbau von Arrays

Funktion   array_fill()

erzeugt ein neues Array mit Schlüsseln in einer arithmetischen Reihe.
♦ Details auf der Seite PHP-Arrays | Definition & Initialisierung

Funktion   range()

erzeugt ein neues Array mit den Werten einer arithmetischen Reihe.
♦ Details auf der Seite PHP-Arrays | Definition & Initialisierung

Funktion   array_combine()

erzeugt aus einem Schlüssel-Array und einem Werte-Array ein neues assoziatives Array.
♦ Details auf der Seite PHP-Arrays | Schlüssel & Wert

Funktion   compact()

erzeugt ein neues Array aus einzelnen Variablen.
♦ Details auf der Seite PHP-Arrays | Schlüssel & Wert

Funktion   split()

Zerlegt einen Text (String) in Teile und gibt sie als Array zurück.
♦ Details auf der Seite PHP-Arrays | Arrays & Strings 		→ Spaltung von Arrays
Aufspaltung von Arrays in Teile.

Zum Inhaltsverzeichnis Homepage von PS-Trainer   >   Entwicklung   >   PHP   >   Array   >   Kombination