php array_s,PHP: Arrays - Manual
Arrays
Ein Array in PHP ist tatsächlich eine geordnete Map. Eine Map ist ein
Typ, der Werte zu Schlüsseln zuordnet.
Dieser Typ ist für einige verschiedene Nutzungsarten optimiert. Er kann als ein
Array verwendet werden, als Liste (Vektor), Hash Table (eine Implementierung einer
Map), Dictionary, Collection, Stack, Queue und wahrscheinlich noch als vieles anderes.
Da ein Wert eines Arrays ein weiteres Array sein kann,
sind auch Bäume und mehrdimensionale Arrays möglich.
Die Erläuterung dieser Datenstrukturen liegt nicht im Rahmen dieses Handbuches,
aber wenigstens ein Beispiel für jede ist hier angegeben. Um weitere Informationen
zu erhalten wird auf die immense Literatur zu diesem weiten Feld verwiesen.
Syntax
Spezifizierung mittels
Ein Array kann durch das Sprachkonstrukt Schlüssel => Wert-
Paare als Parameter entgegen.
array(
Schlüssel =>Wert,
Schlüssel2 =>Wert2,
Schlüssel3 =>Wert3,
...
)
Das Komma nach dem letzten Array-Element ist optional und kann weggelassen werden. Dies wird
üblicherweise in einzeiligen Arrays getan, d.h. array(1, 2) wird der
Schreibweise array(1, 2, ) vorgezogen. Andererseits wird bei mehrzeiligen
Arrays das Komma am Ende üblicherweise genutzt, da dies ein einfaches Hinzufügen weiterer
Elemente am Ende erlaubt.
Seit PHP 5.4 kann auch eine kurze Array-Syntax verwendet werden, welche
array() durch [] ersetzt.
Beispiel #1 Ein einfaches Array
$array= array("foo"=>"bar","bar"=>"foo",
);// seit PHP 5.4$array= ["foo"=>"bar","bar"=>"foo",
];?>
Der Schlüssel kann entweder ein Integer
oder ein String sein. Der Wert kann
beliebige Datentypen annehmen.
Zusätzlich werden die folgenden Typkonvertierungen auf den
Schlüssel angewendet:Strings, die einen gültigen dezimalen Integer enthalten, es sei denn der Zahl sei ein +-Zeichen vorangestellt, werden
zum entsprechenden Integer umgewandelt. Beispielsweise wird der
Schlüssel "8" tatsächlich unter 8
gespeichert. Andererseits wird "08" nicht umgewandelt, da
dies kein gültiger Ganzzahlwert ist.
Floats werden ebenfalls zu Integer umgewandelt, was ein
Abschneiden des Dezimalbruches zur Folge hat. Beispielsweise wird der Schlüssel
8.7 als 8 gespeichert.
Bools werden ebenfalls zu Integer umgewandelt, d.h.
der Schlüssel true wird unter 1
gespeichert und der Schlüssel false unter 0.
Null wird zu einem leeren String umgewandelt, d.h. der Schlüssel
null wird tatsächlich unter "" gespeichert.
Werte vom typ Array oder Object können nicht als Schlüssel
verwendet werden. Ein Versuch dies zu tun wird die Warnung
Illegal offset type zur Folge haben.
Wenn mehrere Elemente in einer Array-Deklaration den gleichen Schlüssel verwenden,
dann wird nur der letzte verwendet und alle weiteren überschrieben.
Beispiel #2 Beispiel für Typenumwandlung und Überschreibung
$array= array(1=>"a","1"=>"b",1.5=>"c",true=>"d",
);var_dump($array);?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
array(1) {
[1]=>
string(1) "d"
}
Da alle Schlüssel im obigen Beispiel zu 1 umgewandelt werden, wird der Wert
dieses Elements durch jeden angegebenen Wert überschrieben und nur der letzte zugewiesene
Wert "d" bleibt übrig.
Arrays können in PHP gleichzeitig Schlüssel der Typen Integer und
String enthalten, da PHP nicht zwischen indizierten und
assoziativen Arrays unterscheidet.
Beispiel #3 Gemischte Integer und String Schlüssel
$array= array("foo"=>"bar","bar"=>"foo",100=> -100,
-100=>100,
);var_dump($array);?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
array(4) {
["foo"]=>
string(3) "bar"
["bar"]=>
string(3) "foo"
[100]=>
int(-100)
[-100]=>
int(100)
}
Die Angabe des Schlüssel ist optional.Ist keiner angegeben,
so wird PHP den bisher größten angegebenen Integer Schlüssel erhöhen
und das Ergebnis als Schlüssel verwenden.
Beispiel #4 Indizierte Arrays ohne Schlüssel
$array= array("foo","bar","hello","world");var_dump($array);?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
array(4) {
[0]=>
string(3) "foo"
[1]=>
string(3) "bar"
[2]=>
string(5) "hello"
[3]=>
string(5) "world"
}
Es ist auch möglich den Schlüssel nur bei einigen Elementen anzugeben
und bei anderen auszulassen:
Beispiel #5 Schlüssel nicht bei allen Elementen
$array= array("a","b",6=>"c","d",
);var_dump($array);?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
array(4) {
[0]=>
string(1) "a"
[1]=>
string(1) "b"
[6]=>
string(1) "c"
[7]=>
string(1) "d"
}
Wie Sie sehen können, wurde dem letzten Wert "d" der
Schlüssel 7 zugewiesen. Dies erfolgte, da der größte
vorherige ganzzahlige Schlüssel 6 war.
Zugriff auf Elemente mit eckigen Klammern
Auf Elemente eines Arrays kann durch Verwendung der Syntax
array[Schlüssel] zugegriffen werden.
Beispiel #6 Zugriff auf Array-Elemente
$array= array("foo"=>"bar",42=>24,"multi"=> array("dimensional"=> array("array"=>"foo")
)
);var_dump($array["foo"]);var_dump($array[42]);var_dump($array["multi"]["dimensional"]["array"]);?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
string(3) "bar"
int(24)
string(3) "foo"
Hinweis:
Sowohl eckige als auch geschweifte Klammern können verwendet werden, um auf
die Elemente eines Arrays zuzugreifen (z.B. werden im obigen Beispiel
$array[42] und array{42} auf das gleiche
Element zugreifen).
Seit PHP 5.4 ist es möglich ein Array aus dem Rückgabewert eines Funktion- oder Methodenaufrufs
direkt zu dereferenzieren. Vorher war dies nur über temporäre Variablen
möglich.
Seit PHP 5.5 ist es möglich ein Array-Literal zu dereferenzieren.
Beispiel #7 Array-Dereferenzierung
return array(1,2,3);
}// seit PHP 5.4$secondElement=getArray()[1];// vorher$tmp=getArray();$secondElement=$tmp[1];// oderlist(,$secondElement) =getArray();?>
Hinweis:
Der Versuch auf einen nicht definierten Arrayschlüssel zuzugreifen
ist gleichwertig zum Zugriff auf jede andere undefinierte Variable:
ein Fehler der Stufe E_NOTICE wird ausgegeben
und das Ergebnis ist null.
Hinweis:
Array-Dereferenzierung eines skalaren Werts, der kein String ist,
ergibt null ohne dass eine Fehlermeldung erzeugt wird.
Anlegen/Ändern mit eckigen Klammern
Ein bestehendes Array kann verändert werden, indem man
explizit Werte darin setzt.
Dies wird getan, indem man Werte dem Array zuweist, und dabei
den Schlüssel in eckigen Klammern angibt. Der Schlüssel kann dabei weggelassen
werden, woraus ein leeres Klammernpaar resultiert ([]).
$arr[Schlüssel] = Wert;
$arr[] = Wert;
// Schlüssel kann ein Integer oder String sein
// Wert kann einen beliebigen Typen haben
Falls $arr noch nicht existiert, wird es erzeugt; dies ist
also eine alternative Methode, um ein Array zu erzeugen. Dieses
Vorgehen wird jedoch nicht empfohlen, da falls $arr bereits
einen Wert enthält (z.B. ein String aus einer Requestvariablen),
bleibt dieser Wert bestehen und [] kann tatsächlich für den
String-Zugriffs-Operator
stehen. Es ist immer besser eine Variable durch direkte Zuweisung zu initialisieren.
Hinweis:
Seit PHP 7.1.0 wirft die Anwendung des leeren Index-Operators auf eine Zeichenkette
einen fatalen Fehler. Zuvor wurde die Zeichenkette stillschweigend in ein Array umgewandelt.
Um einen bestimmten Wert zu ändern, kann man einen Wert zum Element anhand dessen
Schlüssel zuweisen. Um ein Schlüssel-Wert-Paar zu entfernen, kann man die Funktion
$arr= array(5=>1,12=>2);$arr[] =56;// Dies ist das selbe wie $arr[13] = 56;
// an dieser Stelle im Programmablauf$arr["x"] =42;// Dies fügt ein neues Element zum Array
// mit dem Schlüssel "x" hinzuunset($arr[5]);// Dies entfernt das Element aus dem
// Arrayunset($arr);// Dies löscht das gesamte Array?>
Hinweis:
Wie vorher bereits erwähnt wird das Maximum der bestehenden Schlüssel vom
Typ Integer verwendet, wenn kein Schlüssel angegeben ist, und der
neue Schlüssel wird das Maximum plus 1 sein (aber mindestens 0). Wenn noch kein
Integer-Schlüssel existiert wird der schlüssel 0
(Null) verwendet.
Beachten Sie, dass der Maximalwert der Integer-Schlüssel dafür
aktuell nicht im Array existieren muss.
Er muss nur zu einem vorherigen Zeitpunkt im Array
existiert haben seitdem das Array zuletzt neu
indiziert wurde. Das folgende Beispiel erläutert dies:
<?php // Create a simple array.$array= array(1,2,3,4,5);print_r($array);// Nun wird jeder Wert gelöscht, aber das Array selbst bleibt bestehenforeach ($arrayas$i=>$value) {
unset($array[$i]);
}print_r($array);// Ein Element wird hinzugefügt
// (Beachten Sie, dass der neue Schlüssel 5 ist statt 0)$array[] =6;print_r($array);// Neue Indizierung$array=array_values($array);$array[] =7;print_r($array);?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Array
(
[0] => 1
[1] => 2
[2] => 3
[3] => 4
[4] => 5
)
Array
(
)
Array
(
[5] => 6
)
Array
(
[0] => 6
[1] => 7
)
Nützliche Funktionen
Es gibt einige nützliche Funktionen für die Arbeit mit Arrays, die
im Abschnitt Array-Funktionen
nachgeschlagen werden können.
Hinweis:
Die Funktion Array zu entfernen. Beachten Sie dabei, dass das Array
nicht neu indiziert wird. Falls ein echtes Verhalten
von "Entfernen und Verschieben" gewünscht ist, dann kann das
Array mittels
$a= array(1=>'one',2=>'two',3=>'three');
unset($a[2]);/* dies wird ein Array erzeugen, das wie folgt definiert worden wäre
$a = array(1 => 'one', 3 => 'three');
und nicht so
$a = array(1 => 'one', 2 =>'three');
*/$b=array_values($a);// Nun ist $b array(0 => 'one', 1 =>'three')?>
Die Kontrollstruktur foreach existiert speziell für Arrays.
Sie bietet eine einfache Möglichkeit, ein Array zu durchlaufen.
Do's und Dont's für Arrays
Wieso ist $foo[bar] falsch?
Verwenden Sie immer Anführungszeichen um ein Arrayindex-Zeichenkettenliteral.
Beispielsweise ist $foo['bar'] richtig,
$foo[bar] hingegen nicht. Aber wieso? Es ist
üblich die folgende Schreibweise in alten Skripten zu finden:
$foo[bar] ='enemy';
echo$foo[bar];// etc?>
Dies ist falsch, funktioniert aber. Der Grund dafür ist, dass dieser Code
eine undefinierte Konstante (bar) anstatt eines String
verwendet ('bar' - beachten Sie die Anführungszeichen).
Dies funktioniert, da PHP automatisch
einen nackten String (ein String ohne
Anführungszeichen welcher nicht einem bekannten Symbol entspricht) in einen
String umwandelt, welcher den nackten String
enthält. Beispielsweise wird, wenn keine Konstante namens
bar definiert ist, PHP diese automatisch durch
den String 'bar' ersetzen und verwenden.
Warnung
Das Rückfallverhalten eine nicht definierte Konstante als nackte Zeichenkette
zu interpretieren ist von PHP 7.2.0 an missbilligt, und löst einen Fehler
der Stufe E_WARNING aus. Zuvor wurde ein Fehler der
Stufe E_NOTICE ausgelöst.
Hinweis:
Dies bedeutet nicht, dass man den Schlüssel immer in
Anführungszeichen schreiben muss. Schreiben Sie keine Schlüssel in
Anführungszeichen, welche Konstanten
oder Variablen sind, da dies PHP
daran hindern wird, diese zu interpretieren.
error_reporting(E_ALL);ini_set('display_errors',true);ini_set('html_errors',false);// Simples Array:$array= array(1,2);$count=count($array);
for ($i=0;$i
echo"\nPrüfe$i: \n";
echo"Schlecht: ".$array['$i'] ."\n";
echo"Gut: ".$array[$i] ."\n";
echo"Schlecht:{$array['$i']}\n";
echo"Gut:{$array[$i]}\n";
}?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Prüfe 0:
Notice: Undefined index: $i in /path/to/script.html on line 9
Schlecht:
Gut: 1
Notice: Undefined index: $i in /path/to/script.html on line 11
Schlecht:
Gut: 1
Prüfe 1:
Notice: Undefined index: $i in /path/to/script.html on line 9
Schlecht:
Gut: 2
Notice: Undefined index: $i in /path/to/script.html on line 11
Schlecht:
Gut: 2
Weitere Beispiele zur Erläuterung dieses Verhaltens:
<?php // Alle Fehler anzeigenerror_reporting(E_ALL);$arr= array('fruit'=>'apple','veggie'=>'carrot');// Korrektprint$arr['fruit'];// appleprint$arr['veggie'];// carrot
// Inkorrekt. Dies Funktioniert, aber PHP wirft einen Fehler der Stufe
// E_NOTICE, da eine undefinierte Konstante namens fruit verwendet wird
//
// Notice: Use of undefined constant fruit - assumed 'fruit' in...print$arr[fruit];// apple
// Dies definiert eine Konstante, um darzustellen was hier passiert. Der Wert
// 'veggie' wird einer Konstanten namens fruit zugewiesendefine('fruit','veggie');// Beachten Sie nun den Unterschiedprint$arr['fruit'];// appleprint$arr[fruit];// carrot
// Hier ist es in Ordnung, da dies innerhalb eines String ist. Innerhalb eines
// Strings wird nicht nach Konstanten gesucht, weshalb kein E_NOTICE auftrittprint"Hello$arr[fruit]";// Hello apple
// Mit einer Ausnahme: Klammern um ein Array sorgen dafür, dass Konstanten
// interpretiert werdenprint"Hello{$arr[fruit]}";// Hello carrotprint"Hello{$arr['fruit']}";// Hello apple
// Dies wird nicht funktionieren und zu einem Parse-Fehler führen:
// Parse error: parse error, expecting T_STRING' or T_VARIABLE' or T_NUM_STRING'
// Dies gilt natürlich ebenso für superglobale Werte innerhalb von Stringsprint"Hello$arr['fruit']";
print"Hello$_GET['foo']";// Konkatenation ist eine weitere Möglichkeitprint"Hello ".$arr['fruit'];// Hello apple?>
Wenn error_reporting so eingestellt
wird, dass Fehler der Stufe E_NOTICE angezeigt werden
(indem man es beispielsweise auf E_ALL stellt), so wird diese Verwendung
sofort sichtbar. Standardmäßig zeigt
error_reporting keine Hinweise.
Wie im Abschnitt zur Syntax
gezeigt, muss der Inhalt der eckigen Klammern '[' und
']') ein Ausdruck sein. Das bedeutet dass folgendes funktioniert:
Dieses Beispiel zeigt, wie der Rückgabewert einer Funktion als Arrayindex verwendet
wird. PHP kann auch Konstanten auflösen:
$error_descriptions[E_ERROR] ="Ein fataler Fehler ist aufgetreten";$error_descriptions[E_WARNING] ="PHP hat eine Warnung ausgegeben";$error_descriptions[E_NOTICE] ="Dies ist nur ein informeller Hinweis";?>
Beachten Sie, dass E_ERROR ein gültiger Bezeichner ist,
genau wie bar im ersten Beispiel. Das vorherige Beispiel ist
gleichbedeutend mit:
$error_descriptions[1] ="Ein fataler Fehler ist aufgetreten";$error_descriptions[2] ="PHP hat eine Warnung ausgegeben";$error_descriptions[8] ="Dies ist nur ein informeller Hinweis";?>
da E_ERROR gleich 1 ist usw.
Wieso ist es also schlecht?
Irgendwann in der Zukunft könnte das PHP-Team eine weitere Konstante
oder ein Schlüsselwort hinzufügen oder eine Konstante in anderem Code
könnte Einfluss nehmen. Es ist beispielsweise bereits falsch die Wörter
empty oder default so zu schreiben,
da dies reservierte Schlüsselwörter sind.
Hinweis:
Zur Wiederholung: innerhalb eines String in doppelten
Anführungszeichen ist es korrekt einen Arrayschlüssel ohne Anführungszeichen
zu schreiben wie "$foo[bar]". Die obigen Beispiele
erklären dies ebenso wie der Abschnitt zum Parsen von Variablen in Strings.
Konvertierung zu Array
Für jeden der Typen Integer, Float,
String, Boolean und Resource
führt eine Konvertierung eines Wertes in ein Array zu einem
Array mit einem einzigen Wert mit dem Index Null und dem Wert des
Skalaren, der konvertiert wurde. Anders ausgedrückt ist
(array)$scalarValue exakt identisch mit
array($scalarValue).
Wenn ein Object in ein Array konvertiert wird, so
ist das Ergebnis ein Array dessen Werte die Eigenschaften des
Objects sind. Die Schlüssel sind die Namen der Eigenschaften
des Objektes mit einigen Ausnahmen: Eigenschaften mit Ganzzahl-Namen
sind nicht zugreifbar, privaten Variablen wird der Name der Klasse
vorangestellt und protected Variablen wird dem Variablennamen ein '*'
vorangestellt. Diese vorangestellten Werte haben Null-Bytes auf beiden Seiten.
Dies kann zu unerwartetem Verhalten führen:
private$A;// Dies wird zu '\0A\0A'}
classBextendsA{
private$A;// Dies wird zu '\0B\0A'public$AA;// Dies wird zu 'AA'}var_dump((array) newB());?>
Im obigen Beispiel scheint es zwei Schlüssel namens 'AA' zu geben, obwohl
einer davon eigentlich '\0A\0A' ist.
Die Konvertierung von null in ein Array führt zu einem
leeren Array.
Vergleiche
Es ist möglich Arrays mit der Funktion Array-Operatoren
zu vergleichen.
Beispiele
Der Array-Typ in PHP ist sehr vielseitig. Hier sind einige Beispiele:
<?php // Dies:$a= array('color'=>'red','taste'=>'sweet','shape'=>'round','name'=>'apple',4// Schlüssel wird 0 sein);$b= array('a','b','c');// . . .ist komplett gleichbedeutend mit:$a= array();$a['color'] ='red';$a['taste'] ='sweet';$a['shape'] ='round';$a['name'] ='apple';$a[] =4;// Schlüssel wird 0 sein$b= array();$b[] ='a';$b[] ='b';$b[] ='c';// Nachdem der obige Code ausgeführt wurde wird $a das Array
// array('color' => 'red', 'taste' => 'sweet', 'shape' => 'round',
// 'name' => 'apple', 0 => 4) sein und $b wird das Array
// array(0 => 'a', 1 => 'b', 2 => 'c') oder einfach array('a', 'b', 'c')
// sein?>
Beispiel #8 Verwendung von array()
<?php // Array als Map von Eigenschaften$map= array('version'=>4,'OS'=>'Linux','lang'=>'englisch','short_tags'=>true);// Streng numerische Schlüssel$array= array(7,8,0,156,
-10);// das ist gleichbedeutend mit array(0 => 7, 1 => 8, ...)$switching= array(10,// Schlüssel = 05=>6,3=>7,'a'=>4,11,// Schlüssel = 6 (Maximum der Integer-Schlüssel war 5)'8'=>2,// Schlüssel = 8 (Integer!)'02'=>77,// Schlüssel = '02'0=>12// Der Wert 10 wird mit 12 überschrieben);// Leeres array$empty= array();?>
Beispiel #9 Collection
$colors= array('rot','blau','grün','gelb');
foreach ($colorsas$color) {
echo"Mögen sie$color?\n";
}?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Mögen sie rot?
Mögen sie blau?
Mögen sie grün?
Mögen sie gelb?
Die Veränderung der Werte eines Array ist mit der
Übergabe als Referenz direkt möglich.
Beispiel #10 Elemente in der Schleife verändern
}
unset($color);/* Sicherstellen, dass nachfolgende
Zugriffe auf $color nicht das letzte Element ändern */print_r($colors);?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Array
(
[0] => ROT
[1] => BLAU
[2] => GRÜN
[3] => GELB
)
Dieses Beispiel erzeugt ein Array mit erstem Schlüssel 1.
Beispiel #11 1-basierte Indizes
$firstquarter= array(1=>'Januar','Februar','März');print_r($firstquarter);?>
Das oben gezeigte Beispiel erzeugt folgende Ausgabe:
Array
(
[1] => 'Januar'
[2] => 'Februar'
[3] => 'März'
)
Beispiel #12 Ein Array befüllen
while (false!== ($file=readdir($handle))) {$files[] =$file;
}closedir($handle);?>
Arrays sind geordnet. Die Reihenfolge kann durch verschiedene
Sortierfunktionen verändert werden. Siehe Array-Funktionen für mehr Informationen. Die Funktion
Arrays zu ermitteln.
Beispiel #13 Ein Array sortieren
sort($files);print_r($files);?>
Da die Werte eines Array beliebig sein können, können diese
auch andere Arrays sein. Dies ermöglicht die Erzeugung von
rekursiven und mehrdimensionalen Arrays.
Beispiel #14 Rekursive und mehrdimensionale Arrays
$fruits= array ("fruits"=> array ("a"=>"orange","b"=>"banana","c"=>"apple"),"numbers"=> array (1,2,3,4,5,6),"holes"=> array ("first",5=>"second","third")
);// Einige Beispiele um auf Werte in den obigen Beispielen zuzugreifenecho$fruits["holes"][5];// gibt "second" ausecho$fruits["fruits"]["a"];// gibt "orange" ausunset($fruits["holes"][0]);// entfernt "first"
// Ein neues mehrdimensionales Array erzeugen$juices["apple"]["green"] ="good";?>
Zuweisung von Arrays involviert immer eine
Kopie der Werte. Verwenden Sie den Referenz-Operator um eine Kopie einer Referenz auf ein
Array zu erzeugen.
$arr1= array(2,3);$arr2=$arr1;$arr2[] =4;// $arr2 wurde geändert,
// $arr1 ist weiterhin array(2, 3)$arr3= &$arr1;$arr3[] =4;// nun sind $arr1 und $arr3 identisch?>