<?xml version="1.0" encoding="utf-8"?>

<!-- EN-Revision: 3061900171d4ae84d532571bfd6eda823726dad4 Maintainer: cmb Status: ready -->

<!-- Reviewed: yes -->

<!-- Rev-Revision: c140370c354496b38b97dfafe2e31f3f8df8bb44 Reviewer: samesch -->

<sect1 xml:id="language.types.array">

<title>Arrays</title>

<para>

Eine Liste aller Array-Funktionen findet sich im Kapitel

<link linkend="ref.array">Array-Funktionen</link> der Dokumentation.

</para>

<para>

Ein <type>Array</type> ist in PHP in Wirklichkeit eine geordnete Map

(Abbildung). Eine Map ist ein Typ, der <emphasis>Werte</emphasis> zu

<emphasis>Schlüsseln</emphasis> 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 <type>Array</type>s ein weiteres

<type>Array</type> sein kann, sind auch Bäume und mehrdimensionale

<type>Array</type>s möglich.

</para>

<para>

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.

</para>

<sect2 xml:id="language.types.array.syntax">

<title>Syntax</title>

<sect3 xml:id="language.types.array.syntax.array-func">

<title>Spezifizierung mittels <function>array</function></title>

<para>

Ein <type>Array</type> kann durch das Sprachkonstrukt

<function>array</function> erzeugt werden. Dies nimmt eine beliebige

Anzahl kommaseparierter <literal><replaceable>Schlüssel</replaceable>

=&gt; <replaceable>Wert</replaceable></literal>-Paare als Parameter

entgegen.

</para>

<synopsis>

array(

<optional><replaceable>Schlüssel</replaceable> =&gt; </optional><replaceable>Wert</replaceable>,

<optional><replaceable>Schlüssel2</replaceable> =&gt; </optional><replaceable>Wert2</replaceable>,

<optional><replaceable>Schlüssel3</replaceable> =&gt; </optional><replaceable>Wert3</replaceable>,

...

)</synopsis>

<!-- Do not fix the whitespace for the synopsis end element. A limitation of PhD prevents proper trimming -->

<para>

Das Komma nach dem letzten Array-Element ist optional und kann weggelassen

werden. Dies wird üblicherweise in einzeiligen Arrays getan, &dh;.

<literal>array(1, 2)</literal> wird der Schreibweise <literal>array(1, 2,

)</literal> vorgezogen. Andererseits wird bei mehrzeiligen Arrays das

Komma am Ende üblicherweise genutzt, da dies ein einfaches Hinzufügen

weiterer Elemente am Ende erlaubt.

</para>

<note>

<para>

Es gibt eine Kurzform der Array-Syntax, die <literal>array()</literal>

durch <literal>[]</literal> ersetzt.

</para>

</note>

<example>

<title>Ein einfaches Array</title>

<programlisting role="php">

<![CDATA[

<?php

$array1 = array(

"foo" => "bar",

"bar" => "foo",

);

// Verwendung der verkürzten Array-Syntax

$array2 = [

"foo" => "bar",

"bar" => "foo",

];

var_dump($array1, $array2);

?>

]]>

</programlisting>

</example>

<para>

Der <replaceable>Schlüssel</replaceable> kann entweder ein

<type>&integer;</type> oder ein <type>&string;</type> sein. Der

<replaceable>Wert</replaceable> kann beliebige Datentypen annehmen.

</para>

<para xml:id="language.types.array.key-casts">

Zusätzlich werden die folgenden Typkonvertierungen auf den

<replaceable>Schlüssel</replaceable> angewendet:

<itemizedlist>

<listitem>

<simpara>

<type>String</type>s, die einen gültigen dezimalen <type>Int</type>

enthalten, werden zum entsprechenden <type>Int</type> umgewandelt, es

sei denn, der Zahl ist ein <literal>+</literal>-Zeichen vorangestellt.

Beispielsweise wird der Schlüssel <literal>"8"</literal> tatsächlich

unter <literal>8</literal> gespeichert. Andererseits wird

<literal>"08"</literal> nicht umgewandelt, da dies kein gültiger

Ganzzahlwert ist.

</simpara>

</listitem>

<listitem>

<simpara>

<type>Float</type>s werden ebenfalls zu <type>Int</type> umgewandelt,

was ein Abschneiden des Dezimalbruchs zur Folge hat. Beispielsweise

wird der Schlüssel <literal>8.7</literal> als <literal>8</literal>

gespeichert.

</simpara>

</listitem>

<listitem>

<simpara>

<type>Bool</type>s werden ebenfalls zu <type>Int</type> umgewandelt,

&dh; der Schlüssel &true; wird unter <literal>1</literal> gespeichert

und der Schlüssel &false; unter <literal>0</literal>.

</simpara>

</listitem>

<listitem>

<simpara>

<type>Null</type> wird zu einem leeren String umgewandelt, &dh; der

Schlüssel <literal>null</literal> wird tatsächlich unter

<literal>""</literal> gespeichert.

</simpara>

</listitem>

<listitem>

<simpara>

Werte vom Typ <type>Array</type> oder <type>&object;</type>

<emphasis>können nicht</emphasis> als Schlüssel verwendet werden. Ein

Versuch, dies zu tun, wird die Warnung <literal>Illegal offset

type</literal> zur Folge haben.

</simpara>

</listitem>

</itemizedlist>

</para>

<para>

Wenn mehrere Elemente in einer Array-Deklaration den gleichen Schlüssel

verwenden, dann wird nur der letzte verwendet und alle weiteren werden

überschrieben.

</para>

<example>

<title>Beispiel für Typumwandlung und Überschreibung</title>

<programlisting role="php">

<![CDATA[

<?php

$array = array(

1 => "a",

"1" => "b",

1.5 => "c",

true => "d",

);

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(1) {

[1]=>

string(1) "d"

}

]]>

</screen>

<para>

Da alle Schlüssel im obigen Beispiel zu <literal>1</literal> umgewandelt

werden, wird der Wert dieses Elements durch jeden angegebenen Wert

überschrieben und nur der letzte zugewiesene Wert <literal>"d"</literal>

bleibt übrig.

</para>

</example>

<para>

Arrays können in PHP gleichzeitig Schlüssel der Typen <type>Int</type> und

<type>String</type> enthalten, da PHP nicht zwischen indizierten und

assoziativen Arrays unterscheidet.

</para>

<example>

<title>Gemischte <type>Int</type>- und <type>String</type>-Schlüssel</title>

<programlisting role="php">

<![CDATA[

<?php

$array = array(

"foo" => "bar",

"bar" => "foo",

100 => -100,

-100 => 100,

);

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(4) {

["foo"]=>

string(3) "bar"

["bar"]=>

string(3) "foo"

[100]=>

int(-100)

[-100]=>

int(100)

}

]]>

</screen>

</example>

<para>

Die Angabe des <replaceable>Schlüssel</replaceable>s ist optional. Ist

keiner angegeben, so wird PHP den bisher größten angegebenen

<type>Int</type>-Schlüssel erhöhen und das Ergebnis als Schlüssel

verwenden.

</para>

<example>

<title>Indizierte Arrays ohne Schlüssel</title>

<programlisting role="php">

<![CDATA[

<?php

$array = array("foo", "bar", "hello", "world");

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(4) {

[0]=>

string(3) "foo"

[1]=>

string(3) "bar"

[2]=>

string(5) "hello"

[3]=>

string(5) "world"

}

]]>

</screen>

</example>

<para>

Es ist auch möglich, den Schlüssel nur bei einigen Elementen anzugeben und

bei anderen auszulassen:

</para>

<example>

<title>Schlüssel nicht bei allen Elementen</title>

<programlisting role="php">

<![CDATA[

<?php

$array = array(

"a",

"b",

6 => "c",

"d",

);

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(4) {

[0]=>

string(1) "a"

[1]=>

string(1) "b"

[6]=>

string(1) "c"

[7]=>

string(1) "d"

}

]]>

</screen>

<para>

Hier ist zu erkennen, dass dem letzten Wert <literal>"d"</literal> der

Schlüssel <literal>7</literal> zugewiesen wurde. Dies erfolgte, da der

größte vorherige ganzzahlige Schlüssel <literal>6</literal> war.

</para>

</example>

<example>

<title>Beispiel für komplexe Typumwandlung und Überschreibung</title>

<para>

Dieses Beispiel enthält alle Variationen der Typumwandlung von Schlüsseln

und des Überschreibens von Elementen.

</para>

<programlisting role="php">

<![CDATA[

<?php

$array = array(

1 => '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);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(7) {

[1]=>

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"

}

]]>

</screen>

</example>

<example>

<title>Beispiel mit negativem Index</title>

<simpara>

Wenn ein negativer ganzzahliger Schlüssel <literal>n</literal> zugewiesen

wird, stellt PHP sicher, dass als nächstes der Schlüssel

<literal>n+1</literal> zugewiesen wird.

</simpara>

<programlisting role="php">

<![CDATA[

<?php

$array = [];

$array[-5] = 1;

$array[] = 2;

var_dump($array);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

array(2) {

[-5]=>

int(1)

[-4]=>

int(2)

}

]]>

</screen>

<warning>

<simpara>

Vor PHP 8.3.0 würde die Zuweisung eines negativen ganzzahligen Schlüssels

<literal>n</literal> dazu führen, dass als nächstes der Schlüssel

<literal>0</literal> zugewiesen wird, sodass das obige Beispiel zu diesem

Ergebnis führen würde:

</simpara>

<informalexample>

<screen>

<![CDATA[

array(2) {

[-5]=>

int(1)

[0]=>

int(2)

}

]]>

</screen>

</informalexample>

</warning>

</example>

</sect3>

<sect3 xml:id="language.types.array.syntax.accessing">

<title>Zugriff auf Elemente mit eckigen Klammern</title>

<para>

Auf Elemente eines Arrays kann durch Verwendung der Syntax

<literal>array[Schlüssel]</literal> zugegriffen werden.

</para>

<example>

<title>Zugriff auf Array-Elemente</title>

<programlisting role="php">

<![CDATA[

<?php

$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"]);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

string(3) "bar"

int(24)

string(3) "foo"

]]>

</screen>

</example>

<note>

<para>

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 <literal>$array[42]</literal> und

<literal>array{42}</literal> 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.

</para>

</note>

<example>

<title>Array-Dereferenzierung</title>

<programlisting role="php">

<![CDATA[

<?php

function getArray() {

return array(1, 2, 3);

}

$secondElement = getArray()[1];

var_dump($secondElement);

?>

]]>

</programlisting>

</example>

<note>

<para>

Der Versuch, auf einen nicht definierten Arrayschlüssel zuzugreifen,

entspricht dem Zugriff auf jede andere undefinierte Variable: ein Fehler

der Stufe <constant>E_WARNING</constant> (der Stufe

<constant>E_NOTICE</constant> vor PHP 8.0.0) wird ausgegeben und das

Ergebnis ist &null;.

</para>

</note>

<note>

<para>

Die Array-Dereferenzierung eines skalaren Werts, der kein

<type>String</type> ist, ergibt &null;. Vor PHP 7.4.0 verursachte dies

keine Fehlermeldung. Seit PHP 7.4.0 wird ein Fehler der Stufe

<constant>E_NOTICE</constant> ausgegeben; seit PHP 8.0.0 ein Fehler der

Stufe <constant>E_WARNING</constant>.

</para>

</note>

</sect3>

<sect3 xml:id="language.types.array.syntax.modifying">

<title>Anlegen/Ändern mit eckigen Klammern</title>

<para>

Ein bestehendes <type>Array</type> kann verändert werden, indem man

explizit Werte darin setzt.

</para>

<para>

Dies wird getan, indem man dem <type>Array</type> Werte zuweist und dabei

den Schlüssel in eckigen Klammern angibt. Der Schlüssel kann dabei

weggelassen werden, was ein leeres Klammernpaar (<literal>[]</literal>)

ergibt.

</para>

<synopsis>

$arr[<replaceable>Schlüssel</replaceable>] = <replaceable>Wert</replaceable>;

$arr[] = <replaceable>Wert</replaceable>;

// <replaceable>Schlüssel</replaceable> kann ein <type>Int</type> oder <type>String</type> sein

// <replaceable>Wert</replaceable> kann einen beliebigen Typen haben</synopsis>

<para>

Falls <varname>$arr</varname> noch nicht existiert oder auf &null; oder

&false; gesetzt ist, wird es erzeugt; dies ist also eine alternative

Methode, um ein <type>Array</type> zu erzeugen. Dieses Vorgehen wird

jedoch nicht empfohlen, da, falls <varname>$arr</varname> bereits einen

Wert enthält (&zb; ein <type>String</type> aus einer Requestvariable),

dieser Wert bestehen bleibt und <literal>[]</literal> tatsächlich für den

<link linkend="language.types.string.substr">String-Zugriffs-Operator</link>

stehen kann. Es ist immer besser, eine Variable durch direkte Zuweisung zu

initialisieren.

</para>

<note>

<simpara>

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.

</simpara>

</note>

<note>

<simpara>

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.

</simpara>

</note>

<para>

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 <function>unset</function> darauf anwenden.

</para>

<example>

<title>Verwenden von eckigen Klammern bei Arrays</title>

<programlisting role="php">

<![CDATA[

<?php

$arr = array(5 => 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);

?>

]]>

</programlisting>

</example>

<note>

<para>

Wie vorher bereits erwähnt, wird, wenn kein Schlüssel angegeben ist, das

Maximum der bestehenden Schlüssel vom Typ <type>Int</type> verwendet und

der neue Schlüssel wird das Maximum plus 1 sein (aber mindestens 0). Wenn

noch kein <type>Int</type>-Schlüssel existiert wird der Schlüssel

<literal>0</literal> (Null) verwendet.

</para>

<para>

Zu beachten ist, dass der Maximalwert der Integer-Schlüssel dafür

<emphasis>aktuell nicht im <type>Array</type> existieren muss</emphasis>.

Er muss nur zu irgendeinem Zeitpunkt im <type>Array</type> existiert

haben, seitdem das <type>Array</type> zuletzt neu indiziert wurde. Das

folgende Beispiel erläutert dies:

</para>

<informalexample>

<programlisting role="php">

<![CDATA[

<?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 bestehen

foreach ($array as $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);

?>

]]>

</programlisting>

&example.outputs;

<screen>

<![CDATA[

Array

(

[0] => 1

[1] => 2

[2] => 3

[3] => 4

[4] => 5

)

Array

(

)

Array

(

[5] => 6

)

Array

(

[0] => 6

[1] => 7

)

]]>

</screen>

</informalexample>

</note>

</sect3>

<sect3 xml:id="language.types.array.syntax.destructuring">

<title>Destrukturierung (Zerlegung) von Arrays</title>

<para>

Arrays können mit den Sprachkonstrukten <literal>[]</literal> (seit

PHP 7.1.0) oder <function>list</function> destrukuriert werden. Diese

Konstrukte können verwendet werden, um ein Array in einzelne Variablen zu

zerlegen.

</para>

<example>

<title>Destrukturieren eines Arrays</title>

<programlisting role="php">

<![CDATA[

<?php

$source_array = ['foo', 'bar', 'baz'];

[$foo, $bar, $baz] = $source_array;

echo $foo, PHP_EOL; // gibt "foo" aus

echo $bar, PHP_EOL; // gibt "bar" aus

echo $baz, PHP_EOL; // gibt "baz" aus

?>

]]>

</programlisting>

</example>

<para>

Die Destrukturierung von Arrays kann in &foreach; verwendet werden, um

ein mehrdimensionales Array zu zerlegen, während darüber iteriert wird.

</para>

<example>

<title>Destrukturieren eines Arrays in foreach</title>

<programlisting role="php">

<![CDATA[

<?php

$source_array = [

[1, 'John'],

[2, 'Jane'],

];

foreach ($source_array as [$id, $name]) {

echo "{$id}: '{$name}'\n";

}

?>

]]>

</programlisting>

</example>

<para>

Array-Elemente werden ignoriert, wenn die Variable nicht angegeben wird.

Die Destrukturierung von Arrays beginnt immer beim Index

<literal>0</literal>.

</para>

<example>

<title>Ignoren von Elementen</title>

<programlisting role="php">

<![CDATA[

<?php

$source_array = ['foo', 'bar', 'baz'];

// Zuweisen des Elements bei Index 2 an die Variable $baz

[, , $baz] = $source_array;

echo $baz; // gibt "baz" aus

?>

]]>

</programlisting>

</example>

<para>

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.

</para>

<example>

<title>Destrukturieren von assoziativen Arrays</title>

<programlisting role="php">

<![CDATA[

<?php

$source_array = ['foo' => 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

?>

]]>

</programlisting>

</example>

<para>

Array-Destrukturierung kann verwendet werden, um auf einfache Weise zwei

Variablen zu vertauschen.

</para>

<example>

<title>Vertauschen von zwei Variablen</title>

<programlisting role="php">

<![CDATA[

<?php

$a = 1;

$b = 2;

[$b, $a] = [$a, $b];

echo $a, PHP_EOL; // gibt 2 aus

echo $b, PHP_EOL; // gibt 1 aus

?>

]]>

</programlisting>

</example>

<note>

<para>

Der Spread-Operator (<literal>...</literal>) wird bei Zuweisungen

nicht unterstützt.

</para>

</note>

<note>

<para>

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 <constant>E_WARNING</constant>

(der Stufe <constant>E_NOTICE</constant> vor PHP 8.0.0) wird ausgegeben

und das Ergebnis ist &null;.

</para>

</note>

<note>

<para>

Bei der Destrukturierung eines skalaren Werts wird allen Variablen &null;

zugewiesen.

</para>

</note>

</sect3>

</sect2><!-- end syntax -->

<sect2 xml:id="language.types.array.useful-funcs">

<title>Nützliche Funktionen</title>

<para>

Es gibt einige nützliche Funktionen für die Arbeit mit Arrays, die im

Abschnitt <link linkend="ref.array">Array-Funktionen</link> nachgeschlagen

werden können.

</para>

<note>

<para>

Die Funktion <function>unset</function> erlaubt es, Schlüssel aus einem

<type>Array</type> zu entfernen. Zu beachten ist dabei, dass das Array

<emphasis>nicht</emphasis> neu indiziert wird. Falls ein echtes Verhalten

von "Entfernen und Verschieben" gewünscht ist, dann kann das

<type>Array</type> mittels <function>array_values</function> neu indiziert

werden.

</para>

<example>

<title>Entfernen von Zwischenelementen</title>

<programlisting role="php">

<![CDATA[

<?php

$a = array(1 => '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);

?>

]]>

</programlisting>

</example>

</note>

<para>

Die Kontrollstruktur &foreach; existiert speziell für <type>Array</type>s.

Sie bietet eine einfache Möglichkeit, ein <type>Array</type> zu

durchlaufen.

</para>

</sect2>

<sect2 xml:id="language.types.array.donts">

<title>Dos und Dont's für Arrays (was man tun sollte und was nicht)</title>

<sect3 xml:id="language.types.array.foo-bar">

<title>Wieso ist <literal>$foo[bar]</literal> falsch?</title>

<para>

Verwenden Sie immer Anführungszeichen um ein

Arrayindex-Zeichenkettenliteral. Beispielsweise ist

<literal>$foo['bar']</literal> richtig, <literal>$foo[bar]</literal>

hingegen nicht. Aber wieso? Es ist üblich, die folgende Schreibweise in

alten Skripten zu finden:

</para>

<informalexample>

<programlisting role="php">

<![CDATA[

<?php

$foo[bar] = 'enemy';

echo $foo[bar];

// etc

?>

]]>

</programlisting>

</informalexample>

<para>

Dies ist falsch, funktioniert aber. Der Grund dafür ist, dass dieser Code

eine undefinierte Konstante (<literal>bar</literal>) anstatt eines

<type>String</type>s verwendet (<literal>'bar'</literal> - beachten Sie

die Anführungszeichen). Dies funktioniert, da PHP einen

<emphasis>nackten String</emphasis> (ein <type>String</type> ohne

Anführungszeichen, der keinem bekannten Symbol entspricht) automatisch in

einen <type>String</type> umwandelt, welcher den nackten

<type>String</type> enthält. Beispielsweise wird PHP, wenn keine Konstante

namens <constant>bar</constant> definiert ist, diese automatisch durch den

<type>String</type> <literal>'bar'</literal> ersetzen und verwenden.

</para>

<warning>

<simpara>

Das Rückfallverhalten, eine nicht definierte Konstante als nackte

Zeichenkette zu interpretieren, löst einen Fehler der Stufe

<constant>E_NOTICE</constant> aus. Dies ist seit PHP 7.2.0 missbilligt

und löst einen Fehler der Stufe <constant>E_WARNING</constant> aus. Mit

PHP 8.0.0 wurde es entfernt und löst eine

<classname>Error</classname>-Exception aus.

</simpara>

</warning>

<simpara>

Dies bedeutet nicht, dass man den Schlüssel <emphasis>immer</emphasis> in

Anführungszeichen setzen muss. Setzen Sie keine Schlüssel in

Anführungszeichen, welche

<link linkend="language.constants">Konstanten</link> oder

<link linkend="language.variables">Variablen</link> sind, da dies PHP

daran hindern wird, diese zu interpretieren.

</simpara>

<example>

<title>Anführungszeichen bei Schlüsseln</title>

<programlisting role="php">

<![CDATA[

<?php

error_reporting(E_ALL);

ini_set('display_errors', true);

ini_set('html_errors', false);

// Ein simples Array:

$array = array(1, 2);

$count = count($array);

for ($i = 0; $i < $count; $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";

}

?>

]]>

</programlisting>

</example>

&example.outputs;

<screen>

<![CDATA[

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

]]>

</screen>

<para>

Weitere Beispiele zur Erläuterung dieses Verhaltens:

</para>

<example>

<title>Weitere Beispiele</title>

<programlisting role="php">

<![CDATA[

<?php

// Alle Fehler anzeigen

error_reporting(E_ALL);

$arr = array('fruit' => '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

?>

]]>

</programlisting>

</example>