archived-doc-de/language/types/array.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- $Revision$ -->
<!-- EN-Revision: f616f360e1988ed68d5120e1c43e1e473a5b9e13 Maintainer: simp  Status: working -->
<sect1 xml:id="language.types.array">
 <title>Arrays</title>

 <para>
  Ein <type>Array</type> in PHP ist tatsächlich eine geordnete Map. 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 Table (eine Implementierung einer
  Map), Dictionary, Collection, Stack, Queue und wahrscheinlich noch andere.
  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 ist nicht im Rahmen dieses Handbuches,
  aber wenigstens ein Beispiel für jedes 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, d.h. <literal>array(1, 2)</literal> wird der
    Schreibweise <literal>array(1, 2, )</literal> vorgezogen. Andererseits wird bei mehrzeiligen 
    Arrays wird das Komma am Ende üblicherweise genutzt, da dies ein einfaches Hinzufügen weiterer
    Elemente am Ende erlaubt.
   </para>

   <para>
    Seit PHP 5.4 kann auch eine kurze Array-Syntax verwendet werden, welche
    <literal>array()</literal> durch <literal>[]</literal> ersetzt.
   </para>

   <example>
    <title>Ein einfaches Array</title>
    <programlisting role="php">
<![CDATA[
<?php
$array = array(
    "foo" => "bar",
    "bar" => "foo",
);

// seit PHP 5.4
$array = [
    "foo" => "bar",
    "bar" => "foo",
];
?>
]]>
    </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>
    Zusätzlich werden die folgenden Typkonvertierungen auf den 
    <replaceable>Schlüssel</replaceable> angewendet:
    <itemizedlist>
     <listitem>
      <simpara>
       <type>String</type>s die einen gültigen <type>Integer</type> enthalten werden
       zum entsprechenden <type>Integer</type> umgewandelt. 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>Integer</type> umgewandelt, was ein
       Abschneiden des Dezimalbruches 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>Integer</type> umgewandelt, d.h.
       der Schlüssel <literal>true</literal> wird unter <literal>1</literal>
       gespeichert und der Schlüssel <literal>false</literal> unter <literal>0</literal>.
      </simpara>
     </listitem>
     <listitem>
      <simpara>
       <type>Null</type> wird zu einem leeren String umgewandelt, d.h. 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> können nicht 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 überschrieben.
   </para>

   <example>
    <title>Beispiel für Typenumwandlung 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>Integer</type> und
    <type>String</type> enthalten, da PHP nicht zwischen indizierten und 
    assoziativen Arrays unterscheidet.
   </para>

   <example>
    <title>Gemischte <type>Integer</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> ist optional.Ist keiner angegeben,
    so wird PHP den bisher größten angegebenen <type>Integer</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:
   </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>
     Wie Sie sehen können wurde dem letzten Wert <literal>"d"</literal> der 
     Schlüssel <literal>7</literal> zugewiesen. Dies erfolgte da der größte 
     vorherige ganzzahlige Schlüssel die <literal>6</literal> war.
    </para>
   </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>
     Sowohl eckige als auch geschweifte Klammern können verwendet werden, um auf
     die Elemente eines Arrays zuzugreifen (z.B. werden im obigen Beispiel
     <literal>$array[43]</literal> und <literal>array{42}</literal> auf das gleiche 
     Element zugreifen).
    </para>
   </note>

   <para>
    Seit PHP 5.4 ist es möglich ein Array aus dem Rückgabewert eines Funktion
    direkt zu dereferenzieren. Vorher war dies nur über temporäre Variablen
    möglich.
   </para>

   <para>
    Seit PHP 5.5 ist es möglich ein Array-Literal zu dereferenzieren.
   </para>

   <example>
    <title>Array-Dereferenzierung</title>
    <programlisting role="php">
<![CDATA[
<?php
function getArray() {
    return array(1, 2, 3);
}

// seit PHP 5.4
$secondElement = getArray()[1];

// vorher
$tmp = getArray();
$secondElement = $tmp[1];

// oder
list(, $secondElement) = getArray();
?>
]]>
    </programlisting>
   </example>

   <note>
    <para>
      Der Versuch auf einen nicht definierten Arrayschlüssel zuzugreifen
      ist gleichwertig zum Zugriff jeder anderen undefinierten Variable:
      Ein Fehler der Stufe <constant>E_NOTICE</constant> wird ausgegeben
      und das Ergebnis ist &null;.
    </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 Werte dem <type>Array</type> zuweist und dabei
    den Schlüssel in eckigen Klammern angibt. Der Schlüssel kann dabei weggelassen
    werden, woraus ein leeres Klammernpaar resultiert (<literal>[]</literal>).
   </para>

   <synopsis>
$arr[<replaceable>Schlüssel</replaceable>] = <replaceable>Wert</replaceable>;
$arr[] = <replaceable>Wert</replaceable>;
// <replaceable>Schlüssel</replaceable> kann ein <type>Integer</type> oder <type>String</type> sein
// <replaceable>Wert</replaceable> kann einen beliebigen Typen haben</synopsis>

   <para>
    Falls <varname>$arr</varname> noch nicht existiert 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 (z.B. ein <type>String</type> aus einer Requestvariablen)
    bleibt dieser Wert bestehen und <literal>[]</literal> kann tatsächlich für den
    <link linkend="language.types.string.substr">String-Zugriffs-Operator</link>
    stehen. Es ist immer besser eine Variable durch direkte Zuweisung zu initialisieren.
   </para>

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

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$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" hinzu

unset($arr[5]); // Dies entfernt das Element aus dem
                // Array

unset($arr);    // Dies löscht das gesamte Array
?>
]]> 
    </programlisting>
   </informalexample>

   <note>
    <para>
     Wie vorher bereits erwähnt wird das Maximum der bestehenden Schlüssel vom 
     Typ <type>Integer</type> verwendet, wenn kein Schlüssel angegeben ist, und der
     neue Schlüssel wird das Maximum plus 1 sein (aber mindestens 0). Wenn noch kein
     <type>Integer</type>-Schlüssel existiert wird der schlüssel <literal>0</literal>
     (Null) verwendet.
    </para>

    <para>
     Beachten Sie, dass der Maximalwert der Integer-Schlüssel dafür
     <emphasis>aktuell nicht im <type>Array</type> existieren muss</emphasis>.
     Er muss nur zu einem vorherigen 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>
 </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. Beachten Sie 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>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$a = array(1 => 'one', 2 => 'two', 3 => 'three');
unset($a[2]);
/* dies wird ein Array erzeugen, dass wie folgt definiert 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')
?>
]]>
    </programlisting>
   </informalexample>
  </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>Do's und Dont's für Arrays</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 Zeichenkettenliteral des Index
    eines Arrays. Beispielsweise ist <literal>$foo['bar']</literal> richtig,
    <literal>$foo[bar]</literal> hingegen nicht. Aber wieso nicht? 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 (bar) anstatt eines <type>String</type> 
    verwendet ('bar' - beachten Sie die Anführungszeichen).
    PHP kann zukünftig Konstanten definieren die zum Leidwesen dieses Codes
    den gleichen Namen haben könnten. Dies funktioniert, da PHP automatisch
    einen <emphasis>nackten String</emphasis> (ein <type>String</type> ohne
    Anführungszeichen welcher nicht einem bekannten Symbol entspricht) in einen
    <type>String</type> umwandelt, welcher den nackten <type>String</type>
    enthält. Beispielsweise wird, wenn keine Konstante namens 
    <constant>bar</constant> definiert ist, PHP diese automatisch durch
    den <type>String</type> <literal>'bar'</literal> ersetzen und verwenden.
   </para>

   <note>
    <simpara>
     Dies bedeutet nicht, dass man den Schlüssel <emphasis>immer</emphasis> in
     Anführungszeichen schreiben muss. Schreiben 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>

    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
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 < $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>
    </informalexample>
    &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>
   </note>

   <para>
    Weitere Beispiele zur Erläuterung dieses Verhaltens:
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
// Alle Fehler anzeigen
error_reporting(E_ALL);

$arr = array('fruit' => 'apple', 'veggie' => 'carrot');

// Korrekt
print $arr['fruit'];  // apple
print $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 zugewiesen
define('fruit', 'veggie');

// Beachten Sie nun den Unterschied
print $arr['fruit'];  // apple
print $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 auftritt
print "Hello $arr[fruit]";      // Hello apple

// Mit einer Ausnahme: Klammern um ein Array sorgen dafür, dass Konstanten
// interpretiert werden
print "Hello {$arr[fruit]}";    // Hello carrot
print "Hello {$arr['fruit']}";  // Hello apple

// Dies wird nicht funktionieren und zu einem Parser 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 Strings
print "Hello $arr['fruit']";
print "Hello $_GET['foo']";

// Konkatenation ist eine weitere Möglichkeit
print "Hello " . $arr['fruit']; // Hello apple
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    Wenn <link linkend="ini.error-reporting">error_reporting</link> so eingestellt
    wird, dass Fehler der Stufe <constant>E_NOTICE</constant> angezeigt werden
    (indem man es auf <constant>E_ALL</constant> stellt), so wird diese Verwendung
    sofort sichtbar. Standardmäßig ist 
    <link linkend="ini.error-reporting">error_reporting</link> nicht entsprechend
    eingestellt, um solche Hinweise zu zeigen.
   </para>

   <para>
    Wie im Anschnitt zur <link linkend="language.types.array.syntax">Syntax</link>
    gezeigt muss der Inhalt der eckigen Klammern '<literal>[</literal>' und
    '<literal>]</literal>') ein Ausdruck sein. Das bedeutet dass folgendes funktioniert:
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
echo $arr[somefunc($bar)];
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    Dieses Beispiel zeigt, wie der Rückgabewert einer Funktion als Arrayindex verwendet
    wird. PHP kann auch Konstanten auflösen:
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$error_descriptions[E_ERROR]   = "A fatal error has occurred";
$error_descriptions[E_WARNING] = "PHP issued a warning";
$error_descriptions[E_NOTICE]  = "This is just an informal notice";
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    Beachten Sie, dass <constant>E_ERROR</constant> ein gültiger Bezeichner ist,
    genau wie <literal>bar</literal> im ersten Beispiel. Das vorherige Beispiel ist
    gleichbedeutend mit:
   </para>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$error_descriptions[1] = "A fatal error has occurred";
$error_descriptions[2] = "PHP issued a warning";
$error_descriptions[8] = "This is just an informal notice";
?>
]]>
    </programlisting>
   </informalexample>

   <para>
    da <constant>E_ERROR</constant> gleich <literal>1</literal> ist usw.
   </para>

   <sect4 xml:id="language.types.array.foo-bar.why">
    <title>Wieso ist es also schlecht?</title>

    <para>
     Irgendwann in der Zukunft könnte das PHP-Team eine weitere Konstante
     oder ein Schlüsselwort hinzufügen oder eine Kostante in anderem Code
     könnte Einfluss nehmen. Es ist beispielsweise bereits falsch die Wörter
     <literal>empty</literal> oder <literal>default</literal> so zu schreiben,
     da dies <link linkend="reserved">reservierte Schlüsselwörter</link> sind.
    </para>

    <note>
     <simpara>
      Zur Wiederholung: innerhalb eines <type>String</type> in doppelten 
      Anführungszeichen ist es korrekt einen Arrayschlüssel ohne Anführungszeichen
      zu schreiben wie <literal>"$foo[bar]"</literal>. Die obigen Beispiele 
      erklären dies ebenso wie der Abschnitt zum <link 
      linkend="language.types.string.parsing">Parsen von Variablen in Strings</link>.
     </simpara>
    </note>

   </sect4>
  </sect3>
 </sect2>

 <sect2 xml:id="language.types.array.casting">
  <title>Konvertierung zu Array</title>

  <para>
   Für jeden der Typen <type>Integer</type>, <type>Float</type>,
   <type>String</type>, <type>Boolean</type> und <type>Resource</type>
   führt eine Konvertierung eines Wertes in ein <type>Array</type> zu einem
   Array mit einem einzigen Wert mit dem Index Null und dem Wert des
   Skalaren der konvertiert wurde. Anders ausgedrückt ist 
   <literal>(array)$scalarValue</literal> exakt identisch mit
   <literal>array($scalarValue)</literal>.
  </para>

  <para>
   Wenn ein <type>Object</type> in ein <type>Array</type> konvertiert wird, so
   ist das Ergebnis ein <type>Array</type> dessen werte die Eigenschaften des
   <type>Object</type> 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 ein '*' dem Namen der Variablen
   vorangestellt. Diese vorangestellten Werte haben Null-Bytes auf beiden Seiten.
   Dies kann zu unerwartetem Verhalten führen:
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

class A {
    private $A; // Dies wird zu '\0A\0A'
}

class B extends A {
    private $A; // Dies wird zu '\0B\0A'
    public $AA; // Dies wird zu 'AA'
}

var_dump((array) new B());
?>
]]>
   </programlisting>
  </informalexample>

  <para>
   Im obigen Beispiel scheint es zwei Schlüssel namens 'AA' zu geben, obwohl
   einer davon eigentlich '\0A\0A' ist.
  </para>

  <para>
   Die Konvertierung von &null; in ein <type>Array</type> führt zu einem
   leeren <type>Array</type>.
  </para>
 </sect2>

 <sect2 xml:id="language.types.array.comparing">
  <title>Vergleiche</title>

  <para>
   Es ist möglich Arrays mit der Funktion <function>array_diff</function>
   und mit 
   <link linkend="language.operators.array">Array-Operatoren</link>
   zu vergleichen.
  </para>
 </sect2>

 <sect2 xml:id="language.types.array.examples">
  <title>Beispiele</title>

  <para>
   Der Array-Typ in PHP ist sehr vielseitig. Hier sind einige Beispiele:
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// This:
$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 einfacher array('a', 'b', 'c')
// sein
?>
]]>
   </programlisting>
  </informalexample>

  <example>
   <title>Benutzung von array()</title>
   <programlisting role="php">
<![CDATA[
<?php
// Array als Map von Eigenschaften
$map = array( 'version'    => 4,
              'OS'         => 'Linux',
              'lang'       => 'english',
              '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 = 0
                    5    =>  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();         
?>
]]>
<!-- TODO example of
- overwriting keys
- using vars/functions as key/values
- warning about references
-->
   </programlisting>
  </example>

  <example xml:id="language.types.array.examples.loop">
   <title>Collection</title>
   <programlisting role="php">
<![CDATA[
<?php
$colors = array('red', 'blue', 'green', 'yellow');

foreach ($colors as $color) {
    echo "Do you like $color?\n";
}

?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Do you like red?
Do you like blue?
Do you like green?
Do you like yellow?
]]>
   </screen>
  </example>

  <para>
   Die Veränderung der Werte eines <type>Array</type> ist seit PHP mit der 
   Übergabe als Referenz direkt möglich. Vorher war ein Workaround notwendig:
  </para>

  <example xml:id="language.types.array.examples.changeloop">
   <title>Elemente in der Schleife verändern</title>
   <programlisting role="php">
<![CDATA[
<?php
// PHP 5
foreach ($colors as &$color) {
    $color = strtoupper($color);
}
unset($color); /* Sicherstellen, dass nachfolgende
Zugriffe auf $color nicht das letzte Element ändern */

// Workaround für ältere Versionen
foreach ($colors as $key => $color) {
    $colors[$key] = strtoupper($color);
}

print_r($colors);
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Array
(
    [0] => RED
    [1] => BLUE
    [2] => GREEN
    [3] => YELLOW
)
]]>
   </screen>
  </example>

  <para>
   Dieses Beispiel erzeugt ein Array mit erstem Schlüsse 1
  </para>

  <example>
   <title>1-basierte Indizes</title>
   <programlisting role="php">
<![CDATA[
<?php
$firstquarter  = array(1 => 'January', 'February', 'March');
print_r($firstquarter);
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Array 
(
    [1] => 'January'
    [2] => 'February'
    [3] => 'March'
)
]]>   
   </screen>
  </example>

  <example>
   <title>Ein Array befüllen</title>
   <programlisting role="php">
<![CDATA[
<?php
// Dies füllt ein Array mit allen Einträgen eines Verzeichnisses
$handle = opendir('.');
while (false !== ($file = readdir($handle))) {
    $files[] = $file;
}
closedir($handle); 
?>
]]>
   </programlisting>
  </example>

  <para>
   <type>Array</type>s sind sortiert. Die Reihenfolge kann durch verschiedene
   Sortierfunktionen verändert werden. Siehe <link linkend="ref.array">
   Array-Funktionen</link> für mehr Informationen. Die Funktion
   <function>count</function> kann herangezogen werden, um die Anzahl
   der Elemente eines <type>Array</type> zu ermitteln.
  </para>

  <example>
   <title>Ein Array sortieren</title>
   <programlisting role="php">
<![CDATA[
<?php
sort($files);
print_r($files);
?>
]]>
   </programlisting>
  </example>

  <para>
   Da die Werte eines <type>Array</type> beliebig sein können, können diese
   auch andere <type>Array</type>s sein. Dies ermöglicht die Erzeugung von
   rekursiven und mehrdimensionalen <type>Array</type>s.
  </para>

  <example>
   <title>Rekursive und mehrdimensionale Arrays</title>
   <programlisting role="php">
<![CDATA[
<?php
$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 Werde in den obigen Beispielen zuzugreifen
echo $fruits["holes"][5];    // prints "second"
echo $fruits["fruits"]["a"]; // prints "orange"
unset($fruits["holes"][0]);  // remove "first"

// Ein neues mehrdimensionales Array erzeugen
$juices["apple"]["green"] = "good"; 
?>
]]>
   </programlisting>
  </example>

  <para>
   Zuweisung von <type>Array</type>s zu Variablen involviert immer eine
   Kopie der Werte. Verwenden Sie den <link linkend="language.operators">
   Referenz-Operator</link> um eine Kopie einer Referenz auf ein
   <type>Array</type> zu erzeugen.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
$arr1 = array(2, 3);
$arr2 = $arr1;
$arr2[] = 4; // $arr2 ist geändert,
             // $arr1 ist weiterhin array(2, 3)

$arr3 = &$arr1;
$arr3[] = 4; // nun sind $arr1 und $arr3 identisch
?>
]]>
   </programlisting>
  </informalexample>

 </sect2>
</sect1>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->