Ein Array ist in PHP in Wirklichkeit eine geordnete Map (Abbildung). 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-Tabelle (eine Implementierung einer Map), Wörterbuch, Sammlung, Stack, Queue (Warteschlange) 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 Handbuchs, 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. Ein Array kann durch das Sprachkonstrukt array erzeugt werden. Dies nimmt eine beliebige Anzahl kommaseparierter 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, &dh;. 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. Es gibt eine Kurzform der Array-Syntax, die array() durch [] ersetzt. "bar", "bar" => "foo", ); // Verwendung der verkürzten Array-Syntax $array2 = [ "foo" => "bar", "bar" => "foo", ]; var_dump($array1, $array2); ?> ]]> 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 Int enthalten, werden zum entsprechenden Int umgewandelt, es sei denn, der Zahl ist ein +-Zeichen vorangestellt. 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 Int umgewandelt, was ein Abschneiden des Dezimalbruchs zur Folge hat. Beispielsweise wird der Schlüssel 8.7 als 8 gespeichert. Bools werden ebenfalls zu Int umgewandelt, &dh; der Schlüssel &true; wird unter 1 gespeichert und der Schlüssel &false; unter 0. Null wird zu einem leeren String umgewandelt, &dh; 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 werden überschrieben. "a", "1" => "b", 1.5 => "c", true => "d", ); var_dump($array); ?> ]]> &example.outputs; 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 Int und String enthalten, da PHP nicht zwischen indizierten und assoziativen Arrays unterscheidet. "bar", "bar" => "foo", 100 => -100, -100 => 100, ); var_dump($array); ?> ]]> &example.outputs; string(3) "bar" ["bar"]=> string(3) "foo" [100]=> int(-100) [-100]=> int(100) } ]]> Die Angabe des Schlüssels ist optional. Ist keiner angegeben, so wird PHP den bisher größten angegebenen Int-Schlüssel erhöhen und das Ergebnis als Schlüssel verwenden. ]]> &example.outputs; 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: "c", "d", ); var_dump($array); ?> ]]> &example.outputs; string(1) "a" [1]=> string(1) "b" [6]=> string(1) "c" [7]=> string(1) "d" } ]]> Hier ist zu erkennen, dass dem letzten Wert "d" der Schlüssel 7 zugewiesen wurde. Dies erfolgte, da der größte vorherige ganzzahlige Schlüssel 6 war. Dieses Beispiel enthält alle Variationen der Typumwandlung von Schlüsseln und des Überschreibens von Elementen. 'a', '1' => 'b', // der Wert "a" wird mit "b" überschrieben 1.5 => 'c', // der Wert "b" wird mit "c" überschrieben -1 => 'd', '01' => 'e', // da dies kein Integer-String ist, wird der Schlüssel // für 1 NICHT überschrieben '1.5' => 'f', // da dies kein Integer-String ist, wird der Schlüssel // für 1 NICHT überschrieben true => 'g', // der Wert "c" wird mit "g" überschrieben false => 'h', '' => 'i', null => 'j', // der Wert "i" wird mit "j" überschrieben 'k', // dem Wert "k" wird der Schlüssel 2 zugewiesen. Das liegt daran, // dass der größte ganzzahlige Schlüssel davor 1 war 2 => 'l', // der Wert "k" wird mit "l" überschrieben ); var_dump($array); ?> ]]> &example.outputs; string(1) "g" [-1]=> string(1) "d" ["01"]=> string(1) "e" ["1.5"]=> string(1) "f" [0]=> string(1) "h" [""]=> string(1) "j" [2]=> string(1) "l" } ]]> Wenn ein negativer ganzzahliger Schlüssel n zugewiesen wird, stellt PHP sicher, dass als nächstes der Schlüssel n+1 zugewiesen wird. ]]> &example.outputs; int(1) [-4]=> int(2) } ]]> Vor PHP 8.3.0 würde die Zuweisung eines negativen ganzzahligen Schlüssels n dazu führen, dass als nächstes der Schlüssel 0 zugewiesen wird, sodass das obige Beispiel zu diesem Ergebnis führen würde: int(1) [0]=> int(2) } ]]> Auf Elemente eines Arrays kann durch Verwendung der Syntax array[Schlüssel] zugegriffen werden. "bar", 42 => 24, "multi" => array( "dimensional" => array( "array" => "foo" ) ) ); var_dump($array["foo"]); var_dump($array[42]); var_dump($array["multi"]["dimensional"]["array"]); ?> ]]> &example.outputs; Vor PHP 8.0.0 konnten sowohl eckige als auch geschweifte Klammern verwendet werden, um auf die Elemente eines Arrays zuzugreifen (&zb; werden im obigen Beispiel $array[42] und array{42} auf das gleiche Element zugreifen). Die Syntax für geschweifte Klammern ist seit PHP 7.4.0 veraltet und wird seit PHP 8.0.0 nicht mehr unterstützt. ]]> Der Versuch, auf einen nicht definierten Arrayschlüssel zuzugreifen, entspricht dem Zugriff auf jede andere undefinierte Variable: ein Fehler der Stufe E_WARNING (der Stufe E_NOTICE vor PHP 8.0.0) wird ausgegeben und das Ergebnis ist &null;. Die Array-Dereferenzierung eines skalaren Werts, der kein String ist, ergibt &null;. Vor PHP 7.4.0 verursachte dies keine Fehlermeldung. Seit PHP 7.4.0 wird ein Fehler der Stufe E_NOTICE ausgegeben; seit PHP 8.0.0 ein Fehler der Stufe E_WARNING. Ein bestehendes Array kann verändert werden, indem man explizit Werte darin setzt. Dies wird getan, indem man dem Array Werte zuweist und dabei den Schlüssel in eckigen Klammern angibt. Der Schlüssel kann dabei weggelassen werden, was ein leeres Klammernpaar ([]) ergibt. $arr[Schlüssel] = Wert; $arr[] = Wert; // Schlüssel kann ein Int oder String sein // Wert kann einen beliebigen Typen haben Falls $arr noch nicht existiert oder auf &null; oder &false; gesetzt ist, 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 (&zb; ein String aus einer Requestvariable), dieser Wert bestehen bleibt und [] tatsächlich für den String-Zugriffs-Operator stehen kann. Es ist immer besser, eine Variable durch direkte Zuweisung zu initialisieren. Seit PHP 7.1.0 löst die Anwendung des leeren Index-Operators auf eine Zeichenkette einen fatalen Fehler aus. Zuvor wurde die Zeichenkette stillschweigend in ein Array umgewandelt. Seit PHP 8.1.0 ist das Erstellen eines neuen Arrays aus &false;-Werten veraltet. Es ist weiterhin erlaubt, ein neues Array aus &null;- und undefinierten Werten zu erstellen. Um einen bestimmten Wert zu ändern, kann man dem Element anhand seines Schlüssels einen Wert zuweisen. Um ein Schlüssel-Wert-Paar zu entfernen, kann man die Funktion unset darauf anwenden. 1, 12 => 2); $arr[] = 56; // Dies ist dasselbe 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" hinzu unset($arr[5]); // Dies entfernt das Element aus dem Array var_dump($arr); unset($arr); // Dies löscht das gesamte Array var_dump($arr); ?> ]]> Wie vorher bereits erwähnt, wird, wenn kein Schlüssel angegeben ist, das Maximum der bestehenden Schlüssel vom Typ Int verwendet und der neue Schlüssel wird das Maximum plus 1 sein (aber mindestens 0). Wenn noch kein Int-Schlüssel existiert wird der Schlüssel 0 (Null) verwendet. Zu beachten ist, dass der Maximalwert der Integer-Schlüssel dafür aktuell nicht im Array existieren muss. Er muss nur zu irgendeinem Zeitpunkt im Array existiert haben, seitdem das Array zuletzt neu indiziert wurde. Das folgende Beispiel erläutert dies: $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); ?> ]]> &example.outputs; 1 [1] => 2 [2] => 3 [3] => 4 [4] => 5 ) Array ( ) Array ( [5] => 6 ) Array ( [0] => 6 [1] => 7 ) ]]> Arrays können mit den Sprachkonstrukten [] (seit PHP 7.1.0) oder list destrukuriert werden. Diese Konstrukte können verwendet werden, um ein Array in einzelne Variablen zu zerlegen. ]]> Die Destrukturierung von Arrays kann in &foreach; verwendet werden, um ein mehrdimensionales Array zu zerlegen, während darüber iteriert wird. ]]> Array-Elemente werden ignoriert, wenn die Variable nicht angegeben wird. Die Destrukturierung von Arrays beginnt immer beim Index 0. ]]> Seit PHP 7.1.0 können auch assoziative Arrays destrukturiert werden. Da der Index explizit angegeben werden kann, ermöglicht dies auch in numerisch indizierten Arrays eine einfachere Auswahl des richtigen Elements. 1, 'bar' => 2, 'baz' => 3]; // Zuweisen des Elements bei Index 'baz' an die Variable $three ['baz' => $three] = $source_array; echo $three, PHP_EOL; // gibt 3 aus $source_array = ['foo', 'bar', 'baz']; // Zuweisen des Elements bei Index 2 an die Variable $baz [2 => $baz] = $source_array; echo $baz, PHP_EOL; // gibt "baz" aus ?> ]]> Array-Destrukturierung kann verwendet werden, um auf einfache Weise zwei Variablen zu vertauschen. ]]> Der Spread-Operator (...) wird bei Zuweisungen nicht unterstützt. Wird versucht, auf einen nicht definierten Array-Schlüssel zuzugreifen, so ist dies dasselbe wie der Zugriff auf eine andere undefinierte Variable: Eine Fehlermeldung der Stufe E_WARNING (der Stufe E_NOTICE vor PHP 8.0.0) wird ausgegeben und das Ergebnis ist &null;. Bei der Destrukturierung eines skalaren Werts wird allen Variablen &null; zugewiesen. Es gibt einige nützliche Funktionen für die Arbeit mit Arrays, die im Abschnitt Array-Funktionen nachgeschlagen werden können. Die Funktion unset erlaubt es, Schlüssel aus einem Array zu entfernen. Zu beachten ist dabei, dass das Array nicht neu indiziert wird. Falls ein echtes Verhalten von "Entfernen und Verschieben" gewünscht ist, dann kann das Array mittels array_values neu indiziert werden. 'one', 2 => 'two', 3 => 'three'); /* 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'); */ unset($a[2]); var_dump($a); $b = array_values($a); // Nun ist $b array(0 => 'one', 1 =>'three') var_dump($b); ?> ]]> Die Kontrollstruktur &foreach; existiert speziell für Arrays. Sie bietet eine einfache Möglichkeit, ein Array zu durchlaufen. 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: ]]> Dies ist falsch, funktioniert aber. Der Grund dafür ist, dass dieser Code eine undefinierte Konstante (bar) anstatt eines Strings verwendet ('bar' - beachten Sie die Anführungszeichen). Dies funktioniert, da PHP einen nackten String (ein String ohne Anführungszeichen, der keinem bekannten Symbol entspricht) automatisch in einen String umwandelt, welcher den nackten String enthält. Beispielsweise wird PHP, wenn keine Konstante namens bar definiert ist, diese automatisch durch den String 'bar' ersetzen und verwenden. Das Rückfallverhalten, eine nicht definierte Konstante als nackte Zeichenkette zu interpretieren, löst einen Fehler der Stufe E_NOTICE aus. Dies ist seit PHP 7.2.0 missbilligt und löst einen Fehler der Stufe E_WARNING aus. Mit PHP 8.0.0 wurde es entfernt und löst eine Error-Exception aus. Dies bedeutet nicht, dass man den Schlüssel immer in Anführungszeichen setzen muss. Setzen Sie keine Schlüssel in Anführungszeichen, welche Konstanten oder Variablen sind, da dies PHP daran hindern wird, diese zu interpretieren. ]]> &example.outputs; Weitere Beispiele zur Erläuterung dieses Verhaltens: 'apple', 'veggie' => 'carrot'); // Korrekt echo $arr['fruit'], PHP_EOL; // apple echo $arr['veggie'], PHP_EOL; // carrot // Inkorrekt. Dies Funktioniert nicht und PHP löst löst einen Error aus, // da eine undefinierte Konstante namens fruit verwendet wird // // Error: Undefined constant "fruit" try { echo $arr[fruit]; } catch (Error $e) { echo get_class($e), ': ', $e->getMessage(), PHP_EOL; } // Dies definiert eine Konstante, um darzustellen, was hier passiert. Der Wert // 'veggie' wird einer Konstanten namens fruit zugewiesen define('fruit', 'veggie'); // Beachten Sie nun den Unterschied echo $arr['fruit'], PHP_EOL; // apple echo $arr[fruit], PHP_EOL; // carrot // Hier ist es in Ordnung, da dies innerhalb eines Strings ist. Innerhalb eines // Strings wird nicht nach Konstanten gesucht, weshalb kein Fehler auftritt echo "Hello $arr[fruit]", PHP_EOL; // Hello apple // Mit einer Ausnahme: Klammern um ein Array sorgen dafür, dass Konstanten // interpretiert werden echo "Hello {$arr[fruit]}", PHP_EOL; // Hello carrot echo "Hello {$arr['fruit']}", PHP_EOL; // Hello apple // Konkatenation (Verkettung) ist eine weitere Möglichkeit echo "Hello " . $arr['fruit'], PHP_EOL; // Hello apple ?> ]]> ]]> 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: ]]> Es ist zu beachten, dass E_ERROR ein gültiger Bezeichner ist, genau wie bar im ersten Beispiel. Das vorherige Beispiel ist gleichbedeutend mit: ]]> da E_ERROR gleich 1 ist usw. 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. Zur Wiederholung: innerhalb eines Strings in doppelten Anführungszeichen ist es korrekt, einen Arrayschlüssel ohne Anführungszeichen zu schreiben, weswegen "$foo[bar]" zulässig ist. Die obigen Beispiele erklären dies ebenso, wie der Abschnitt zum Parsen von Variablen in Strings. 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 Objekts sind. Die Schlüssel sind die Namen der Eigenschaften des Objektes mit ein paar nennenswerten 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 NUL-Bytes auf beiden Seiten. Nicht-initialisierte typisierte Eigenschaften werden stillschweigend verworfen. {1} = null; } } var_export((array) new A()); ?> ]]> &example.outputs; NULL, '' . "\0" . '*' . "\0" . 'C' => NULL, 'D' => NULL, 1 => NULL, ) ]]> Diese NUL-Bytes können zu einem unerwarteten Verhalten führen: ]]> &example.outputs; NULL ["AA"]=> NULL ["AA"]=> NULL } ]]> 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. Mit der Funktion array_diff und mit Array-Operatoren ist es möglich, Arrays zu vergleichen. Ein Array, dem ein ... vorangestellt ist, wird bei der Definition des Arrays an Ort und Stelle expandiert (entpackt). Nur Arrays und Objekte, die Traversable implementieren, können entpackt werden. Das Entpacken von Arrays mit ... ist seit PHP 7.4.0 verfügbar. Dies wird auch als Spread-Operator bezeichnet. Es ist möglich, ein Array mehrmals zu entpacken und normale Elemente vor oder nach dem Operator ... hinzuzufügen: 'd']; // ['a', 'b', 'c' => 'd'] var_dump($arr1, $arr2, $arr3, $arr4, $arr5, $arr6); ?> ]]> Das Entpacken eines Arrays mit dem Operator ... folgt der Syntax der Funktion array_merge. Das heißt, nachfolgende Zeichenketten-Schlüssel überschreiben vorherige und Integer-Schlüssel werden neu nummeriert: 1]; $arr2 = ["a" => 2]; $arr3 = ["a" => 0, ...$arr1, ...$arr2]; var_dump($arr3); // ["a" => 2] // Integer-Schlüssel $arr4 = [1, 2, 3]; $arr5 = [4, 5, 6]; $arr6 = [...$arr4, ...$arr5]; var_dump($arr6); // [1, 2, 3, 4, 5, 6] // Das ergibt [0 => 1, 1 => 2, 2 => 3, 3 => 4, 4 => 5, 5 => 6] // wobei die ursprünglichen Integer-Schlüssel nicht beibehalten wurden. ?> ]]> Schlüssel, die weder Integer noch Zeichenketten sind, lösen einen TypeError aus. Solche Schlüssel können nur von einem Traversable-Objekt erzeugt werden. Vor PHP 8.1 wird das Entpacken eines Arrays, das einen String-Schlüssel enthält, nicht unterstützt: 4]; $arr3 = [...$arr1, ...$arr2]; // Fatal error: Uncaught Error: Cannot unpack array with string keys in example.php:5 $arr4 = [1, 2, 3]; $arr5 = [4, 5]; $arr6 = [...$arr4, ...$arr5]; // works. [1, 2, 3, 4, 5] ?> ]]> Der Array-Typ in PHP ist sehr vielseitig. Hier sind einige Beispiele: 'red', 'taste' => 'sweet', 'shape' => 'round', 'name' => 'apple', 4 // der Schlüssel wird 0 sein ); $b = array('a', 'b', 'c'); var_dump($a, $b); // . . .ist komplett gleichbedeutend mit: $a = array(); $a['color'] = 'red'; $a['taste'] = 'sweet'; $a['shape'] = 'round'; $a['name'] = 'apple'; $a[] = 4; // der 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 var_dump($a, $b); ?> ]]> 4, 'OS' => 'Linux', 'lang' => 'englisch', 'short_tags' => true ); var_dump($map); // Streng numerische Schlüssel // Das ist gleichbedeutend mit array(0 => 7, 1 => 8, ...) $array = array( 7, 8, 0, 156, -10 ); var_dump($array); $switching = array( 10, // Schlüssel = 0 5 => 6, 3 => 7, 'a' => 4, 11, // Schlüssel = 6 (das 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 ); var_dump($switching); // Leeres array $empty = array(); var_dump($empty); ?> ]]> ]]> &example.outputs; Die Veränderung der Werte eines Arrays ist mit der Übergabe als Referenz direkt möglich. ]]> &example.outputs; ROT [1] => BLAU [2] => GRÜN [3] => GELB ) ]]> Dieses Beispiel erzeugt ein Array mit erstem Schlüssel 1. 'Januar', 'Februar', 'März'); print_r($firstquarter); ?> ]]> &example.outputs; Januar [2] => Februar [3] => März ) ]]> ]]> Arrays sind geordnet. Die Reihenfolge kann durch verschiedene Sortierfunktionen verändert werden. Siehe Array-Funktionen für mehr Informationen. Die Funktion count kann verwendet werden, um die Anzahl der Elemente eines Arrays zu ermitteln. ]]> Da die Werte eines Arrays beliebig sein können, können diese auch andere Arrays sein. Dies ermöglicht die Erzeugung von rekursiven und mehrdimensionalen Arrays. array ( "a" => "orange", "b" => "banana", "c" => "apple" ), "numbers" => array ( 1, 2, 3, 4, 5, 6 ), "holes" => array ( "first", 5 => "second", "third" ) ); var_dump($fruits); // Einige Beispiele für den Zugriff auf die Werte in den obigen Beispielen echo $fruits["holes"][5]; // gibt "second" aus echo $fruits["fruits"]["a"]; // gibt "orange" aus unset($fruits["holes"][0]); // entfernt "first" // Ein neues mehrdimensionales Array erzeugen $juices["apple"]["green"] = "good"; var_dump($juices); ?> ]]> Die Zuweisung eines Arrays beinhaltet immer eine Kopie der Werte. Verwenden Sie den Referenz-Operator, um ein Array per Referenz zu kopieren. ]]>