PHP-Array

Arrays und Listen in PHP

Ein Array ( Liste, Vektor ) fasst mehrere Variable unter einem gemeinsamen Namen zusammen. PHP bietet nicht nur klassische indizierte Arrays sondern auch assoziative Arrays. PHP bietet derzeit ca. 80 verschiedene Funktionen zur Arbeit mit Arrays. Das ist sehr vielseitig, aber auch verwirrend. Hier werden einige ausgewählte Funktionen vorgestellt.
PHP PHP Hypertext Processor
Arrays in PHP Schlüssel, Indizierte und assoziative Arrays, Speicher
Definition Erzeugen & Löschen von Arrays, Initialisierung mit Daten
Array-Variable Kopie und Äquivalenz, Austausch mit Variablen und Unterprogrammen
Schlüssel & Wert Zerlegung, Zusammensetzung und Tausch
Eigenschaften Existenz, Type, Anzahl der Elemente eines Arrays
Suche Suche nach Schlüsseln und Werten
Sortieren Sortieren und Mischen von Arrays
Zugriff Lesen & Schreiben von Array-Elementen
Schleife Bearbeitung von Array-Elementen in Schleifen (loops)
ArrayPointer Funktionen zur Anwendung von Array-(Index)-Pointern
String Umwandlung strukturierter Strings in Arrays und umgekehrt
Multidimension Mehrdimensionale Arrays
Datenspeicher Arrays als Stapel oder Warteschlange
Kombination Aufbau von Arrays aus verschiedenen Teilen
Spaltung Aufspaltung von Arrays in Teile
Arithmetik Funktionen mit Array-Arithmetik und Array-Algorithmen
Verwandte Themen Arrays in Javascript, Perl, VBA

Arrays:   Indiziert oder assoziativ

Schlüssel (key)

PHP verwendet zur Kennzeichnung der Elemente eines Arrays Schlüssel (keys).
Als Schlüssel sind entweder ganze Zahlen oder Worte (Text, string) zulässig.
Jedes einzelne Element jedes Arrays speichert daher 2 Daten als Paar: Den Schlüssel und den Wert.
Das ermöglicht die Verwendung 'klassischer' Index-Zahlen (0,1,2, ..) ebenso wie von Worten ("Vorname","Zuname", ..) für die Bezeichnung bestimmter Elemente eines Arrays.

Ganze Zahlen

Wenn ganze Zahlen als Schlüssel eingesetzt werden, dann wird meist der Begriff   Index   dafür verwendet.

Text (string)

Wenn Texte (Worte, strings) als Schlüssel eingesetzt werden, dann verwendet man meist den Begriff   assoziatives Array.

Intern macht PHP keinen Unterschied zwischen diesen Typen, man kann sie daher sogar miteinander mischen (Beispiel unten).
Ganze Zahlen (auch negative) können als Schlüssel (Index) im Bereich -231..+231-1 verwendet werden. Überschreitung dieser Grenzen liefert keine Fehlermeldung !

Strings (Texte) können als assoziative Schlüssel verwendet werden. Sie dürfen auch Leerzeichen oder Sonderzeichen enthalten, empfohlen werden jedoch nur einfache Worte.

Ganze Zahlen und Strings können 'gemischt' als Schlüssel verwendet werden, das wird allerdings bald unübersichtlich und daher nicht empfohlen.
// Ganze Zahlen:
$a[0] = 1;
$a[-2147483648] = 1; // min
$a[2147483647] = 1; // max

// Strings:
$a['Vorname']='Franz';
$a['%2 oder 3;']="neue \n Zeile";
Gleitkomma-Zahlen werden beim (nicht empfohlenen !) Versuch ihrer Verwendung als Schlüssel ohne Warnung auf ganze Zahlen abgeschnitten.
Als Wert sind Gleitkomma-Zahlen natürlich zulässig.
// Vorsicht ! - dieser Befehl
$a[3.1416] = 3.1416;
// ergibt $a[3]=3.1416;
PHP-Array am Beispiel eines Arrays $a
Element$a[-3]$a['Vorname'] $a[0]$a[12]$a['a und b']$a['pnr']$a[99]
Schlüssel-3'Vorname' 0'12''a und b''pnr'99
Wert'Test''Anna' 3.1416NULL012345-9876
Dieses Array ergibt keinen vernünftigen Sinn und soll nur zeigen, was möglich ist:
• Ganzzahlige Schlüssel [Index] sind mit negativen und positiven Zahlen möglich, die Index-Reihe kann Lücken aufweisen (d.h. muss in diesem Falle nicht alle Schlüssel zwischen -3 und 99 enthalten).
• Text-(String)-Schlüssel oder assziative Elemente sind möglich, auch gemischt mit ganzzahligen (indizierten) Elementen.
• Text-Schlüssel können auch geschützte Worte, Leerzeichen oder Sonderzeichen enthalten. 		• Text-Schlüssel, die nur Ziffern enthalten, werden wie ganzzahlige Schlüssel verwendet, daher ist ['12'] identisch mit [12] !
• Leere Elemente enthalten den Wert NULL, das ist zu unterscheiden von der Zahl 0 und einem leeren Text ''.
• Der Wert (Inhalt) kann unabhängig vom Schlüssel jeden Typ annehmen, auch array (hier nicht gezeigt).

Array-Pointer

Jedes Array verfügt über einen eigenen Array-Pointer. Dieser Zeiger weist immer auf genau ein Element, das 'aktuelle' Array-Element kann man jeweils bearbeiten.
♦ Details zum ↓ ArrayPointer auf dieser Seite

Speicherplatz

Der für PHP Script-Programme erlaubte Speicherplatz ist aus gutem Grund streng begrenzt. Das erhöht die Sicherheit und verhindert übermäßigen Konsum von Server-Resourcen für einzelne Clents.
Die erlaubte Grenze ist in der → Konfigurations-Datei php.ini eingetragen und kann z.B. so angezeigt werden:
print get_cfg_var('memory_limit');

Am eigenen Webserver kann man die Grenze beliebig erhöhen, allerdings lässt das der Provider normalerweise nicht zu - Die PHP-Programme laufen dann nur mehr am eigenen Webserver, nicht beim Provider.

Die bessere Strategie ist es, mit Resourcen sparsam umzugehen, und sie nach Verwendung wieder freizugeben, z.B. mit Funktion unset() (→ Array-Eigenschaften).
Wenn ein Programm mehr Speicher erfordert als für PHP erlaubt, dann kann man auf eine Datei oder auf eine Datenbank ausweichen. Beides erfordert jedoch deutlich mehr Zeit zur Verarbeitung - Man stößt daher evtl. an die Grenze der für PHP erlaubten Ausführungszeit.
print get_cfg_var('max_execution_time');

Derart umfangreiche Programme sind allerdings Sonderfälle: Meist werden sie ohnehin nur auf einem einzigen PC ausgefährt.
Das Überschreiten der Grenzen ist meist auch ein Indiz dafür, dass man eine Aufgabe anders und besser organisieren sollte.

Eine interessante Lösung bietet die Verteilung solcher Arbeiten im Internet, z.B. das klassische SETI-Projekt. Jeder PC holt sich eine Teil-Aufgabe, berechnet das Ergebnis und liefert es wieder ab. Dadurch wird der zentrale Server nur wenig belastet, und die Kapazität zahlreicher verteilter PC gut ausgenutzt.

Definition und Initialisierung von Arrays

Leeres Array

Der Befehl array() erzeugt ein neues leeres Array mit dem gewählten Namen (hier $a).
$a = array();
Die Anzahl der Elemente muss dabei nicht angegeben werden und beträgt zunächst 0.
PHP verwaltet Arrays mit dynamischer Länge, d.h. die benötigte Länge wird später bei der Verwendung angepasst.
Als Array-Namen sind alle in PHP zulässigen Namen möglich.

Initialisierung von Arrays ohne Schlüssel

Wenn bereits bei der Definition die Werte aller Elemente bekannt sind, dann werden diese als Argumente eingetragen, mit Beistrich getrennt.

• Ohne Angabe von Schlüsseln werden ganzzahlige Schlüssel [0],[1],[2],.. verwendet. Ein neues Element von $ca erhält immer den höchsten Zahlen-Index.
$ca = array(11,22,3.4567);
Das nächste Element würde den Index $ca[3] erhalten.

• Variablen-Typen können gemischt werden:
Array $ca enthält ganze Zahlen und Gleitkomma-Zahlen, Array $cb enthält Texte (strings), $cc Zahlen und Texte.
$cb = array('Anton','Berta');
$cc = array(44,'Dora',55);
$cd = array('Emil',"$vorname $zuname");
Typenreine Arrays sollten mit einem optimierten PHP-Interpreter schneller arbeiten und weniger Speicher belegen.

• Ein leeres Element wird auf den Wert NULL gesetzt, das ist ein Unterschied zur Zahl 0 und zu einem leeren String ''
$cnull = array(NULL,0,'');
• Ein Array kann andere Arrays als Elemente enthalten. Dabei ergeben sich ↓ mehrdimensionale Arrays
$ce = array($ca,$cc);

• Wenn als Argument in () nur ein Element angeführt ist, dann wird daraus das einzige Element dieses Arrays (hier $c1[0] ) erzeugt.
$c1 = array(3);
Verwechseln sie das nicht mit dem Versuch, 3 leere Elemente zu erzeugen.
$c3 = array(NULL,NULL,NULL);

• Bei der Initialisierung darf kein Element ausgelassen werden. Leere Elemente werden mit dem Wert NULL korrekt initialisiert.
// Fehler:
$cf = array(123,,456);

Array mit Initialisierung von Schlüssel und Wert

Ein assoziatives Array verwendet Schlüssel-Worte zur Verwaltung seiner Elemente.
$p = array('pnr'=>123, 'vn'=>'Emil', 'zn'=>'Erpel');
Die 'Pfeil-Syntax'   =>   wird in PHP für die logische Verbindung zwischen Schlüssel (key) und Wert verwendet.
Das Beispiel simuliert einen Datensatz (Zeile) aus einer Personen-Datei (Tabelle).

• Die 3 Elemente des Arrays kann man nur mit ihren Schlüsseln ['pnr'],['vn'],['zn'] adressieren, nicht mit einem numerischen Index [0],[1],[2]

Zeilenweise Initialisierung

So kann man Daten zeilenweise in ein Array eingeben. Das eignet sich für die Automatisierung: Texte dieser Art kann man mit vielen Programmen bzw. mit jeder Programmiersprache erzeugen, und damit Daten an ein PHP Script-Programm übergeben.
$b = array();
$i = 0;
$b[$i++] = 12;
$b[$i++] = 34;
$b[$i++] = 567;

Funktion   array_fill()

erzeugt ein neues Array mit Schlüsseln in einer arithmetischen Reihe.
Sie erhält 3 Argumente ($kmin, $ck, $v).
Die Anzahl von $ck Array-Elementen mit Schlüsseln ab [$kmin] erhalten den Wert $v
$abc = array_fill(5,3,'xyz');
Das Beispiel erzeugt 3 Elemente und ist äquivalent zu
$abc[5] = 'xyz';
$abc[6] = 'xyz';
$abc[7] = 'xyz';

Die Verwendung von array_fill(0,$imax,NULL) erzeugt ein Array mit $imax leeren Elementen:
$leer = array_fill(0,10,NULL);

• Achtung: Allenfalls vorhandene gleichnamige Variable oder Arrays werden überschrieben.

Funktion   range()

erzeugt ein neues Array mit den Werten einer arithmetischen Reihe.
Sie erhält 2 Argumente ($vmin, $vmax)
$r = range(33,35);
Das Beispiel erzeugt 3 Elemente und ist äquivalent zu
$r[0] = 33;
$r[1] = 34;
$r[2] = 35;
Die Schlüssel werden ganzzahlig ab [0] vergeben.

• Mit $vmin>$vmax lassen sich Arrays mit fallenden Zahlenwerten erzeugen.
• Ab PHP-Version>=5 kann man ein 3.Argument $vstep angeben. Damit werden Werte im angegebenen Abstand erzeugt.
• Achtung: Allenfalls vorhandene gleichnamige Variable oder Arrays werden überschrieben.

Funktion   unset()   löscht ein Array

Insbesondere große Arrays sollte man nach Gebrauch löschen, um den belegten Speicherplatz freizugeben.
unset($a);

Array-Variable,   Übergabe an Unterprogramme

Kopie

$a = array(99,88,77);
$b = $a;
Hier wird eine komplette Kopie von Array $a erzeugt und an $b übergeben. Die Elemente von $a und von $b können unabhängig voneinander geändert werden.
Beim Kopieren wird der Speicher-Bedarf verdoppelt. Das kann bei großen Arrays zu Problemen führen !

Äquivalenz

$a = array(66,55,44);
$b = &$a;
Hier wird lediglich $b als zusätzlicher Name für das Array $a erzeugt. Der Operator & bezeichnet die Adresse des folgenden Arguments.
Jede Änderung von $a wirkt genauso wie eine Änderung von $b.
Bei der Vergabe äquivalenter Namen wird kein zusätzlicher Speicher belegt.
Diese Technik wird vorteilhaft bei der Übergabe von Arrays an Unterprogramme (Funktionen) verwendet.

Übergabe eines Arrays an ein Unterprogramm

In der Funktion sub1() wird mit dem Operator & die Adresse des Arguments $a übernommen.
Das Array $a des Unterprogramms ist daher identisch mit dem Array $m des aufrufenden Programms, d.h. man braucht es auch nicht mehr mit return zurückzugeben.
Zur Demonstration werden die Werte aller Elemente um +1 erhöht.
Da keine Daten an das Unterprogramm übergeben werden, sondern nur eine einzige Adresse, ist diese Version sehr schnell und für jede Zugriffs-Art (Lesen und Schreiben der Array-Elemente) empfehlenswert.
function sub1(&$a) {
for($k=0;$k<count($a);$k++) {
$a[$k]*=10;
}
}

$m = array(11,12,13);
sub1($m);
Nach Ausführung von sub1 enthält $m die Werte (110,120,130)
Das Beispiel rechts arbeitet genauso, benötigt jedoch wesentlich mehr Resourcen.
Hier wird das gesamte Array $a als Kopie übernommen. Das verdoppelt den Speicher-Bedarf und verbraucht unnötig viel Prozessor-Zeit.
Die Änderung der Werte funktioniert zwar, wirkt jedoch ohne Rückgabe nur auf die Arbeitskopie $a und nicht aus das Original-Array $m
Bei Rückgabe von Array $a werden alle Elemente von $m mit dem geänderten Array überschrieben - eine weitere unnötig zeitraubende Arbeit.
function nix1($a) {
for($k=0;$k<count($a);$k++) {
$a[$k]++;
}
return $a;
}

$m = array(11,12,13);
$m = nix1($m);

Array global deklarieren

Eine weitere Möglichkeit, ein Array zum Lesen und Schreiben an ein Unterprogramm zu übergeben, ist die global-Deklaration.
In diesem Fall werden keine Daten an das Unterprogramm sub2 übergeben oder von ihm zurückgegeben, das Unterprogramm greift direkt auf das 'Original'-Array $m zu.
Diese Methode ist rasch und einfach, jedoch weniger flexibel. Sie kann nur auf ein einziges Array angewendet werden, während die Übergabe der Array-Adresse (s.oben) auf jedes Array angewendet werden kann.
function sub2() {
global $m;
for($k=0;$k<count($m);$k++) {
$m[$k]++;
}
}
$m = array(11,12,13);
sub2($m);

Rückgabe eines Arrays aus einem Unterprogramm

Die Rückgabe von beliebigen Variablen - auch von Arrays - erfolgt mit dem return-Befehl.
Das Beispiel rechts zeigt die Funktion myrange(), welche ein Array mit so vielen Elementen erzeugt, wie im Argument angefordert werden (hier 1000).
Die Rückgabe ist nur dann notwendig, wenn das Array im Unterprogramm neu erzeugt wird. In allen anderen Fällen (s.o.) verwenden sie besser äquivalente Arrays.
Das Beispiel dient nur zur Demonstration und wird in der Praxis schneller durch die PHP Standard-Funktion range() (↑ Initialisierung) ausgeführt.
function myrange($vmax) {
$a = array();
for($k=0;$k<$vmax;$k++) {
$a[$k] = $k;
}
return $a;
}

$m = myrange(1000);

Schlüssel und Wert:   Zerlegung, Zusammensetzung und Tausch
Jedes assoziative Array besteht intern aus den miteinander verknüpften Listen der Schlüssel und der Werte.
In diesem Absatz werden Methoden zur Manipulation dieser Listen vorgestellt.
(Sie ergeben für Arrays mit ganzzahligen Schlüsseln normalerweise keinen Sinn). 		Test-Array für die Funktionen dieses Kapitels:
$persalt = array('Anna'=>25,'Zoe'=>19);
ist äquivalent zu
$persalt['Anna'] = 25;
$persalt['Zoe'] = 19;

Funktion   array_keys()

erzeugt ein neues Array und setzt die Schlüssel eines Arrays als Werte ein.
$pers = array_keys($persalt);
ergibt
$pers[0] = 'Anna';
$pers[1] = 'Zoe';
Mit einem zweiten optionalen Argument werden die Elemente nach Wert gefiltert, d.h. nur solche Schlüssel eingetragen, für welche der Wert genau gleich dem Filter (hier die Zahl 19) ist.
$pers = array_keys($persalt,19);
ergibt nur
$pers[0] = 'Anna';

Funktion   array_values()

erzeugt ein neues Array aus den Werten eines Arrays.
$alt = array_values($persalt);
ergibt
$alt[0] = 25;
$alt[1] = 19;

Funktion   array_flip()

erzeugt ein neues Array und vertauscht in der Kopie die Schlüssel und Werte aller Elemente.
Die Funktion kann nur auf ganzzahlige und Text-Werte angewendet werden, nicht auf Elemente mit Gleitkomma-Werten.
$altpers = array_flip($persalt);
ergibt
$altpers[25] = 'Anna';
$altpers[19] = 'Zoe';

Funktion   array_combine()

erzeugt aus einem Schlüssel-Array und einem Werte-Array ein neues assoziatives Array.
Wenn die Länge der beiden erzeugenden Arrays 0 beträgt oder nicht übereinstimmt, gibt die Funktion false zurück.
$pers = array('Anna','Zoe');
$alt = array(25,19);
$persalt = array_combine($pers,$alt)
ergibt
$persalt['Anna'] = 25;
$persalt['Zoe'] = 19;

Funktion   compact()

erzeugt ein neues Array aus einzelnen Variablen. Als Argumente werden die Namen der Variablen ( ↔ Schlüssel) übergeben.
$Anna = 25;
$Zoe = 19;
$persalt = compact('Anna','Zoe');
erzeugt aus den Variablen das Array
$persalt['Anna'] = 25;
$persalt['Zoe'] = 19;

Funktion   extract()

zerlegt ein Array in Variable (Das ist nur selten eine gute Idee.).
Dabei wird mit Hilfe von → Konstanten entschieden, ob die Werte allenfalls bestehender Variablen überschrieben werden sollen.
EXTR_OVERWRITE ↔ Variable erzeugen oder überschreiben
EXTR_SKIP ↔ Variable nur dann erzeugen, wenn sie noch nicht existiert
EXTR_IF_EXISTS ↔ Variable nur dann überschreiben, wenn sie bereits existiert.
extract($persalt, EXTR_OVERWRITE);
erzeugt aus dem Array die Variablen
$Anna = 25;
$Zoe = 19;

Funktion   list()

Führt die Zuweisung von ganzzahlig indizierten Array-Elementen an eine Liste von Variablen durch.
Das funktioniert im ersten Fall, weil von der array-Anweisung die Indices [0] und [1] erzeugt werden. Es funktioniert nicht mit den Indices ['Dora'] oder ['Emil'].
list($x,$y) = array(111,222);
list($a,$b) = array('Dora'=>33,'Emil'=>44);
ergibt die Variablen
$x=111;  $y=222;
$a=NULL;  $b=NULL;

Eigenschaften von PHP-Arrays   (und verwandte Themen)
In diesem Kapitel werden einige 'Informations-Funktionen' vorgestellt. Solche Funktionen geben normalerweise einen (boolschen) Wahrheitswert zurück (true / false, d.h. 'trifft zu' bzw. 'trifft nicht zu'). Sie werden typisch für bedingte Verzweigungen eingesetzt, d.h. das Programm teilt sich je nach dem Ergebnis der Funktion in verschiedene Zweige.

Funktion   isset()

Die Funktion gibt true zurück, wenn eine Variable oder ein Array mit einem bestimmten Namen (hier $a) existiert, und zwar ohne Rücksicht auf deren Wert, der auch leer bzw. NULL sein kann.

Funktion   unset()

löscht eine Variable oder ein Array des angegeben Namens. Löschen sie damit ein großes Array nach Gebrauch, um die davon besetzten Resourcen freizugeben.
if(isset($a)) {print 'isset = T'; }
else {print 'isset = F';}

unset ($a);

Funktion   empty()

Die Funktion gibt true zurück, wenn eine Variable mit einem bestimmten Namen nicht existiert, wenn sie ein Array ohne Elemente ist, oder wenn sie eine Variable ohne Wert bzw. mit den Werten 0 (Zahl) oder NULL ist.
if(empty($a)) {print 'empty = T';}
else {print 'empty = F';}

Funktion   is_array()

Die Funktion gibt true zurück, wenn eine Variable vom Typ array ist.
if(is_array($a)) {print 'is_array = T';}
else {print 'is_array = F ';}

Funktionen   count()   und   sizeof()

sind identisch (Alias) und geben die Anzahl der Elemente eines Array zurück.
Achtung: Das muss nicht identisch mit dem größten ganzzahligen Index sein !
$clen = count($c);

Funktion   array_key_exists()

Dient zur Feststellung, ob ein bestimmter Schlüssel existiert.
Im Beispiel wird getestet, ob mindestens ein Element des Arrays $a den Schlüssel ['vn'] enthält.
if(array_key_exists('vn',$a)) {
print '(array_key_exists(vn) = Y';
}
else { print 'array_key_exists(vn) = N'; }

Funktion   in_array()

Dient zur Feststellung, ob ein bestimmter Wert existiert.
Im Beispiel wird getestet, ob mindestens ein Element des Arrays $a den Wert 'Anna' enthält.
if(in_array('Anna',$a)) {
print 'in_array(Anna) = Y';
}
else { print 'in_array(Anna) = N '; }

Suche nach Schlüsseln und Werten

Funktion   array_key_exists()

Dient zur Feststellung, ob ein bestimmter Schlüssel existiert.
Im Beispiel wird getestet, ob mindestens ein Element des Arrays $_GET den Schlüssel ['vn'] enthält.
Wenn das zutrifft, dann wird eine Variable $x auf den Wert des Elements gesetzt, ansonsten wird ein Standardwert (default value) eingesetzt.
Damit kann man z.B. → Globale Arrays wie $_GET oder $_POST bearbeiten. 		Beispiel mit dem Globalen Array $_GET .
if(array_key_exists('farbe',$_GET)) {
$c = $_GET['farbe'];
}
else { $c = '#F39'; }

Funktion   array_search()

Dient zur Suche nach einem bestimmten Wert. Im Beispiel wird im Array $a nach dem Wert 'Bert' gesucht.
Bei erfolgloser Suche wird false zurückgegeben (Achtung, in manchen Fällen evtl. auch die Zahl 0).
Bei einem Treffer wird der Schlüssel zurückgegeben.
Bei >1 Treffern wird der erste zutreffende Schlüssel zurückgegeben.
$k = array_search('Bert',$a);
(Treffer, wenn $a[$k]=='Bert')

Funktion   in_array()

Eignet sich besser zur Feststellung, ob ein bestimmter Wert existiert.
Im Beispiel wird getestet, ob mindestens ein Element des Arrays $a den Wert 'Chris' enthält.
if(in_array('Chris',$a)) {
print 'in_array(Chris) = Y';
}
else { print 'in_array(Chris) = N '; }

Zugriff auf Array-Elemente:   Lesen & Schreiben

Array-Element schreiben

Der gewünschte Schlüssel wird nach dem Array-Namen in [] gesetzt. Man kann den Schlüssel direkt oder durch eine Variable angeben.
► Das erste Beispiel zeigt, wie man Werte an die Elemente $d[0] und $d[15] übergibt, welche durch einen ganzzahligen Schlüssel identifiziert werden.
Danach enthält das Array $d nur die beiden Elemente $d[0] und $d[15]. PHP behandelt einen ganzzahligen Index genauso wie jeden anderen Schlüssel, und kümmert sich nicht um allenfalls 'dazwischen' liegende Elemente.
► Das zweite Beispiel zeigt die Zuweisung von Werten an Elemente mit Schlüssel-Worten.
Für jede Art von Schlüssel gilt: Wenn das Element bereits existiert, wird sein Wert überschrieben, wenn nicht, dann wird es neu erzeugt.
► Das dritte Beispiel zeigt, wie man ein neues Element ohne Angabe des Schlüssels anlegen kann. Dabei wird automatisch der nächste numerische Schlüssel erzeugt. Diese Variante eignet sich dazu, um automatisch lange Listen von Array-Elementen einzutragen.
$d = array();
$d[0] = 12;
$d[15] = 'vier';
$d['vn'] = 'Franz';
$t = 'Test';
$d[$t] = $t;
$d[] = 'neu';
$d[] = 999;

Array-Element lesen

Das Lesen von Daten aus Array-Elementen erfolgt genau analog. Ganzzahlige Schlüssel werden nur selten als Zahl eingetragen, sondern meist in Variablen berechnet.
$x = $d[0] + 3;
$y = $d[$x];
$vorname = $d['vn'];

Vorsicht bei Zahlen-Strings !

PHP unterscheidet nicht zwischen der Zahl 123 und dem Text (String) "123".
Das betrifft vor allem die Schlüssel von Arrays: Verwenden sie entweder eindeutige ganze Zahlen (1,2,3,..) oder eindeutige Strings ('a1','a2','a3',..),  jedoch niemals missverständliche Strings wie ('11','22','33').
Im Zweifel sollten sie daher das gewünschte Verhalten erzwingen:
• Arithmetische Addition der Zahl 0 erzwingt eine Zahl (wenn möglich).
• String-Verkettung mit einem leeren String "" oder besser '' erzwingt einen String (immer möglich).
$x = '123' + 4;
$y = 123 + '4';
ergibt jeweils 127 ↔ '127'
$z = 123.'4';
ergibt 1234 ↔ '1234'

Array-Variable zuweisen und kopieren

Bei Zuweisung eines Arrays an eine Variable wird eine komplette Kopie aller Elemente erstellt:
Im Beispiel wird das Array $c erzeugt - ein neues Array, unabhängig von Array $a
$a = array('r','g','b');
$c = $a;

Array-Elemente löschen

• Funktion unset() löscht ein Element. Die Schlüssel der restlichen Elemente bleiben jedoch unverändert, d.h. im Beispiel fehlt anschließend der Schlüssel 2.
• Die Zuweisung eines leeren Arrays löscht alle Elemente, jedoch nicht die Array-Variable.
• Zuletzt wird mit unset das gesamte Array inkl. aller evtl. vorhandenen Elemente gelöscht.
$a = array('r','s','t','u');
unset($a[2]); // löscht 't'
$a = array();
unset($a);

Bearbeitung von Array-Elementen in Schleifen

for-Schleife

Array-Elemente werden meist innerhalb von Schleifen bearbeitet. Das Beispiel zeigt die Verwendung einer einfachen 'klassichen' for-Schleife. 		Schreiben aller Elemente in einer Schleife (begrenzt mit count)
for($k=0;$k<count($d);$k++) {
$d[$k] = $k*$k;
}
Die ganzzahlige Schlüssel-Variable $k läuft zwischen 0 und der Länge count($d) des Arrays $d
Innerhalb der Schleife wird jedes Element einzeln bearbeitet - Zur Demonstration wird hier ein Zahlenwert eingetragen. 		Achtung - Das funktioniert nur dann korrekt, wenn die Schlüssel fortlaufend ab 0 nummeriert wurden, was allerdings bei Verwendung ganzzahliger Schlüssel meistens der Fall ist.
Die Schleife arbeitet nicht wie erwartet, wenn z.B. nur die Elemente $d[0] und $d[15] vorhanden sind.

foreach-Schleife

Dieses Beispiel demonstriert die in PHP meistens verwendete Syntax-Variante:
In jedem Durchgang der Schleife wird ein Element des Arrays $a bearbeitet. Dabei wird der Schlüssel an die Variable $k übergeben, der Wert des Elements an die Variable $v

Mit $v kann man Werte lesen, mit Hilfe von $k auch schreiben. Da $v nur eine Kopie des Wertes enthält, wirkt sich eine Änderung nicht auf das Array-Element aus.

Das untere Beispiel zeigt eine verkürzte Variante mit Verzicht auf den Schlüssel. In diesem Fall kann man die Werte $v nur lesen,
Verwendung der foreach-Syntax:
foreach($a as $k=>$v) {
print "key=$k, value=$v <br />";
// $v++;   // wirkungslos !
$a[$k]++;
}
Verwendung der verkürzten foreach-Syntax:
foreach($a as $v) {
print "value=$v <br />";
}

Funktion   walk()

Diese PHP-Funktion erlaubt eine besonders übersichtliche Organisation zur Bearbeitung aller Elemente eines Arrays.
Die Funktion erhält als Argumente das Array (hier $d) und den Namen einer eigenen (Callback)-Funktion zur Verarbeitung je eines Elements.

Die Verarbeitungs-Funktion (hier print_elements() ) erhält Wert und Schlüssel je eines Elements (hier $v und $n) und wird für jedes Element genau einmal aufgerufen.

Der Wert eines Elements kann auch geändert werden. In diesem Fall übernimmt die Verarbeitungs-Funktion (hier change_elements() ) nicht den Wert $v sondern die Adresse, auf welcher der Wert gespeichert ist. Das wird durch ein &-Zeichen (rot) in der Argumente-Liste erreicht.
function print_elements($v,$k) {
print "key=$k, value=$v <br>";
}
function change_elements(&$v,$k) {
$v = $v+1;
}

// Werte ausgeben, ändern, nochmals ausgeben
array_walk($d,'print_elements');
array_walk($d,'change_elements');
array_walk($d,'print_elements');

Funktion   each()

Die Funktion each() liefert für jedes Element (des Arrays $d) ein neues Array von je 4 Elementen und setzt danach den Array-Pointer auf das nächste Element des Arrays.
Die Elemente [0] und ["key"] enthalten den Schlüssel, die Elemente [1] und ['value'] den Wert.
Funktion list() übergibt dieses Array an die Variablen in (), hier an $n und $v
In jedem Durchlauf der while-Schleife wird ein Element des Arrays $d untersucht. Wenn alle Elemente abgearbeitet sind, erhält Funktion list() keine Daten und die Schleife bricht ab.
while(list($k,$v) = each($d)) {
print "key=$k, value=$v <br />";
}

Debug-Ausgabe

Funktion print_r() bietet die roh formatierte Ausgabe eines gesamten Arrays.
print_r($d);

Array-Pointer
Jedes Array verfügt über einen ArrayPointer. Dieser 'Zeiger' zeigt jeweils auf genau ein Element des Arrays. In diesem Absatz werden einige Funktionen zur Steuerung des ArrayPointer vorgestellt.
Anfangs-Position

Funktion   reset()

Nach der Erzeugung eines Arrays zeigt der ArrayPointer immer auf das erste Element des Arrays.
Mit Funktion reset() können sie ihn jederzeit wieder dorthin setzen.
$a = array(11,22,33,44,55);
reset($a);
Aktuelle Position
Funktion   key()   gibt den Schlüssel jenes Elements zurück, auf welches der ArrayPointer gerade zeigt.
Funktion   current()   gibt den Wert des aktuellen Elements zurück.
Funktion   pos()   ist ein Alias zu current() (identisch mit anderem Funktionsnamen).
$k = key($a);
$c = current($a);
ergibt anfangs das erste Element
$k=0   $v=11
Bewegung
Funktion   next()   setzt den ArrayPointer um +1 Element weiter und wird häufig innerhalb von Schleifen verwendet.
Funktion   prev()   setzt den ArrayPointer um -1 Element zurück
Funktion   reset()   setzt den ArrayPointer auf das erste Element und wird dann verwendet, wenn man nach Durchlauf einiger/aller Elemente nochmals beim ersten Element beginnen will.
Funktion   end()   setzt den ArrayPointer auf das letzte Element
next($a);
$k = key($a);
$c = current($a);
ergibt
$k=1   $v=22
end($a);
$k = key($a);
$c = current($a);
ergibt
$k=4  $v=55

Funktion   each()

Die Funktion each() ist eine Kombination der Funktionen (key(), current(), next() ).
Sie liefert für das aktuelle Element ein neues Array von je 4 Elementen und setzt danach den Array-Pointer auf das nächste Element des Arrays.
Die Elemente [0] und ['key'] enthalten die Schlüssel, die Elemente [1] und ['value'] die Werte.
reset($a);
$ea = each($a);
ergibt
$ea[0]=0   $ea['key']=0   $ea[1]=11   $ea['value']=11  
bei Wiederholung
$ea = each($a);
ergibt das
$ea[0]=1   $ea['key']=1   $ea[1]=22   $ea['value']=22  
Funktion each() wird vorwiegend in Schleifen über Array-Elemente verwendet.
Das Beispiel gibt alle Paare Schlüssel ↔ Wert eines Arrays (hier $a ) aus.
♦ Details in den Kapiteln Schlüssel & Wert und Array-Variable auf dieser Seite.
while(list($k,$v) = each($d)) {
print "key=$k, value=$v <br />";
}

Arrays und Strings
Diese Funktionen dienen zum Aufbau und zur Zerlegung systematisch aufgebauter Texte, deren Teile durch bestimmte Trennzeichen getrennt sind. Beispiele: Datei-Pfade, Internet-Adressen, Datum und Zeit (nach → ISO-Standard), usw.

Funktion   join()

Erzeugt einen Text (string) aus den Elementen eines Arrays.
Das erste Argument wird als Trennzeichen bzw. Trenn-String zwischen den einzelnen Elementen verwendet, das zweite bezeichnet das Array.
Zahlen-Arrays werden automatisch in Strings umgewandelt. Wenn der Trenn-String leer ist, werden die Elemente direkt aneinander gesetzt.
$j = array(77,88,99);
$t = join('-#-',$j);
Das ist äquivalent zu
$t = $j[0].'-#-'.$j[1].'-#-'.$j[2];
und erzeugt diesen Text:
77-#-88-#-99

Funktion   preg_split()

Zerlegt einen Text (string) in Teile und gibt sie als Array zurück. Als Argument wird ein → Regulärer Ausdruck verwendet. Die Trennzeichen (bzw. Trenn-Strings) selbst werden bei der Aufspaltung unterdrückt.
▲ Die Vorgänger-Funktionen split(), spliti() sind veraltet (deprecated) und sollten nicht mehr verwendet werden.
♦ Details zu Regulären Ausdrücken.
$t = 'http://test/myweb/index.htm';
$s = preg_split("/\//",$t);
Liefert das Array $s mit 5 Elementen
('http:','','test','myweb','index.htm')
Hinweis: Das erste und das letzte / Zeichen begrenzen den Regulären Ausdruck. Dieser besteht lediglich aus dem Zeichen / welches durch einen vorangestellten \ BackSlash maskiert wird.

Funktion   implode()

Arbeitet so wie ↑ Funktion join() und verbindet die Elemente eines Arrays zu einem String.
$j = array(77,88,99);
$t = implode('-#-',$j);
print("t=$t<br>");
Das Beispiel gibt diesen Text aus:
77-#-88-#-99

Funktion   explode()

Arbeitet in einfachen Fällen so wie Funktion   split(), zerlegt einen Text (String) in Teile und gibt sie als Array zurück. Als Argument wird ein String verwendet. Die Trennzeichen (bzw. Trenn-strings) selbst werden bei der Aufspaltung unterdrückt.
$t = 'http://test/myweb/index.htm';
$s = explode('/',$t);
Liefert das Array $s mit 5 Elementen
('http:','','test','myweb','index.htm')

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