<?xml version="1.0" encoding="iso-8859-1"?>
<!-- EN-Revision: 1.161 Maintainer: tom Status: ready -->
 <reference id="ref.array">
  <title>Array Funktionen</title>
  <titleabbrev>Arrays</titleabbrev>
  <partintro>
   <simpara>
    Diese Funktionen erlauben es, Arrays auf verschiedene Arten zu
    manipulieren bzw. mit ihnen zu interagieren. Arrays sind wichtig,
    um Gruppen von Variablen zu verwalten, zu bearbeiten, oder zu
    speichern.
   </simpara>
   <simpara>
    Es werden einfache und mehrdimensionale Arrays untersttzt, welche
    entweder vom Benutzer oder von einer anderen Funktion erstellt
    werden knnen. Es gibt bestimmte Datenbankfunktionen, welche die
    Ergebnisse aus Datenbankabfragen in Arrays speichern, und
    verschiedene andere Funktionen, die Arrays als Rckgabewerte
    haben.
   </simpara>
  <para>
   In der Sektion <link linkend="language.types.array">Arrays</link>
   finden Sie eine detaillierte Erklrung, wie Arrays in PHP
   implementiert sind und wie sie benutzt werden.
  </para>
   <para>
    Siehe auch <function>is_array</function>,
    <function>explode</function>, <function>implode</function>,
    <function>split</function> und <function>join</function>.
   </para>
  </partintro>

  <refentry id="function.array">
   <refnamediv>
    <refname>array</refname>
    <refpurpose>
     Erstellt ein Array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array</methodname>
      <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     Gibt ein den Parametern entsprechendes Array zurck. Mit dem
     <literal>=&gt;</literal> Operator knnen die Parameter indiziert werden.
    </para>
    <para>
     <note>
      <para>
       <function>array</function> ist keine richtige Funktion sondern ein
       Sprachkonstrukt, das zur Erzeugung eines Wertefeldes genutzt wird.
      </para>
     </note>
    </para>
    <para>
     Die Syntax "Index =&gt; Werte", durch Kommas getrennt, definiert
     Index und Werte. Index kann vom Typ String oder numerisch sein.
     Wird der Index weggelassen, erstellt die Funktion automatisch
     einen numerischen Index, der bei 0 beginnt. Ist der Index als
     Integer-Wert angegeben, wird der nchste generierte Index der
     grte Integer Index + 1. Beachten Sie, dass wenn zwei identische
     Indexe definiert sind, der letzte den ersten berschreibt.
    </para>
    <para>
     Das folgende Beispiel zeigt wie man ein zweidimensionales Array
     erstellt, wie man Schlssel fr assoziative Arrays festlegt, und
     wie man numerische Indizes in normalen Arrays berspringt und
     fortsetzt.
     <example>
      <title><function>array</function></title>
      <programlisting role="php">
<![CDATA[
$fruits = array (
    "Frchte" => array ("a"=>"Orange", "b"=>"Banane", "c"=>"Apfel"),
    "Zahlen"  => array (1, 2, 3, 4, 5, 6),
    "Lcher"  => array ("erstes", 5 => "zweites", "drittes")
);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     <example>
      <title>Automatischer Index mit <function>array</function></title>
      <programlisting role="php">
<![CDATA[
$array = array( 1, 1, 1, 1, 1, 8=>1, 4=>1, 19, 3=>13);
print_r($array);
]]>
      </programlisting>
      <para>
       wird folgendes anzeigen:
       <screen role="php">
<![CDATA[
Array
(
    [0] => 1
    [1] => 1
    [2] => 1
    [3] => 13
    [4] => 1
    [8] => 1
    [9] => 19
)
]]>
       </screen>
      </para>
     </example>
     Beachten Sie, dass Index '3' doppelt definiert ist, und den letzten
     definierten Wert 13 behlt. Index 4 wurde nach dem Index 8 definiert,
     und der nchste generierte Index (Wert 19) ist 9, da der grte Index
     8 war.
    </para>
    <para>
     Dieses Beispiel erstellt ein auf dem Index 1 basierendes Array.
     <example>
      <title>1-basierter Index mit <function>array</function></title>
      <programlisting role="php">
<![CDATA[
$erstesquartal  = array(1 => 'Januar', 'Februar', 'Mrz');
print_r($erstesquartal);
]]>
      </programlisting>
      <para>
     wird folgendes ausgeben:
       <screen>
<![CDATA[
Array
(
    [1] => 'Januar'
    [2] => 'Februar'
    [3] => 'Mrz'
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     Siehe auch <function>array_pad</function>,
     <function>list</function> und <function>range</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-change-key-case">
   <refnamediv>
    <refname>array_change_key_case</refname>
    <refpurpose>
     Liefert ein Array mit allen String-Schlsseln in Klein- oder Grobuchstaben
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_change_key_case</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>case</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_change_key_case</function> wandelt die Schlssel des
     Arrays <parameter>input</parameter> in Klein- bzw. Grobuchstaben um.
     Die Richtung der Umwandlung wird mit dem optionalen Parameter
     <parameter>case</parameter> festgelegt, mit dem die zwei Konstanten
     <constant>CASE_UPPER</constant> und <constant>CASE_LOWER</constant>
     bergeben werden knnen. Default ist <constant>CASE_LOWER</constant>.
     Diese Funktion lsst die numerischen Indizes unverndert.
    </para>
    <example>
     <title><function>array_change_key_case</function></title>
     <programlisting role="php">
<![CDATA[
$input_array = array("FirSt" => 1, "SecOnd" => 4);
print_r(array_change_key_case($input_array, CASE_UPPER);
]]>
     </programlisting>
     <para>
      wird folgendes ausgeben:
      <screen>
<![CDATA[
Array
(
    [FIRST] => 1
    [SECOND] => 2
)
]]>
      </screen>
     </para>
    </example>
   </refsect1>
  </refentry>

  <refentry id="function.array-chunk">
   <refnamediv>
    <refname>array_chunk</refname>
    <refpurpose>Splittet ein Array in Teile auf</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_chunk</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam><type>int</type><parameter>size</parameter></methodparam>
      <methodparam choice="opt"><type>bool</type><parameter>preserve_keys</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_chunk</function> teilt das Array in verschiedene
     Arrays mit <parameter>size</parameter> Werten auf. Am Ende kann
     auch ein Array mit weniger Werten erzeugt werden. Die Arrays werden
     als Teile eines mehrdimensionalen Arrays erzeugt, welches bei Null
     und beginnend numerisch indiziert ist.
    </para>
    <para>
     Sie knnen PHP dazu zwingen, die originalen Schlssel des
     Arrays input beizubehalten, indem Sie den optionalen Parameter
     <parameter>preserve_keys</parameter> auf &true; setzen. Geben
     Sie &false; an, werden in jedem erzeugten Array neue numerische
     Indizes erzeugt, welche bei Null beginnen. Default ist &false;.
    </para>
    <example>
     <title><function>array_chunk</function></title>
     <programlisting role="php">
<![CDATA[
$input_array = array('a', 'b', 'c', 'd', 'e');
print_r(array_chunk($input_array, 2));
print_r(array_chunk($input_array, 2, TRUE));
]]>
     </programlisting>
     <para>
      wird folgendes ausgeben:
      <screen>
<![CDATA[
Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
        )

    [1] => Array
        (
            [0] => c
            [1] => d
        )

    [2] => Array
        (
            [0] => e
        )

)
Array
(
    [0] => Array
        (
            [0] => a
            [1] => b
        )

    [1] => Array
        (
            [2] => c
            [3] => d
        )

    [2] => Array
        (
            [4] => e
        )

)
]]>
      </screen>
     </para>
    </example>
   </refsect1>
  </refentry>

  <refentry id="function.array-count-values">
   <refnamediv>
    <refname>array_count_values</refname>
    <refpurpose>Zhlt die Werte eines Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_count_values</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_count_values</function> gibt ein Array zurck, in
     dem die Werte des Arrays <parameter>input</parameter> als
     Schlssel, und deren Anzahl als Werte angegeben sind.
    </para>
    <para>
     <example>
      <title><function>array_count_values</function></title>
      <programlisting role="php">
<![CDATA[
$array = array (1, "hello", 1, "world", "hello");
print_r(array_count_values ($array));
]]>
      </programlisting>
      <para>
       Wird folgendes ausgeben:
       <screen>
<![CDATA[
Array
(
    [1] => 2
    [hello] => 2
    [world] => 1
)
]]>
       </screen>
      </para>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-diff">
   <refnamediv>
    <refname>array_diff</refname>
    <refpurpose>Ermittelt die Unterschiede von Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_diff</methodname>
      <methodparam><type>array</type><parameter>array1</parameter></methodparam>
      <methodparam><type>array</type><parameter>array2</parameter></methodparam>
      <methodparam choice="opt"><type>array</type><parameter> ...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_diff</function> gibt ein Array mit allen Werten von
     <parameter>array1</parameter>, welche in keinem der anderen Argumente
     enthalten sind, zurck. Beachten Sie, dass Schlssel erhalten bleiben.
    </para>
    <para>
     <example>
      <title><function>array_diff</function></title>
      <programlisting role="php">
<![CDATA[
$array1 = array ("a" => "grn", "rot", "blau", "rot");
$array2 = array ("b" => "grn", "gelb", "rot");
$result = array_diff ($array1, $array2);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Dies speichert <literal>array("blau");</literal> in
     <varname>$result</varname>.  Mehrfache Vorkommen in $array1
     werden auf die gleiche Weise behandelt.
    </para>
    <note>
     <simpara>
      Zwei Elemente werden nur dann als gleich angesehen, wenn
      <literal>(string) $elem1 === (string) $elem2</literal>. In Worten:
      Wenn die String-Reprsentation die gleiche ist.
     </simpara>
    </note>
    <warning>
     <simpara>
      Dies war in PHP 4.0.4 fehlerhaft!
     </simpara>
    </warning>
    <para>
     Siehe auch <function>array_intersect</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-filter">
   <refnamediv>
    <refname>array_filter</refname>
    <refpurpose>
     Filtert Elemente eines Arrays mittels einer Callback-Funktion
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_filter</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>callback</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_filter</function> gibt ein Array mit den mittels
     der Callback-Funktion gefilterten Elementen von
     <parameter>input</parameter> zurck. Ist
     <parameter>input</parameter> ein assoziatives Array, bleiben die
     Schlssel erhalten.
    </para>
    <para>
     <example>
      <title><function>array_filter</function></title>
      <programlisting role="php">
<![CDATA[
function ungerade($var) {
    return ($var % 2 == 1);
}

function gerade($var) {
    return ($var % 2 == 0);
}

$array1 = array ("a"=>1, "b"=>2, "c"=>3, "d"=>4, "e"=>5);
$array2 = array (6, 7, 8, 9, 10, 11, 12);

echo "Ungerade :\n";
print_r(array_filter($array1, "ungerade"));
echo "Gerade:\n";
print_r(array_filter($array2, "gerade"));
]]>
      </programlisting>
      <para>
       Wird folgendes ausgeben:
       <screen role="php">
<![CDATA[
Ungerade :
Array
(
    [a] => 1
    [c] => 3
    [e] => 5
)
Gerade:
Array
(
    [0] => 6
    [2] => 8
    [4] => 10
    [6] => 12
)
]]>
       </screen>
      </para>
     </example>
    </para>
    &note.func-callback;
    <para>
     Siehe auch <function>array_map</function> und
     <function>array_reduce</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-flip">
   <refnamediv>
    <refname>array_flip</refname>
    <refpurpose>Vertauscht Werte und Schlssel in einem Array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_flip</methodname>
      <methodparam><type>array</type><parameter>trans</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_flip</function> Gibt ein <type>Array</type> in
     umgekehrter Reihenfolge zurck, d.h. Schlssel von
     <parameter>trans</parameter> werden Werte, und umgekehrt werden
     die Werte zu Schlsseln.
    </para>
    <para>
     Beachten Sie, dass die Werte von <parameter>trans</parameter> gltige
     Schlssel sein mssen, z.B. haben sie entweder <type>integer</type>
     oder <type>string</type> zu sein. Ist ein Wert vom falschen Typ wird
     eine Warnung ausgegeben, und das Schlssel/Werte-Paar <emphasis>wird
     nicht vertauscht</emphasis>.
    </para>
    <para>
     Kommt ein Wert mehrmals vor, wird der letzte Schlssel mit seinem
     Wert vertauscht, und alle anderen Schlssel- Wertepaare gehen
     verloren.
    </para>
    <para>
     <function>array_flip</function> gibt im Fehlerfall
     &false; zurck.
    </para>
    <para>
     <example>
      <title><function>array_flip</function> Beispiel</title>
      <programlisting role="php">
<![CDATA[
$trans = array_flip ($trans);
$original = strtr ($str, $trans);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     <example>
      <title><function>array_flip</function> Beispiel: Kollision</title>
      <programlisting role="php">
<![CDATA[
$trans = array ("a" => 1, "b" => 1, "c" => 2);
$trans = array_flip ($trans);
print_r($trans);
]]>
      </programlisting>
      <para>
       Nun ist $trans:
       <screen>
<![CDATA[
Array
(
    [1] => b
    [2] => c
)
]]>
       </screen>
      </para>
     </example>
    </para>
    </refsect1>
  </refentry>

  <refentry id="function.array-fill">
   <refnamediv>
    <refname>array_fill</refname>
    <refpurpose>Fllt ein Array mit Werten</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_fill</methodname>
      <methodparam><type>int</type><parameter>start_index</parameter></methodparam>
      <methodparam><type>int</type><parameter>num</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>value</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_fill</function> fllt ein Array mit
     <parameter>num</parameter> Eintrgen des Wertes des
     <parameter>value</parameter> Parameters. Die Indizes des Arrays
     beginnen mit dem <parameter>start_index</parameter> Parameter.
    </para>
    <para>
     <example>
      <title><function>array_fill</function></title>
      <programlisting role="php">
<![CDATA[
$a = array_fill(5, 6, 'Banane');
]]>
      </programlisting>
      <para>
       $a wrde mit <function>print_r</function> folgende Inhalte ausgeben:
       <screen>
<![CDATA[
Array
(
    [5]  => Banane
    [6]  => Banane
    [7]  => Banane
    [8]  => Banane
    [9]  => Banane
    [10] => Banane
)
]]>
       </screen>
      </para>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-intersect">
   <refnamediv>
    <refname>array_intersect</refname>
    <refpurpose>Ermittelt die Schnittmenge von Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_intersect</methodname>
      <methodparam><type>array</type><parameter>array1</parameter></methodparam>
      <methodparam><type>array</type><parameter>array2</parameter></methodparam>
      <methodparam choice="opt"><type>array</type><parameter> ...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_intersect</function> gibt ein Array mit allen Werten
     von <parameter>array1</parameter>, die auch in allen anderen
     Argumenten enthalten sind, zurck. Beachten Sie, dass die Schlssel
     erhalten bleiben.
    </para>
    <para>
     <example>
      <title><function>array_intersect</function> Beispiel</title>
      <programlisting role="php">
<![CDATA[
$array1 = array ("a" => "grn", "rot", "blau");
$array2 = array ("b" => "grn", "gelb", "rot");
$result = array_intersect ($array1, $array2);
]]>
      </programlisting>
      <para>
       Danach enthlt <varname>$result</varname>
       <screen role="php">
<![CDATA[
Array
(
    [a] => grn
    [0] => rot
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <note>
     <simpara>
      Zwei Elemente werden nur dann als gleich angesehen, wenn
      <literal>(string) $elem1 === (string) $elem2</literal>. In Worten:
      Wenn die String-Reprsentation die gleiche ist.
     </simpara>
    </note>
    <warning>
     <simpara>
      Dies war in PHP 4.0.4 fehlerhaft!
     </simpara>
    </warning>
    <para>
     Siehe auch <function>array_diff</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-key-exists">
   <refnamediv>
    <refname>array_key_exists</refname>
    <refpurpose>Prft, ob ein Schlssel in einem Array existiert</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>bool</type><methodname>array_key_exists</methodname>
      <methodparam><type>mixed</type><parameter>key</parameter></methodparam>
      <methodparam><type>array</type><parameter>search</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_key_exists</function> gibt &true; zurck, wenn
     <parameter>key</parameter> in dem Array vorhanden ist.
     <parameter>key</parameter> kann jeder fr einen Array-Index
     mgliche Wert sein.
    </para>
    <para>
     <example>
      <title><function>array_key_exists</function></title>
      <programlisting role="php">
<![CDATA[
$search_array = array("erstes" => 1, "zweites" => 4);
if (array_key_exists("erstes", $search_array)) {
    echo "Das Element 'erstes' ist in dem Array vorhanden";
}
]]>
      </programlisting>
     </example>
    </para>
    <note>
     <simpara>
      Der Name dieser Funktion ist in PHP 4.0.6
      <function>key_exists</function>.
     </simpara>
    </note>
    <para>
     Siehe auch <function>isset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-keys">
   <refnamediv>
    <refname>array_keys</refname>
    <refpurpose>Liefert alle Schlssel eines Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_keys</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>
        search_value
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_keys</function> gibt die Schlssel (numerisch und
     String) des Arrays <parameter>input</parameter> zurck.
    </para>
    <para>
     Ist der optionale Parameter <parameter>search_value</parameter>
     angegeben, werden nur die Schlssel fr diesen Wert zurckgegeben.
     Andernfalls werden all Schlssel von <parameter>input</parameter>
     zurckgegeben.
    </para>
    <para>
     <example>
      <title><function>array_keys</function></title>
      <programlisting role="php">
<![CDATA[
$array = array (0 => 100, "Farbe" => "rot");
print_r(array_keys ($array));

$array = array ("blau", "rot", "grn", "blau", "blau");
print_r(array_keys ($array, "blau"));

$array = array ("Farbe" => array("blau", "rot", "grn"), "Gre" => array("klein", "mittel", "gro"));
print_r(array_keys ($array));
]]>
      </programlisting>
      <para>
       wrde folgendes ausgeben:
       <screen>
<![CDATA[
Array
(
    [0] => 0
    [1] => Farbe
)
Array
(
    [0] => 0
    [1] => 3
    [2] => 4
)
Array
(
    [0] => Farbe
    [1] => Gre
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <note>
     <para>
      Diese Funktion wurde in PHP 4 eingefhrt, nachstehend finden Sie eine
      Implementierung fr Benutzer von PHP 3.
      <example>
       <title>
	    Implementierung von <function>array_keys</function> fr
	    Benutzer von PHP 3:
       </title>
       <programlisting role="php">
<![CDATA[
function array_keys ($arr, $term="") {
    $t = array();
    while (list($k,$v) = each($arr)) {
        if ($term && $v != $term) {
            continue;
        }
        $t[] = $k;
    }
    return $t;
}
]]>
       </programlisting>
      </example>
     </para>
    </note>
    <para>
     Siehe auch <function>array_values</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-map">
   <refnamediv>
    <refname>array_map</refname>
    <refpurpose>
     Wendet eine Callback-Funktion auf die Elemente von Arrays an
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_map</methodname>
      <methodparam><type>mixed</type><parameter>callback</parameter></methodparam>
      <methodparam><type>array</type><parameter>arr1</parameter></methodparam>
      <methodparam choice="opt"><type>array</type><parameter>arr2...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_map</function> gibt ein Array mit allen Elementen von
     <parameter>arr1</parameter> zurck, nachdem die Callback-Funktion auf
     jedes einzelne Element angewandt wurde. Die Anzahl Parameter, welche
     Callback-Funktion akzeptiert, sollte der Anzahl der an
     <function>array_map</function> bergebenen Arrays entsprechen.
    </para>
    <para>
     <example>
      <title><function>array_map</function></title>
      <programlisting role="php">
<![CDATA[
function cube($n) {
    return $n*$n*$n;
}

$a = array(1, 2, 3, 4, 5);
$b = array_map("cube", $a);
print_r($b);
]]>
      </programlisting>
      <para>
       Dies speichert in <varname>$b</varname>:
       <screen>
<![CDATA[
Array
(
    [0] => 1
    [1] => 8
    [2] => 27
    [3] => 64
    [4] => 125
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     <example>
      <title>
       <function>array_map</function> - Verwendung mehrerer Arrays
      </title>
      <programlisting role="php">
<![CDATA[
function show_Spanish($n, $m) {
    return "Die Zahl $n heit auf Spanisch  $m";
}

function map_Spanish($n, $m) {
    return array ($n => $m);
}

$a = array(1, 2, 3, 4, 5);
$b = array("uno", "dos", "tres", "cuatro", "cinco");

$c = array_map("show_Spanish", $a, $b);
print_r($c);

$d = array_map("map_Spanish", $a , $b);
print_r($d);
]]>
      </programlisting>
      <para>
       Dies resultiert in:
       <screen>
<![CDATA[
// Ausgabe von $c
Array
(
    [0] => Die Zahl 1 heit auf Spanisch  uno
    [1] => Die Zahl 2 heit auf Spanisch  dos
    [2] => Die Zahl 3 heit auf Spanisch  tres
    [3] => Die Zahl 4 heit auf Spanisch  cuatro
    [4] => Die Zahl 5 heit auf Spanisch  cinco
)

// Ausgabe von $d
Array
(
    [0] => Array
        (
            [1] => uno
        )

    [1] => Array
        (
            [2] => dos
        )

    [2] => Array
        (
            [3] => tres
        )

    [3] => Array
        (
            [4] => cuatro
        )

    [4] => Array
        (
            [5] => cinco
        )

)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     Bei Verwendung von zwei oder mehr Arrays sollten diese gewhnlich
     die gleiche Lnge besitzen, da die Callback-Funktion parallel auf
     die entsprechenden Elemente angewandt wird.  Haben die Arrays
     unterschiedliche Lngen, wird das krzeste um leere Elemente
     erweitert.
    </para>
    <para>
     Eine interessante Anwendung dieser Funktion ist die Konstruktion
     eines Arrays bestehend aus Arrays, was mit &null; als Name der
     Callback-Funktion leicht realisiert werden kann.
    </para>
    <para>
     <example>
      <title>Erstellen eines Arrays mit Arrays</title>
      <programlisting role="php">
<![CDATA[
$a = array(1, 2, 3, 4, 5);
$b = array("eins", "zwei", "drei", "vier", "fnf");
$c = array("uno", "dos", "tres", "cuatro", "cinco");

$d = array_map(null, $a, $b, $c);
print_r($d);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Wrde folgendes ausgeben:
     <screen>
<![CDATA[
Array
(
    [0] => Array
        (
            [0] => 1
            [1] => eins
            [2] => uno
        )

    [1] => Array
        (
            [0] => 2
            [1] => zwei
            [2] => dos
        )

    [2] => Array
        (
            [0] => 3
            [1] => drei
            [2] => tres
        )

    [3] => Array
        (
            [0] => 4
            [1] => vier
            [2] => cuatro
        )

    [4] => Array
        (
            [0] => 5
            [1] => fnf
            [2] => cinco
        )

)
]]>
     </screen>
    </para>
    <para>
     Siehe auch <function>array_filter</function> und
     <function>array_reduce</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-merge">
   <refnamediv>
    <refname>array_merge</refname>
    <refpurpose>Fhrt zwei oder mehr Arrays zusammen</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_merge</methodname>
      <methodparam><type>array</type><parameter>array1</parameter></methodparam>
      <methodparam><type>array</type><parameter>array2</parameter></methodparam>
      <methodparam choice="opt"><type>array</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_merge</function> fgt die Elemente von zwei oder
     mehr Arrays zusammen, indem die Werte des einen an das Ende des
     anderen angehngt werden. Das daraus resultierende Array wird
     zurckgegeben.
    </para>
    <para>
     Haben die angegebenen Arrays die selben String-Schlssel, dann
     wird der hintere Wert dieses Schlssels den vorhergehenden
     berschreiben. Haben die Arrays den gleichen numerischen
     Schlssel, dann wird der hintere Wert den vorhergehenden nicht
     berschreiben, sondern an den vorderen angehngt.
    </para>
    <para>
     <example>
      <title><function>array_merge</function></title>
      <programlisting role="php">
<![CDATA[
$array1 = array ("farbe" => "rot", 2, 4);
$array2 = array ("a", "b", "farbe" => "grn", "form" => "trapezoid", 4);
$result = array_merge ($array1, $array2);
]]>
      </programlisting>
      <para>
       Das <literal>$result</literal> Ergebnis ist:
       <screen role="php">
<![CDATA[
Array
(
    [farbe] => grn
    [0] => 2
    [1] => 4
    [2] => a
    [3] => b
    [form] => trapezoid
    [4] => 4
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     Siehe auch <function>array_merge_recursive</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-merge-recursive">
   <refnamediv>
    <refname>array_merge_recursive</refname>
    <refpurpose>
     Fhrt zwei oder mehr Arrays rekursiv zusammen
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_merge_recursive</methodname>
      <methodparam><type>array</type><parameter>array1</parameter></methodparam>
      <methodparam><type>array</type><parameter>array2</parameter></methodparam>
      <methodparam choice="opt"><type>array</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_merge_recursive</function> fgt die Elemente von
     zwei oder mehr Arrays zusammen, so dass die Werte des einen
     Arrays an die des vorigen angehngt werden. Das daraus
     resultierende Array wird zurckgegeben.
    </para>
    <para>
     Haben die angegebenen Arrays die selben String-Schlssel, dann
     wird der hintere Wert dieses Schlssels den vorhergehenden
     berschreiben. Haben die Arrays den gleichen numerischen
     Schlssel, dann wird der hintere Wert den vorhergehenden nicht
     berschreiben, sondern an den vorderen angehngt.
    </para>
    <para>
     <example>
      <title><function>array_merge_recursive</function></title>
      <programlisting role="php">
<![CDATA[
$ar1 = array ("farbe" => array ("favorit" => "rot"), 5);
$ar2 = array (10, "farbe" => array ("favorit" => "grn", "blau"));
$result = array_merge_recursive ($ar1, $ar2);
]]>
      </programlisting>
      <para>
       The <literal>$result</literal> will be:
       <screen role="php">
<![CDATA[
Array
(
    [farbe] => Array
        (
            [favorit] => Array
                (
                    [0] => rot
                    [1] => grn
                )

            [0] => blau
        )

    [0] => 5
    [1] => 10
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     See also <function>array_merge</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-multisort">
   <refnamediv>
    <refname>array_multisort</refname>
    <refpurpose>Sortiert mehrere oder multidimensionale Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>bool</type><methodname>array_multisort</methodname>
      <methodparam><type>array</type><parameter>ar1</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>arg</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
      <methodparam choice="opt"><type>array</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_multisort</function> wird zum Sortieren von
     entweder mehreren Arrays auf einmal, oder eines
     multidimensionalen Arrays (entsprechend einer von mehreren
     Dimensionen) benutzt. Bei der Sortierung werden die
     Schlsselassoziationen beibehalten.
    </para>
    <para>
     Die angegebenen Arrays werden als Spalten einer Tabelle
     behandelt, welche nach Reihen sortiert werden - hnlich der SQL
     Klausel ORDER BY.  Das erste Array ist auch das erste in der
     Sortierreihenfolge. Die in diesem Array gleichen Zeilen (Werte)
     werden anhand des nchsten angegebenen Arrays sortiert, usw.
    </para>
    <para>
     Die Struktur der Argumente ist etwas ungewhnlich, aber
     flexibel. Das aller erste Argument muss ein Array sein. Die
     nachfolgenden Argumente knnen entweder ein Array oder eines der
     folgenden Sortierflags sein.
    </para>
    <para>
     Flags fr Sortierreihenfolge:
     <itemizedlist>
      <listitem>
       <simpara>
	SORT_ASC - sortiere in aufsteigender Reihenfolge
       </simpara>
      </listitem>
      <listitem>
       <simpara>
	SORT_DESC - sortiere in absteigender Reihenfolge
       </simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
     Flags fr Sortiertypen:
     <itemizedlist>
      <listitem>
       <simpara>SORT_REGULAR - vergleiche Felder normal</simpara>
      </listitem>
      <listitem>
       <simpara>SORT_NUMERIC - vergleiche Felder numerisch</simpara>
      </listitem>
      <listitem>
       <simpara>SORT_STRING - vergleiche Felder als Strings</simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
     Es kann nur ein Sortierflag des selben Typs nach jedem Array
     spezifiziert werden. Sortierflags nach einem Array Argument
     gelten nur fr dieses Array, und werden vor jedem neuen Array
     Argument zu den Defaultflags SORT_ASC und SORT_REGULAR
     zurckgesetzt.
    </para>
    <para>
     Liefert bei Erfolg &true;, und im Fehlerfall
     &false;.
    </para>
    <para>
     <example>
      <title>Sortieren mehrerer Arrays</title>
      <programlisting role="php">
<![CDATA[
$ar1 = array ("10", 100, 100, "a");
$ar2 = array (1, 3, "2", 1);
array_multisort ($ar1, $ar2);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     In diesem Beispiel enthlt das erste Array nach dem Sortieren 10,
     "a", 100, 100. Das zweite Array wird 1, 1, "2", 3 enthalten. Die
     Eintrge des zweiten Arrays, welche den identischen Eintrgen des
     ersten Arrays entsprechen (100 und 100) wurden ebenfalls
     sortiert.
    </para>
    <para>
     <example>
      <title>Sortieren eines mehrdimensionalen Arrays</title>
      <programlisting role="php">
<![CDATA[
$ar = array (array ("10", 100, 100, "a"), array (1, 3, "2", 1));
array_multisort ($ar[0], SORT_ASC, SORT_STRING,
                 $ar[1], SORT_NUMERIC, SORT_DESC);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     In diesem Beispiel enthlt das erste Array nach dem Sortieren 10,
     100, 100, "a" (wurde als Strings in aufsteigender Reihenfolge
     sortiert), und das zweite enthlt 1, 3, "2", 1 (numerisch und
     absteigender Reihenfolge sortiert).
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-pad">
   <refnamediv>
    <refname>array_pad</refname>
    <refpurpose>
     Vergrert ein Array auf die spezifizierte Lnge mit einem Wert
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_pad</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam><type>int</type><parameter>pad_size</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>pad_value</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_pad</function> liefert eine Kopie von
     <parameter>input</parameter>, welche auf die von
     <parameter>pad_size</parameter> spezifizierte Gre mit dem Wert
     <parameter>pad_value</parameter> erweitert wurde. Ist der
     Parameter <parameter>pad_size</parameter> positiv, wird das Array
     rechts erweitert, ist er negativ, dann erfolgt die Erweiterung
     links. Ist der absolute Wert von <parameter>pad_size</parameter>
     kleiner oder gleich der Lnge von <parameter>input</parameter>,
     erfolgt keine Erweiterung.
    </para>
    <para>
     <example>
      <title><function>array_pad</function></title>
      <programlisting role="php">
<![CDATA[
$input = array (12, 10, 9);

$result = array_pad ($input, 5, 0);
// Ergebnis ist array (12, 10, 9, 0, 0)

$result = array_pad ($input, -7, -1);
// Ergebnis ist array (-1, -1, -1, -1, 12, 10, 9)

$result = array_pad ($input, 2, "noop");
// nicht erweitert
]]>
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-pop">
   <refnamediv>
    <refname>array_pop</refname>
    <refpurpose>Liefert das letzte Element eines Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>array_pop</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_pop</function> liefert den letzten Wert von
     <parameter>array</parameter>, und verkrzt
     <parameter>array</parameter> um ein Element. Ist
     <parameter>array</parameter> leer (oder kein Array), wird &null;
     zurckgegeben.
    </para>
    <para>
     <example>
      <title><function>array_pop</function></title>
      <programlisting role="php">
<![CDATA[
$stack = array ("Orange", "Banane", "Apfel", "Himbeere");
$fruit = array_pop ($stack);
]]>
      </programlisting>
      <para>
       Danach hat <varname>$stack</varname> nur 3 Elemente:
       <screen role="php">
<![CDATA[
Array
(
    [0] => Orange
    [1] => Banane
    [2] => Apfel
)
]]>
       </screen>
       und <literal>rasberry</literal> wird <varname>$fruit</varname>
       zugewiesen.
      </para>
     </example>
    </para>
    &return.falseproblem;
    <para>
     Siehe auch <function>array_push</function>,
     <function>array_shift</function> und
     <function>array_unshift</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-push">
   <refnamediv>
    <refname>array_push</refname>
    <refpurpose>
     Fgt ein oder mehr Elemente an das Ende eines Arrays
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>int</type><methodname>array_push</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_push</function> behandelt
     <parameter>array</parameter> als Stapel (Stack), und fgt die
     bergebenen Variablen an das Ende von
     <parameter>array</parameter>.  Die Lnge von
     <parameter>array</parameter> wird dabei um die Anzahl der
     angefgten Variablen erhht. Dies hat den selben Effekt wie:
     <programlisting role="php">
<![CDATA[
$array[] = $var;
]]>
     </programlisting>
     fr jede Variable <parameter>var</parameter> wiederholt.
    </para>
    <para>
     Liefert die neue Anzahl Elemente des Arrays.
    </para>
    <para>
     <example>
      <title><function>array_push</function></title>
      <programlisting role="php">
<![CDATA[
$stack = array ("Orange", "Banane");
array_push ($stack, "Apfel", "Himbeere");
]]>
      </programlisting>
      <para>
       Danach enthlt <varname>$stack</varname>
       die folgenden Elemente:
       <screen role="php">
<![CDATA[
Array
(
    [0] => Orange
    [1] => Banane
    [2] => Apfel
    [3] => Himbeere
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     Siehe auch <function>array_pop</function>,
     <function>array_shift</function> und
     <function>array_unshift</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-rand">
   <refnamediv>
    <refname>array_rand</refname>
    <refpurpose>
     Liefert einen oder mehrere zufllige Eintrge eines Arrays
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>array_rand</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>num_req</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_rand</function> ist ziemlich ntzlich, wenn Sie
     einen oder mehrere zufllige Eintrge eines Arrays auswhlen
     mchten. Die Funktion bernimmt das Array
     <parameter>input</parameter>, und ein optionales Argument
     <parameter>num_req</parameter>, welches die gewnschte Anzahl
     Eintrge spezifiziert. Ist <parameter>num_req</parameter> nicht
     angegeben, wird ein Defaultwert von 1 angenommen.
    </para>
    <para>
     Wenn Sie nur einen Eintrag auswhlen, liefert
     <function>array_rand</function> den Schlssel eines zuflligen
     Eintrages.  Andernfalls wird ein Array mit den Schlsseln der
     zuflligen Eintrge zurckgegeben. Dies hat den Zweck, dass Sie
     zufllige Schlssel und auch Werte aus dem Array auswhlen
     knnen.
    </para>
    <para>
     Vergessen Sie bitte nicht, mittels <function>srand</function> den
     Startwert fr den Zufallsgenerator festzulegen.
    </para>
    <para>
     <example>
      <title><function>array_rand</function></title>
      <programlisting role="php">
<![CDATA[
srand ((float) microtime() * 10000000);
$input = array ("Neo", "Morpheus", "Trinity", "Cypher", "Tank");
$rand_keys = array_rand ($input, 2);
print $input[$rand_keys[0]]."\n";
print $input[$rand_keys[1]]."\n";
]]>
      </programlisting>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-reverse">
   <refnamediv>
    <refname>array_reverse</refname>
    <refpurpose>
     Liefert ein Array mit umgekehrter Reihenfolge der Elemente
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_reverse</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>bool</type><parameter>preserve_keys</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_reverse</function> liefert ein Array mit der
     umgekehrten Reihenfolge der Elemente von
     <parameter>array</parameter>. Ist der optionale Parameter
     <parameter>preserve_keys</parameter> &true;, bleibt die
     Reihenfolge der Schlssel aufrecht.
    </para>
    <para>
     <example>
      <title><function>array_reverse</function></title>
      <programlisting role="php">
<![CDATA[
$input  = array ("php", 4.0, array ("grn", "rot"));
$result = array_reverse ($input);
$result_keyed = array_reverse ($input, TRUE);
]]>
      </programlisting>
      <para>
       Danach haben <varname>$result</varname> und
       <varname>$result_keyed</varname> die gleichen Elemente, aber
       Beachten Sie den Unterschied zwischen den Schlsseln. Die
       Ausgabe von <varname>$result</varname> und
       <varname>$result_keyed</varname> wird wie folgt aussehen:
       <screen role="php">
<![CDATA[
Array
(
    [0] => Array
        (
            [0] => grn
            [1] => rot
        )

    [1] => 4
    [2] => php
)
Array
(
    [2] => Array
        (
            [0] => grn
            [1] => rot
        )

    [1] => 4
    [0] => php
)
]]>
       </screen>
      </para>

     </example>
    </para>
    <note>
     <para>
      Der zweite Parameter wurde in PHP 4.0.3 hinzugefgt.
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.array-reduce">
   <refnamediv>
    <refname>array_reduce</refname>
    <refpurpose>
     Iterative Reduktion eines Arrays zu einem Wert mittels einer
     Callback Funktion
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>array_reduce</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>callback</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>initial</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_reduce</function> wendet die
     <parameter>callback</parameter> Funktion iterativ bei den
     Elementen des Arrays <parameter>input</parameter> so an, dass das
     Array auf einen einzigen Wert reduziert wird. Ist der optionale
     Parameter <parameter>intial</parameter> angegeben, wird er am
     Beginn des Prozesses, benutzt oder als Resultat verwendet, sollte
     das Array leer sein.
    </para>
    <para>
     <example>
      <title><function>array_reduce</function></title>
      <programlisting role="php">
<![CDATA[
function rsum($v, $w) {
    $v += $w;
    return $v;
}

function rmul($v, $w) {
    $v *= $w;
    return $v;
}

$a = array(1, 2, 3, 4, 5);
$x = array();
$b = array_reduce($a, "rsum");
$c = array_reduce($a, "rmul", 10);
$d = array_reduce($x, "rsum", 1);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Hier enthlt <varname>$b</varname> <literal>15</literal>,
     <varname>$c</varname> <literal>1200</literal> (= 1*2*3*4*5*10),
     und <varname>$d</varname> enthlt <literal>1</literal>.
    </para>
    <para>
     Siehe auch <function>array_filter</function> und
     <function>array_map</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-shift">
   <refnamediv>
    <refname>array_shift</refname>
    <refpurpose>
     Liefert ein Element vom Beginn eines Arrays
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>array_shift</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_shift</function> liefert den ersten Wert von
     <parameter>array</parameter>, verschiebt die anderen Werte
     hinunter, und verkrzt <parameter>array</parameter> um ein
     Element.  Ist <parameter>array</parameter> leer (oder kein
     Array), wird &null; zurckgegeben.
    </para>
    <para>
     <example>
      <title><function>array_shift</function></title>
      <programlisting role="php">
<![CDATA[
$stack = array ("Orange", "Banane", "Apfel", "Himbeere");
$fruit = array_shift ($stack);
]]>
      </programlisting>
      <para>
       Danach blieben in <varname>$stack</varname> 3 Elemente brig:
       <screen role="php">
<![CDATA[
Array
(
    [0] => Banane
    [1] => Apfel
    [2] => Himbeere
)
]]>
       </screen>
       und <literal>orange</literal> wird
       <varname>$fruit</varname> zugeordnet.
      </para>
     </example>
    </para>
    <para>
     Siehe auch <function>array_unshift</function>,
     <function>array_push</function> und
     <function>array_pop</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-slice">
   <refnamediv>
    <refname>array_slice</refname>
    <refpurpose>Extrahiert einen Ausschnitt eines Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_slice</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam><type>int</type><parameter>offset</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>
        length
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_slice</function> liefert die mittels
     <parameter>offset</parameter> und <parameter>length</parameter>
     spezifizierte Sequenz von Elementen des Arrays
     <parameter>array</parameter>
    </para>
    <para>
     Ist <parameter>offset</parameter> positiv, beginnt die Sequenz bei
     diesem Offset in dem <parameter>array</parameter>. Ist
     <parameter>offset</parameter> negativ, beginnt die Sequenz
     <parameter>offset</parameter> Elemente vor dem Ende von
     <parameter>array</parameter>.
    </para>
    <para>
     Ist <parameter>length</parameter> positiv, enthlt die Sequenz
     genauso viele Elemente. Ist <parameter>length</parameter>
     negativ, enthlt die Sequenz alle Elemente des Arrays von
     <parameter>offset</parameter> bis <parameter>length</parameter>
     Elemente vor dem Ende des Arrays. Ist
     <parameter>length</parameter> nicht angegeben, enthlt die
     Sequenz alle Elemente von <parameter>offset</parameter> bis zum
     Ende von <parameter>array</parameter>.
    </para>
    <para>
     Beachten Sie, dass <function>array_slice</function> Schlssel
     ignoriert, und Offsets sowie Lngen anhand der aktuellen
     Positionen berechnet.
    </para>
    <para>
     <example>
      <title><function>array_slice</function></title>
      <programlisting role="php">
<![CDATA[
$input = array ("a", "b", "c", "d", "e");

$output = array_slice ($input, 2);      // liefert "c", "d", und "e"
$output = array_slice ($input, 2, -1);  // liefert "c", "d"
$output = array_slice ($input, -2, 1);  // liefert "d"
$output = array_slice ($input, 0, 3);   // liefert "a", "b", und "c"
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Siehe auch <function>array_splice</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-splice">
   <refnamediv>
    <refname>array_splice</refname>
    <refpurpose>
     Entfernt einen Teil eines Arrays und ersetzt ihn durch etwas
     anderes
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_splice</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
      <methodparam><type>int</type><parameter>offset</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>length</parameter></methodparam>
      <methodparam choice="opt"><type>array</type><parameter>
        replacement
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_splice</function> entfernt die durch
     <parameter>offset</parameter> und <parameter>length</parameter>
     angegebenen Elemente des Arrays <parameter>input</parameter>, und
     ersetzt diese durch die Elemente des Arrays
     <parameter>replacement</parameter>, wenn angegeben und gibt ein
     Array mit den entfernten Elemente zurck.
    </para>
    <para>
     Ist <parameter>offset</parameter> positiv, beginnt der zu
     entfernende Bereich bei diesem Offset vom Anfang des Arrays
     <parameter>input</parameter>. Ist <parameter>offset</parameter>
     negativ, beginnt der zu entfernende Bereich
     <parameter>offset</parameter> Elemente vor dem Ende des Arrays
     <parameter>input</parameter>.
    </para>
    <para>
     Ist <parameter>length</parameter> nicht angegeben, wird alles von
     <parameter>offset</parameter> bis zum Ende des Arrays
     entfernt. Ist <parameter>length</parameter> positiv, wird die
     angegebene Anzahl Elemente entfernt. Ist
     <parameter>length</parameter> negativ, dann wird der Bereich von
     <parameter>length</parameter> Elementen vor dem Ende, bis zum
     Ende des Arrays entfernt. Tipp: Um alles von
     <parameter>offset</parameter> bis zum Ende des Arrays zu
     entfernen wenn <parameter>replacement</parameter> ebenfalls
     angegeben ist, verwenden Sie <literal>count($input)</literal> als
     <parameter>length</parameter>.
    </para>
    <para>
     Ist das Array <parameter>replacement</parameter> angegeben,
     werden die entfernten Elemente durch die Elemente dieses Arrays
     ersetzt. Sind <parameter>offset</parameter> und
     <parameter>length</parameter> so angegeben dass nichts entfernt
     wird, werden die Elemente von <parameter>replacement</parameter>
     an der von <parameter>offset</parameter> spezifizierten Stelle
     eingefgt. Tipp: Soll die Ersetzung durch nur ein Element erfolgen
     ist es nicht ntig ein Array zu anzugeben es sei denn, dieses
     Element ist selbst ein Array.
    </para>
    <para>
     Hier einige Entsprechungen:
     <programlisting role="php">
<![CDATA[
array_push ($input, $x, $y)     array_splice ($input, count ($input), 0,
                                             array ($x, $y))
array_pop ($input)              array_splice ($input, -1)
array_shift ($input)            array_splice ($input, 0, 1)
array_unshift ($input, $x, $y)  array_splice ($input, 0, 0, array ($x, $y))
$a[$x] = $y                     array_splice ($input, $x, 1, $y)
]]>
     </programlisting>
    </para>
    <para>
     Gibt das Array mit den entfernten Elementen zurck.
    </para>
    <para>
     <example>
      <title><function>array_splice</function></title>
      <programlisting role="php">
<![CDATA[
$input = array ("rot", "grn", "blau", "gelb");
array_splice ($input, 2);
// $input ist nun array ("rot", "grn")

$input = array ("rot", "grn", "blau", "gelb");
array_splice ($input, 1, -1);
// $input ist nun array ("rot", "gelb")

$input = array ("rot", "grn", "blau", "gelb");
array_splice ($input, 1, count($input), "orange");
// $input ist nun array ("rot", "orange")

$input = array ("rot", "grn", "blau", "gelb");
array_splice ($input, -1, 1, array("schwarz", "braun"));
// $input ist nun array ("rot", "grn", "blau", "schwarz", "braun")
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Siehe auch <function>array_slice</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-sum">
   <refnamediv>
    <refname>array_sum</refname>
    <refpurpose>
     Liefert die Summe der Werte in einem Array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>array_sum</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_sum</function> liefert die Summe der Werte eines
     Arrays als Integer oder Float.
    </para>
    <para>
     <example>
      <title><function>array_sum</function></title>
      <programlisting role="php">
<![CDATA[
$a = array(2, 4, 6, 8);
echo "sum(a) = ".array_sum($a)."\n";

$b = array("a"=>1.2,"b"=>2.3,"c"=>3.4);
echo "sum(b) = ".array_sum($b)."\n";
]]>
      </programlisting>
      <para>
       Obiges Programm wird folgendes ausgeben:
       <screen role="php">
<![CDATA[
sum(a) = 20
sum(b) = 6.9
]]>
       </screen>
      </para>
     </example>
    </para>
    <note>
     <para>
      PHP Versionen vor 4.0.6 haben das bergebene Array selbst
      modifiziert, und Strings in Zahlen konvertiert (welche
      abhngig von deren Wert meist zu null konvertiert wurden).
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.array-unique">
   <refnamediv>
    <refname>array_unique</refname>
    <refpurpose>Entfernt doppelte Werte aus einem Array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_unique</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_unique</function> nimmt
     <parameter>array</parameter> und gibt ein neues Array zurck, aus
     dem alle doppelten Eintrge entfernt wurden.
    </para>
    <para>
     Beachten Sie, dass Schlssel bewahrt bleiben. Erst behandelt
     <function>array_unique</function> die Werte als Strings und sortiert
     sie, danach wird der erste gefundene Schlssel behalten, und alle
     folgenden Schlssel ignoriert. Das heit nicht, dass der Schlssel
     des ersten zugehrigen Wertes aus dem unsortierten
     <parameter>array</parameter> behalten wird.
    </para>
    <note>
     <simpara>
      Zwei Elemente werden nur dann als gleich angesehen, wenn
      <literal>(string) $elem1 === (string) $elem2</literal>. In Worten:
      Wenn die String-Reprsentation die gleiche ist.
     </simpara>
     <simpara>
      Das erste Element wird verwendet.
     </simpara>
    </note>
    <warning>
     <simpara>
      Dies war in PHP 4.0.4 fehlerhaft!
     </simpara>
    </warning>
    <para>
     <example>
      <title><function>array_unique</function> example</title>
      <programlisting role="php">
<![CDATA[
$input = array ("a" => "grn", "rot", "b" => "grn", "blau", "rot");
$result = array_unique ($input);
print_r($result);
]]>
      </programlisting>
      <para>
       Dieses Programm wird folgendes ausgeben:
       <screen role="php">
<![CDATA[
Array
(
    [b] => grn
    [1] => blau
    [2] => rot
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     <example>
      <title><function>array_unique</function> und Typen</title>
      <programlisting role="php">
<![CDATA[
$input = array (4,"4","3",4,3,"3");
$result = array_unique ($input);
var_dump($result);
]]>
      </programlisting>
      <para>
       Dieses Programm wird folgendes ausgeben (PHP 4.0.6):
       <screen role="php">
<![CDATA[
array(2) {
  [3]=>
  int(4)
  [4]=>
  int(3)
}
]]>
       </screen>
      </para>
     </example>
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-unshift">
   <refnamediv>
    <refname>array_unshift</refname>
    <refpurpose>
     Fgt ein oder mehr Elemente am Anfang eines Arrays ein
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>int</type><methodname>array_unshift</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>
        ...
       </parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_unshift</function> fgt die bergebenen Elemente
     am Anfang von <parameter>array</parameter> ein. Beachten Sie,
     dass die Liste von Elementen als Ganzes eingefgt wird, sodass
     die eingefgten Elemente die selbe Reihenfolge haben.
    </para>
    <para>
     Diese Funktion gibt die neue Anzahl der in
     <parameter>array</parameter> enthaltenen Elemente zurck.
    </para>
    <para>
     <example>
      <title><function>array_unshift</function></title>
      <programlisting role="php">
<![CDATA[
$queue = array ("Orange", "Banane");
array_unshift ($queue, "Apfel", "Himbeere");
]]>
      </programlisting>
      <para>
       Als Ergebnis enthlt <varname>$queue</varname>
       die folgenden Elemente:
       <screen role="php">
<![CDATA[
Array
(
    [0] => Apfel
    [1] => Himbeere
    [2] => Orange
    [3] => Banane
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     Siehe auch <function>array_shift</function>,
     <function>array_push</function> und
     <function>array_pop</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-values">
   <refnamediv>
    <refname>array_values</refname>
    <refpurpose>Liefert alle Werte eines Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>array_values</methodname>
      <methodparam><type>array</type><parameter>input</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>array_values</function> liefert alle Werte des Arrays
     <parameter>input</parameter>.
    </para>
    <para>
     <example>
      <title><function>array_values</function></title>
      <programlisting role="php">
<![CDATA[
$array = array ("gre" => "XL", "farbe" => "gold");
print_r(array_values ($array));
]]>
      </programlisting>
      <para>
       Dies wird folgendes ausgeben:
       <screen role="php">
<![CDATA[
Array
(
    [0] => XL
    [1] => gold
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <note>
     <para>
      Diese Funktion wurde in PHP 4 hinzugefgt, nachstehend findet
      sich eine Implementation fr Benutzer von PHP 3.
      <example>
       <title>
	Implementation von <function>array_values</function> fr PHP 3
	Benutzer
       </title>
       <programlisting role="php">
<![CDATA[
function array_values ($arr) {
    $t = array();
    while (list($k, $v) = each ($arr)) {
        $t[] = $v;
    }
    return $t;
}
]]>
       </programlisting>
      </example>
     </para>
    </note>
    <para>
     Siehe auch <function>array_keys</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-walk">
   <refnamediv>
    <refname>array_walk</refname>
    <refpurpose>
     Wendet eine Benutzerfunktion an jedem Element eines Arrays an
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>int</type><methodname>array_walk</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam><type>string</type><parameter>func</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>userdata</parameter></methodparam>
     </methodsynopsis>
    <simpara>
     Wendet die mittels <parameter>func</parameter> angegebene
     Benutzerfunktion fr jedes Element von <parameter>arr</parameter>
     an. <parameter>func</parameter> wird der Wert als erster, und der
     Schlssel als zweiter Parameter bergeben. Sofern angegeben, wird
     <parameter>userdata</parameter>, als dritter Parameter an die
     Funktion <parameter>func</parameter> bergeben.
     <parameter>func</parameter> muss eine vom Benutzer definierte
     Funktion sein, und nicht eine native PHP Funktion. Deshalb knnen
     Sie <function>array_walk</function> nicht direkt mit
     <function>str2lower</function> benutzen, sondern mssen erst eine
     eigene Funktion damit erstellen, und diese Funktion als Argument
     bergeben.
    </simpara>
    &note.func-callback;
    <simpara>
     Sollte <parameter>func</parameter> mehr als zwei oder drei
     Argumente verlangen, wird - abhngig von
     <parameter>userdata</parameter> - bei jedem Aufruf von
     <parameter>func</parameter> seitens
     <function>array_walk</function> eine Warnmeldung generiert. Diese
     Warnmeldungen knnen unterdrckt werden, indem man dem
     Funktionsaufruf von <function>array_walk</function> ein '@'
     Zeichen voranstellt, oder mittels der Verwendung von
     <function>error_reporting</function>.
    </simpara>
    <note>
     <para>
      Wenn <parameter>func</parameter> mit den Werten des Arrays
      direkt arbeiten soll, geben Sie an, dass der erste Parameter von
      <parameter>func</parameter> als Referenz bergeben werden muss.
      Dann werden alle nderungen an diesen Elementen direkt in dem
      selbst durchgefhrt.
     </para>
     <para>
      Die Modifizierung des Arrays aus <parameter>func</parameter>
      heraus knnte ein unvorhersehbares Verhalten hervorrufen.
     </para>
    </note>
    <note>
     <para>
      Die bergabe des Schlssels und von
      <parameter>userdata</parameter> an <parameter>func</parameter>
      wurde mit PHP 4.0 eingefhrt.
     </para>
     <para>
      In PHP 4 muss <function>reset</function> aufgerufen werden, da
      <function>array_walk</function> den internen Zeiger nicht
      selbstttig wieder auf das erste Element zurcksetzt.
     </para>
    </note>
    <para>
     <example>
      <title><function>array_walk</function></title>
      <programlisting role="php">
<![CDATA[
$fruits = array ("d"=>"Zitrone", "a"=>"Orange", "b"=>"Banane", "c"=>"Apfel");

function test_alter (&$item1, $key, $prefix) {
    $item1 = "$prefix: $item1";
}

function test_print ($item2, $key) {
    echo "$key. $item2<br>\n";
}
echo "Vorher ...:\n";
array_walk ($fruits, 'test_print');
reset ($fruits);
array_walk ($fruits, 'test_alter', 'Frucht');
echo "... und nachher:\n";
reset ($fruits);
array_walk ($fruits, 'test_print');
]]>
      </programlisting>
      <para>
       Das obige Programm wird folgendes ausgeben:
       <screen role="php">
<![CDATA[
Vorher ...:
d. Zitrone
a. Orange
b. Banane
c. Apfel
... und nachher:
d. Frucht: Zitrone
a. Frucht: Orange
b. Frucht: Banane
c. Frucht: Apfel
]]>
       </screen>
      </para>
     </example>
    </para>
    <simpara>
     Siehe auch <function>each</function> und
     <function>list</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.arsort">
   <refnamediv>
    <refname>arsort</refname>
    <refpurpose>
     Sortiert ein Array in umgekehrter Reihenfolge und behlt die
     Verbindung zum Index
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>arsort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion sortiert ein Array so, dass der Zusammenhang zwischen
     den Indizes und den entsprechenden Arrayelementen erhalten bleibt.
     Dies wird hauptschlich bei assoziativen Arrays verwendet, bei denen
     die aktuelle Reihenfolge der Elemente bedeutend ist.
    </para>
     <example>
      <title><function>arsort</function></title>
      <programlisting role="php">
<![CDATA[
$fruits = array ("d"=>"Zitrone", "a"=>"Orange", "b"=>"Banane", "c"=>"Apfel");
arsort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
    echo "$key = $val\n";
}
]]>
      </programlisting>
     <para>
      Dieses Beispiel wrde folgendes ausgeben:
      <screen>
<![CDATA[
d = Zitrone
a = Orange
b = Banane
c = Apfel
]]>
      </screen>
     </para>
    </example>
    <para>
     Die Frchte wurden in umgekehrter alphabetischer Reihenfolge
     sortiert, und die Zuordnung zwischen Index und Element blieb
     beibehalten.
    </para>
    <para>
     Sie knnen das Verhalten der Sortierung mittels dem optionalen
     Parameter <parameter>sort_flags</parameter> beeinflussen, fr
     Details siehe <function>sort</function>.
    </para>
    <para>
     Siehe auch <function>asort</function>,
     <function>rsort</function>, <function>ksort</function> und
     <function>sort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.asort">
   <refnamediv>
    <refname>asort</refname>
    <refpurpose>
     Sortiert ein Array und behlt die Indexverbindungen
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>asort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion sortiert ein Array so, dass der Zusammenhang
     zwischen den Indizes und den entsprechenden Arrayelementen
     erhalten bleibt.  Dies wird hauptschlich bei assoziativen Arrays
     verwendet, bei denen die aktuelle Reihenfolge der Elemente
     bedeutend ist.
    </para>
    <example>
     <title><function>asort</function></title>
     <programlisting role="php">
<![CDATA[
$fruits = array ("d"=>"Zitrone", "a"=>"Orange", "b"=>"Banane", "c"=>"Apfel");
asort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
    echo "$key = $val\n";
}
]]>
     </programlisting>
     <para>
      Dieses Beispiel wrde folgendes ausgeben:
      <screen>
<![CDATA[
c = Apfel
b = Banane
a = Orange
d = Zitrone
]]>
      </screen>
     </para>
    </example>
    <para>
     Die Frchte wurden alphabetisch sortiert, und die Zuordnung
     zwischen Index und Element blieb beibehalten
    </para>
    <para>
     Sie knnen das Verhalten der Sortierung mittels dem optionalen
     Parameter <parameter>sort_flags</parameter> beeinflussen, fr
     Details siehe <function>sort</function>.
    </para>
    <para>
     Siehe auch <function>arsort</function>,
     <function>rsort</function>, <function>ksort</function> und
     <function>sort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.compact">
   <refnamediv>
    <refname>compact</refname>
    <refpurpose>
     Erstellt ein Array mit Variablen und deren Werten
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>compact</methodname>
      <methodparam><type>mixed</type><parameter>varname</parameter></methodparam>
      <methodparam choice="opt"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>compact</function> bernimmt eine variable Anzahl von
     Parametern. Jeder Parameter kann entweder ein String mit einem
     Variablennamen, oder ein Array mit Variablennamen sein. Dieses
     Array kann auch andere Arrays mit Variablennamen enthalten;
     <function>compact</function> behandelt sie rekursiv.
    </para>
    <para>
     Fr alle diese sucht <function>compact</function> nach einer
     Variablen in der aktuellen Symboltabelle, und fgt diese dem
     zurckzugebenden Array hinzu, wobei der Variablenname als
     Schlssel, und der Inhalt der Variablen als Wert gespeichert
     wird. Kurz, diese Funktion tut das Gegenteil von
     <function>extract</function>. Sie gibt ein Array mit allen
     Variablen zurck.
    </para>
    <para>
     Strings, welche nicht gesetzt sind, werden einfach ignoriert.
    </para>
    <para>
     <example>
      <title><function>compact</function></title>
      <programlisting role="php">
<![CDATA[
$city = "San Francisco";
$state = "CA";
$event = "SIGGRAPH";

$location_vars = array ("city", "state");

$result = compact ("event", "nothing_here", $location_vars);
]]>
      </programlisting>
      <para>
       Danach wird <varname>$result</varname>:
       <screen role="php">
<![CDATA[
Array
(
    [event] => SIGGRAPH
    [city] => San Francisco
    [state] => CA
)
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     Siehe auch <function>extract</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.count">
   <refnamediv>
    <refname>count</refname>
    <refpurpose>Zhlt die Elemente einer Variable</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>int</type><methodname>count</methodname>
      <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
     </methodsynopsis>
    <para>
     Liefert die Anzahl von Elementen in <parameter>var</parameter>,
     welche typischerweise ein <type>Array</type> ist (da alles andere
     ein Element enthlt).
    </para>
    <para>
     Ist <parameter>var</parameter> kein Array, wird <literal>1</literal>
     zurckgegeben (Ausnahme: <literal>count(&null;)</literal> ist gleich
     <literal>0</literal>).
    </para>
    <warning>
     <para>
      <function>count</function> kann 0 zurckgeben wenn die Variable
      nicht gesetzt ist, aber sie knnte ebenfalls 0 zurckgeben, wenn
      eine Variable als leeres Array initialisiert wurde. Verwenden Sie
      <function>isset</function> um zu testen, ob eine Variable gesetzt
      ist.
     </para>
    </warning>
    <para>
     In der Sektion <link linkend="language.types.array">Arrays</link>
     finden Sie eine detaillierte Erklrung, wie Arrays in PHP
     implementiert sind und wie sie benutzt werden.
    </para>
    <para>
     <example>
      <title><function>count</function></title>
      <programlisting role="php">
<![CDATA[
$a[0] = 1;
$a[1] = 3;
$a[2] = 5;
$result = count ($a);
//$result == 3

$b[0] = 7;
$b[5] = 9;
$b[10] = 11;
$result = count ($b);
// $result == 3;
]]>
      </programlisting>
     </example>
    </para>
    <note>
     <para>
     Die Funktion <function>sizeof</function> ist ein
     <link linkend="aliases">Alias</link> fr <function>count</function>.
     </para>
    </note>
    <para>
     Siehe auch <function>is_array</function>,
     <function>isset</function> und
     <function>strlen</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.current">
   <refnamediv>
    <refname>current</refname>
    <refpurpose>Liefert das aktuelle Element eines Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>current</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Jedes Array hat einen internen Zeiger auf sein "aktuelles"
     Element, welcher auf das erste in das Array eingefgte Element
     initialisiert wird.
    </para>
    <para>
     Die Funktion <function>current</function> liefert das Array
     Element, auf das gerade vom internen Zeiger gezeigt wird. Sie
     bewegt den Zeiger in keinster Weise. Zeigt der interne Zeiger
     hinter das Ende der Elementenliste, gibt
     <function>current</function> &false; zurck.
     <warning>
      <para>
       Enthlt das Array leere Elemente (0 oder "", den leeren
       String), gibt diese Funktion auch fr diese Elemente &false;
       zurck. Das macht es unmglich, unter Verwendung von
       <function>current</function> herauszufinden, ob das wirklich am
       Ende der Liste sind. Um ein Array, das leere Elemente enthalten
       knnte richtig durchzugehen, verwenden Sie die Funktion
       <function>each</function>.
      </para>
     </warning>
    </para>
    <para>
     Siehe auch <function>end</function>, <function>next</function>,
     <function>prev</function> und <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.each">
   <refnamediv>
    <refname>each</refname>
    <refpurpose>
     Liefert das aktuelle Paar (Schlssel und Wert) eines Arrays und
     rckt den Array Cursor vor.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>each</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Liefert das aktuelle Schlssel- Wertepaar des Arrays
     <parameter>array</parameter>, und erhht den Array Cursor. Dieses
     Paar wird als Array mit 4 Elementen zurckgegeben, und zwar mit
     den Schlsseln <emphasis>0</emphasis>, <emphasis>1</emphasis>,
     <emphasis>key</emphasis>, und <emphasis>value</emphasis>. Die
     Elemente <emphasis>0</emphasis> und <emphasis>key</emphasis>
     enthalten den Namen des Schlssels, <emphasis>1</emphasis> und
     <emphasis>value</emphasis> den Wert.
    </para>
    <para>
     Zeigt der interne Zeiger hinter das Ende der Array-Inhalte, gibt
     <function>each</function> &false; zurck.
    </para>
    <para>
     <example>
      <title><function>each</function> Beispiele</title>
      <programlisting role="php">
<![CDATA[
$foo = array ("bob", "fred", "jussi", "jouni", "egon", "marliese");
$bar = each ($foo);
]]>
      </programlisting>
      <para>
       <varname>$bar</varname> enthlt nun die folgenden Schlssel/Wert
       Paare:
       <itemizedlist spacing="compact">
        <listitem><simpara>0 =&gt; 0</simpara></listitem>
        <listitem><simpara>1 =&gt; 'bob'</simpara></listitem>
        <listitem><simpara>key =&gt; 0</simpara></listitem>
        <listitem><simpara>value =&gt; 'bob'</simpara></listitem>
       </itemizedlist>
       <programlisting role="php">
<![CDATA[
$foo = array ("Robert" => "Bob", "Seppo" => "Sepi");
$bar = each ($foo);
]]>
       </programlisting>
      </para>
      <para>
       <varname>$bar</varname> enthlt nun die folgenden Schlssel/Wert
       Paare:
       <itemizedlist spacing="compact">
        <listitem><simpara>0 =&gt; 'Robert'</simpara></listitem>
        <listitem><simpara>1 =&gt; 'Bob'</simpara></listitem>
        <listitem><simpara>key =&gt; 'Robert'</simpara></listitem>
        <listitem><simpara>value =&gt; 'Bob'</simpara></listitem>
       </itemizedlist>
      </para>
     </example>
    </para>
    <para>
     <function>each</function> wird typischerweise in Verbindung mit
     <function>list</function> verwendet, um ein Array durchzugehen;
     zum Beispiel <varname>$HTTP_POST_VARS</varname>:
     <example>
      <title>
       Durchgehen aller <varname>$HTTP_POST_VARS</varname> mit
       <function>each</function>
      </title>
      <programlisting role="php">
<![CDATA[
echo "Werte, die mit der POST Methode bertragen wurden:<br>";
reset ($HTTP_POST_VARS);
while (list ($key, $val) = each ($HTTP_POST_VARS)) {
    echo "$key => $val<br>";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Nachdem <function>each</function> ausgefhrt wurde, bleibt der
     Array Cursor beim nchsten Element des Arrays, oder wenn am Ende
     des Arrays angelangt, bei dem letzten Element. Sie mssen
     <function>reset</function> verwenden, wenn Sie das Array erneut
     mittels each durchgehen wollen.
    </para>
    <para>
     Siehe auch <function>key</function>, <function>list</function>,
     <function>current</function>, <function>reset</function>,
     <function>next</function> und <function>prev</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.end">
   <refnamediv>
    <refname>end</refname>
    <refpurpose>
     Positioniert den internen Zeiger eines Arrays auf dessen letztes Element
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>end</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>end</function> rckt den internen Zeiger von
     <parameter>array</parameter> bis zum letzten Element vor, und gibt
     dieses Element zurck.
    </para>
    <para>
     Siehe auch <function>current</function>,
     <function>each</function>,
     <function>next</function> und <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.extract">
   <refnamediv>
    <refname>extract</refname>
    <refpurpose>
     Importiert Variablen in die aktuelle Symboltabelle eines Arrays
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>int</type><methodname>extract</methodname>
      <methodparam><type>array</type><parameter>var_array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>extract_type</parameter></methodparam>
      <methodparam choice="opt"><type>string</type><parameter>prefix</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion wird verwendet, um Variablen eines Arrays in die
     aktuelle Symboltabelle zu importieren. Es behandelt die Schlssel
     des assoziativen Arrays <parameter>var_array</parameter> als
     Variablennamen, und die Werte als Variablenwerte. Fr jedes Paar
     Schlssel/Wert wird - abhngig von den Parametern
     <parameter>extract_type</parameter> und
     <parameter>prefix</parameter> - eine Variable in der aktuellen
     Symboltabelle eingetragen.
    </para>
    <note>
     <para>
      Seit Version 4.0.5 gibt diese Funktion die Anzahl der
      extrahierten Variablen zurck.
     </para>
    </note>
    <note>
     <para>
      EXTR_IF_EXISTS und EXTR_PREFIX_IF_EXISTS wurde in Version 4.2.0.
      eingefhrt.
     </para>
    </note>
    <para>
     <function>extract</function> prft jeden Schlssel, ob dieser
     einen gltigen Variablennamen ergibt, und auch auf eventuelle
     Kollisionen mit existierenden Variablen in der Symboltabelle. Die
     Art, wie ungltige/numerische Schlssel und Kollisionen behandelt
     werden, wird mit <parameter>extract_type</parameter>
     spezifiziert. Es kann einen der folgenden Werte annehmen:
     <variablelist>
      <varlistentry>
       <term>EXTR_OVERWRITE</term>
       <listitem>
        <simpara>
         Im Falle einer Kollision wird die existierende Variable
         berschrieben.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_SKIP</term>
       <listitem>
        <simpara>
         Im Falle einer Kollision wird die existierende Variable
         nicht berschrieben.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_PREFIX_SAME</term>
       <listitem>
        <simpara>Im Falle einer Kollision wird dem Variablennamen
        <parameter>prefix</parameter> vorangestellt.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_PREFIX_ALL</term>
       <listitem>
        <simpara>
         Allen Variablennamen wird <parameter>prefix</parameter>
         vorangestellt. Seit PHP 4.0.5 gilt dies auch fr numerische
         Schlssel.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_PREFIX_INVALID</term>
       <listitem>
        <simpara>
         Nur ungltigen/numerischen Variablennamen wird
         <parameter>prefix</parameter> vorangestellt. Dieser Flag
         wurde mit PHP 4.0.5 eingefhrt.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_IF_EXISTS</term>
       <listitem>
        <simpara>
         berschreibt die Variable nur, wenn sie bereits in der aktuellen
         Symboltabelle existiert, sonst geschieht nichts. Dies ist dann
         hilfreich, wenn Sie eine Liste mit gltigen Variablen definieren,
         und dann z.B. nur jene Variablen extrahieren, welche Sie aus
         $_REQUEST definiert haben. Dieser Flag wurde in PHP 4.2.0
         eingefhrt.
        </simpara>
       </listitem>
      </varlistentry>
      <varlistentry>
       <term>EXTR_PREFIX_IF_EXISTS</term>
       <listitem>
        <simpara>
         Erstellt nur Variablennamen mit Prfix, wenn die Version ohne
         Prfix der selben Variable in der aktuellen Symboltabelle
         existiert. Dieser Flag wurde in PHP 4.2.0 eingefhrt.
        </simpara>
       </listitem>
      </varlistentry>
     </variablelist>
    </para>
    <para>
     Ist <parameter>extract_type</parameter> nicht spezifiziert, so wird
     EXTR_OVERWRITE angenommen.
    </para>
    <para>
     Beachten Sie, dass <parameter>prefix</parameter> nur dann ntig
     ist, wenn <parameter>extract_type</parameter> EXTR_PREFIX_SAME,
     EXTR_PREFIX_ALL, EXTR_PREFIX_INVALID, oder EXTR_PREFIX_IF_EXISTS
     ist. Ist das Resultat trotz Prfix kein gltiger Variablenname,
     wird es nicht in die Symboltabelle importiert.
    </para>
    <para>
     <function>extract</function> gibt die Anzahl erfolgreich in die
     Symboltabelle importierter Variablen zurck.
    </para>
    <para>
     Eine mgliche Verwendung fr extract ist der Import der Variablen
     in einem von <function>wddx_deserialize</function> gelieferten
     assoziativen Array in die Symboltabelle.
    </para>
    <para>
     <example>
      <title><function>extract</function></title>
      <programlisting role="php">
<![CDATA[
<?php

/* Annahme: $var_array ist ein von wddx_deserialize
   zurckgegebenes Array */

$groesse = "gro";
$var_array = array ("farbe"   => "blau",
                    "groesse" => "mittel",
                    "form"    => "Kugel");
extract ($var_array, EXTR_PREFIX_SAME, "wddx");

print "$farbe, $groesse, $form, $wddx_groesse\n";

?>
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Das obige Beispiel wird folgendes ausgeben:
     <programlisting>
<![CDATA[
blau, gro, Kugel, mittel
]]>
     </programlisting>
    </para>
    <para>
     <varname>$size</varname> wurde nicht berschrieben, da wir
     EXTR_PREFIX_SAME spezifiziert haben, was im Anlegen von
     <varname>$wddx_size</varname> endete. Wre EXTR_SKIP spezifiziert
     worden, dann wre $wddx_size nicht angelegt worden. EXTR_OVERWRITE
     htte <varname>$size</varname> mit dem Wert "medium" berschrieben,
     und EXTR_PREFIX_ALL htte die neuen Variablen
     <varname>$wddx_color</varname>, <varname>$wddx_size</varname>,
     und <varname>$wddx_shape</varname> angelegt.
    </para>
    <para>
     Sie mssen assoziative Arrays benutzen, numerisch indizierte
     Arrays liefern keine Resultate.
    </para>
    <para>
     Siehe auch <function>compact</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.in-array">
   <refnamediv>
    <refname>in_array</refname>
    <refpurpose>Prft, ob ein Wert in einem Array existiert</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>bool</type><methodname>in_array</methodname>
      <methodparam><type>mixed</type><parameter>needle</parameter></methodparam>
      <methodparam><type>array</type><parameter>haystack</parameter></methodparam>
      <methodparam choice="opt"><type>bool</type><parameter>strict</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion sucht in <parameter>haystack</parameter> nach
     <parameter>needle</parameter> und gibt bei Erfolg &true; zurck,
     andernfalls &false;.
    </para>
    <para>
     Ist der dritte Parameter <parameter>strict</parameter> auf &true;
     gesetzt, prft <function>in_array</function> auch die
     <link linkend="language.types">Typen</link> von
     <parameter>needle</parameter> in <parameter>haystack</parameter>.
    </para>
    <note>
     <para>
      Ist <parameter>needle</parameter> ein String, erfolgt der Vergleich
      unter Bercksichtigung der Gro- und Kleinschreibung.
     </para>
    </note>
    <note>
     <para>
      In den PHP Versionen vor 4.2.0 durfte <parameter>needle</parameter>
      kein Array sein
     </para>
    </note>
    <para>
     <example>
      <title><function>in_array</function></title>
      <programlisting role="php">
<![CDATA[
$os = array ("Mac", "NT", "Irix", "Linux");
if (in_array ("Irix", $os)) {
    print "Got Irix";
}
if (in_array ("mac", $os)) {
    print "Got mac";
}
]]>
      </programlisting>
      <para>
       Die zweite Bedingung schlgt fehl, da <function>in_array</function>
       die Gro-/Kleinschreibung bercksichtigt, daher wird das obige
       Programm folgendes ausgeben:
       <screen role="php">
<![CDATA[
Got Irix
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     <example>
      <title><function>in_array</function> mit strict</title>
      <programlisting role="php">
<![CDATA[
<?php
$a = array('1.10', 12.4, 1.13);

if (in_array('12.4', $a, TRUE))
    echo "'12.4' gefunden mit strict check\n";
if (in_array(1.13, $a, TRUE))
    echo "1.13 gefunden mit strict check\n";
?>
]]>
      </programlisting>
      <para>
       Dies wird folgendes anzeigen:
       <screen role="php">
<![CDATA[
1.13 gefunden mit strict check
]]>
       </screen>
      </para>
     </example>
    </para>
    <para>
     <example>
      <title><function>in_array</function> mit einem Array als needle</title>
      <programlisting role="php">
<![CDATA[
<?php
$a = array(array('p', 'h'), array('p', 'r'), 'o');

if (in_array(array ('p', 'h'), $a))
    echo "'ph' wurde gefunden\n";
if (in_array(array ('f', 'i'), $a))
    echo "'fi' wurde nicht gefunden\n";
if (in_array('o', $a))
    echo "'o' wurde gefunden\n";
?>

// Dies wird folgendes anzeigen:

'ph' wurde gefunden
'o' wurde gefunden
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Siehe auch <function>array_search</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.array-search">
   <refnamediv>
    <refname>array_search</refname>
    <refpurpose>
     Durchsucht ein Array nach einem Wert liefert bei Erfolg den
     Schlssel
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>array_search</methodname>
      <methodparam><type>mixed</type><parameter>needle</parameter></methodparam>
      <methodparam><type>array</type><parameter>haystack</parameter></methodparam>
      <methodparam choice="opt"><type>bool</type><parameter>strict</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion durchsucht <parameter>haystack</parameter> nach
     <parameter>needle</parameter> und gibt bei Erfolg den Schlssel
     zurck, andernfalls &false;.
    </para>
    <para>
     Ist der optionale dritte Parameter <parameter>strict</parameter>
     auf &true; gesetzt, prft <function>in_array</function>
     auch die Typen von <parameter>needle</parameter> in
     <parameter>haystack</parameter>.
    </para>
    &return.falseproblem;
    <para>
     Siehe auch <function>in_array</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.key">
   <refnamediv>
    <refname>key</refname>
    <refpurpose>
     Liefert einen Schlssel eines assoziativen Arrays
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>key</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>key</function> liefert das Index Element der aktuellen
     Position im Array.
    </para>
    <para>
     Siehe auch <function>current</function> und
     <function>next</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.krsort">
   <refnamediv>
    <refname>krsort</refname>
    <refpurpose>
     Sortiert ein Array nach Schlsseln in umgekehrter Reihenfolge
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>int</type><methodname>krsort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Sortiert ein Array nach Schlsseln in umgekehrter Reihenfolge,
     wobei die Zuordnungen zwischen Schlssel und Wert erhalten
     bleiben. Dies ist hauptschlich bei assoziativen Arrays
     hilfreich.
     <example>
      <title><function>krsort</function></title>
      <programlisting role="php">
<![CDATA[
$fruits = array ("d"=>"Zitrone", "a"=>"Orange", "b"=>"Banane", "c"=>"Apfel");
krsort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
    echo "$key = $val\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Dieses Beispiel wrde folgendes ausgeben:
    </para>
    <para>
     <screen>
<![CDATA[
d = Zitrone
c = Apfel
b = Banane
a = Orange
]]>
     </screen>
    </para>
    <para>
     Sie knnen das Verhalten der Sortierung mittels dem optionalen
     Parameter <parameter>sort_flags</parameter> beeinflussen, fr
     Details siehe <function>sort</function>.
    </para>
    <simpara>
     Siehe auch <function>asort</function>, <function>arsort</function>,
     <function>ksort</function>, <function>sort</function>,
     <function>natsort</function> und <function>rsort</function>.
    </simpara>
   </refsect1>
  </refentry>

  <refentry id="function.ksort">
   <refnamediv>
    <refname>ksort</refname>
    <refpurpose>Sortiert ein Array nach Schlsseln</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>int</type><methodname>ksort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Sortiert ein Array nach Schlsseln, wobei die Zuordnungen
     zwischen Schlssel und Wert erhalten bleiben. Dies ist
     hauptschlich bei assoziativen Arrays hilfreich.
     <example>
      <title><function>ksort</function></title>
      <programlisting role="php">
<![CDATA[
$fruits = array ("d"=>"Zitrone", "a"=>"Orange", "b"=>"Banane", "c"=>"Apfel");
ksort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
    echo "$key = $val\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Dieses Beispiel wrde folgendes ausgeben:
    </para>
    <para>
     <screen>
<![CDATA[
a = Orange
b = Banane
c = Apfel
d = Zitrone
]]>
     </screen>
    </para>
    <para>
     Sie knnen das Verhalten der Sortierung mittels dem optionalen
     Parameter <parameter>sort_flags</parameter> beeinflussen, fr
     Details siehe <function>sort</function>.
    </para>
    <simpara>
     Siehe auch <function>asort</function>, <function>arsort</function>,
     <function>krsort</function>, <function>uksort</function>,
     <function>sort</function>, <function>natsort</function> und
     <function>rsort</function>.
    </simpara>
    <note>
     <para>
      Der zweite Parameter wurde mit PHP 4 eingefhrt.
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.list">
   <refnamediv>
    <refname>list</refname>
    <refpurpose>
     Weist Variablen zu, als wren sie ein Array
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>list</methodname>
      <methodparam rep="repeat"><type>mixed</type><parameter>...</parameter></methodparam>
     </methodsynopsis>
    <para>
     Wie <function>array</function> ist auch dies keine wirkliche
     Funktion, sondern ein Sprachkonstrukt. <function>list</function>
     wird verwendet, um eine Liste von Variablen innerhalb einer
     Operation zuzuweisen.
     <example>
      <title><function>list</function></title>
      <programlisting role="php">
<![CDATA[
<table>
 <tr>
  <th>Mitarbeitername</th>
  <th>Gehalt</th>
 </tr>

<?php

$result = mysql_query ("SELECT id, name, salary FROM employees",$conn);
while (list ($id, $name, $salary) = mysql_fetch_row ($result)) {
    print (" <tr>\n".
           "  <td><a href=\"info.php?id=$id\">$name</a></td>\n".
           "  <td>$salary</td>\n".
           " </tr>\n");
}

?>

</table>
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Siehe auch <function>each</function> und <function>array</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.natsort">
   <refnamediv>
    <refname>natsort</refname>
    <refpurpose>
     Sortiert ein Array in "natrlicher Reihenfolge"
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>natsort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion implementiert einen Sortieralgorithmus, welcher
     alphanumerische Zeichenketten reiht, wie es auch ein Mensch tun
     wrde. Hier ein Beispiel fr den Unterschied zwischen diesem und
     dem normalen Sortieralgorithmus fr Strings eines Computers
     (verwendet in <function>sort</function>):
    </para>
    <para>
     <example>
      <title><function>natsort</function></title>
      <programlisting role="php">
<![CDATA[
$array1 = $array2 = array ("img12.png", "img10.png", "img2.png", "img1.png");
sort ($array1);
echo "Standardsortierung\n";
print_r ($array1);

natsort ($array2);
echo "\nSortieren mit natrlicher Reihenfolge\n";
print_r ($array2);
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Der obige Code wird folgendes anzeigen:
    </para>
    <para>
     <screen>
<![CDATA[
Standardsortierung
Array
(
    [0] => img1.png
    [1] => img10.png
    [2] => img12.png
    [3] => img2.png
)

Sortieren mit natrlicher Reihenfolge
Array
(
    [3] => img1.png
    [2] => img2.png
    [1] => img10.png
    [0] => img12.png
)
]]>
     </screen>
     Detailliertere Informationen finden Sie auf Martin Pool's <ulink
     url="&url.strnatcmp;">Natural Order String Comparison</ulink>
     Seite.
    </para>
    <para>
     Siehe auch <function>natcasesort</function>,
     <function>strnatcmp</function> und
     <function>strnatcasecmp</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.natcasesort">
   <refnamediv>
    <refname>natcasesort</refname>
    <refpurpose>
     Sortiert ein Array in "natrlicher Reihenfolge",
     Gro/Kleinschreibung wird ignoriert
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>natcasesort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion implementiert einen Sortieralgorithmus, welcher
     alphanumerische Zeichenketten reiht, wie es auch ein Mensch tun
     wrde. Das wird als "natrliche Reihenfolge" bezeichnet.
    </para>
    <para>
     <function>natcasesort</function> arbeitet wie
     <function>natsort</function>, nur dass es die
     Gro/Kleinschreibung ignoriert. Ein Beispiel fr den Unterschied
     zwischen diesem und dem normalen Sortieralgorithmus fr Strings
     eines Computers finden Sie in <function>natsort</function>.
    </para>
    <para>
     Detailliertere Informationen finden Sie auf Martin Pool's <ulink
     url="&url.strnatcmp;">Natural Order String Comparison</ulink>
     Seite.
    </para>
    <para>
     Siehe auch <function>sort</function>,
     <function>natsort</function>,
     <function>strnatcmp</function> und
     <function>strnatcasecmp</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.next">
   <refnamediv>
    <refname>next</refname>
    <refpurpose>
     Rckt den internen Zeiger eines Arrays vor
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>next</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion gibt das nchste Element des Arrays zurck, auf
     das der interne Zeiger des Arrays gerade zeigt. Sind keine
     Elemente mehr vorhanden, wird &false; zurckgegeben.
    </para>
    <para>
     <function>next</function> verhlt sich hnlich wie
     <function>current</function>, mit einem Unterschied. Der interne
     Zeiger wird um ein Element vorgerckt, bevor das Element
     zurckgegeben wird, d.h. es wird das nchste Element
     zurckgegeben, und der interne Zeiger um eins erhht. Zeigt der
     interne Zeiger hinter das Ende der Elementliste, wird &false;
     zurckgegeben.
     <warning>
      <para>
       Enthlt das Array leere Elemente oder Elemente mit dem
       Schlssel 0, wird fr diese Elemente ebenfalls &false;
       zurckgegeben. Um ein Array, das leere Elemente oder Elemente
       mit dem Schlssel 0 enthalten knnte richtig durchzugehen,
       verwenden Sie die Funktion <function>each</function>.
      </para>
     </warning>
    </para>
    <para>
     Siehe auch <function>current</function>,
     <function>end</function>, <function>prev</function> und
     <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.pos">
   <refnamediv>
    <refname>pos</refname>
    <refpurpose>Liefert das aktuelle Element eines Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>pos</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <simpara>
     Dies ist nur ein <link linkend="aliases">Alias</link>
     fr die Funktion <function>current</function>.
    </simpara>
    <para>
     Siehe auch
     <function>end</function>, <function>next</function>,
     <function>prev</function> und <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.prev">
   <refnamediv>
    <refname>prev</refname>
    <refpurpose>
     Verkleinert den internen Zeiger eines Arrays
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>prev</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Liefert das Element vor der Position des Arrays, auf die der
     interne Zeiger gerade zeigt. Sind keine Elemente mehr vorhanden,
     wird &false; zurckgegeben.
     <warning>
      <para>
       Enthlt das Array leere Elemente, wird fr diese ebenfalls
       &false; zurckgegeben. Um ein Array mit leeren Elementen
       richtig durchzugehen, verwenden Sie die Funktion
       <function>each</function>.
      </para>
     </warning>
    </para>
    <para>
     <function>prev</function> verhlt sich wie
     <function>next</function>, nur dass hier der interne Zeiger um
     eine Position zurck, und nicht nach vorne gerckt wird.
    </para>
    <para>
     Siehe auch <function>current</function>,
     <function>end</function>, <function>next</function> und
     <function>reset</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.range">
   <refnamediv>
    <refname>range</refname>
    <refpurpose>
     Erstellt ein Array mit einem Bereich von Elementen
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>array</type><methodname>range</methodname>
      <methodparam><type>mixed</type><parameter>low</parameter></methodparam>
      <methodparam><type>mixed</type><parameter>high</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>range</function> gibt ein Array mit Elementen im
     Bereich von <parameter>low</parameter> bis
     <parameter>high</parameter> zurck. Wenn low > high, wird die
     Sequenz von high nach low sein.
    </para>
     <example>
      <title><function>range</function></title>
      <programlisting role="php">
<![CDATA[
foreach(range(0, 9) as $number) {
    echo $number;
}
foreach(range('a', 'z') as $letter) {
    echo $letter;
}
foreach(range('z', 'a') as $letter) {
    echo $letter;
}
]]>
      </programlisting>
     </example>
    <note>
     <para>
      Vor der Version 4.1.0 hat die Funktion
      <function>range</function> nur aufsteigende Integer Arrays
      erstellt. Die Untersttzung fr Zeichenfolgen und Arrays in
      absteigender Reihenfolge wurde in 4.1.0 hinzugefgt.
     </para>
     <example>
      <title>Dekrementieren von Bereichen und Zeichenketten simulieren</title>
      <programlisting role="php">
<![CDATA[
# array_reverse kann dazu verwendet werden,
# die Reihenfolge eines Bereiches umzudrehen
foreach(array_reverse(range(0,9)) as $number) {
    echo $number;
}

# array_map() kann benutzt werden, um Integer-Werte mittels
# chr() in Zeichen umzuwandeln
foreach(array_map('chr', range(ord('a'),ord('z'))) as $character) {
    echo $character;
}
]]>
      </programlisting>
     </example>
    </note>
    <para>
     Siehe <function>shuffle</function> fr ein weiteres
     Anwendungsbeispiel.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.reset">
   <refnamediv>
    <refname>reset</refname>
    <refpurpose>
     Setzt den internen Zeiger eines Arrays auf sein erstes Element
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>mixed</type><methodname>reset</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     <function>reset</function> setzt den internen Zeiger von
     <parameter>array</parameter> auf das erste Element zurck.
    </para>
    <para>
     <function>reset</function> gibt den Wert des ersten Arrayelements
     zurck.
    </para>
    <para>
     Siehe auch <function>current</function>,
     <function>each</function>, <function>next</function> und
     <function>prev</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.rsort">
   <refnamediv>
    <refname>rsort</refname>
    <refpurpose>
     Sortiert ein Array in umgekehrter Reihenfolge
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>rsort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion sortiert ein Array in umgekehrter Reihenfolge (vom
     hchsten zum niedrigsten Wert).
     <example>
      <title><function>rsort</function></title>
      <programlisting role="php">
<![CDATA[
$fruits = array ("Zitrone", "Orange", "Banane", "Apfel");
rsort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
    echo "$key = $val\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Dieses Beispiel wrde folgendes ausgeben:
    </para>
    <para>
     <screen>
<![CDATA[
0 = Zitrone
1 = Orange
2 = Banane
3 = Apfel
]]>
     </screen>
    </para>
    <para>
     Die Frchte wurden in umgekehrter alphabetischer Reihenfolge
     sortiert.
    </para>
    <para>
     Sie knnen das Verhalten der Sortierung mittels dem optionalen
     Parameter <parameter>sort_flags</parameter> beeinflussen, fr
     Details siehe <function>sort</function>.
    </para>
    <para>
     Siehe auch <function>arsort</function>,
     <function>asort</function>, <function>ksort</function>,
     <function>sort</function> und <function>usort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.shuffle">
   <refnamediv>
    <refname>shuffle</refname>
    <refpurpose>Mischt die Elemente eines Arrays</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>shuffle</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion mischt die Reihenfolge der Elemente eines Arrays
     zufllig (shuffle). Benutzen Sie <function>srand</function>, um
     den Startwert fr den Zufallsgenerator festzulegen.
     <example>
      <title><function>shuffle</function></title>
      <programlisting role="php">
<![CDATA[
$numbers = range (1,20);
srand ((float)microtime()*1000000);
shuffle ($numbers);
while (list (, $number) = each ($numbers)) {
    echo "$number ";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Siehe auch <function>arsort</function>,
     <function>asort</function>, <function>ksort</function>,
     <function>rsort</function>, <function>sort</function> und
     <function>usort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.sizeof">
   <refnamediv>
    <refname>sizeof</refname>
    <refpurpose>Liefert die Anzahl Elemente einer Variable</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>int</type><methodname>sizeof</methodname>
      <methodparam><type>mixed</type><parameter>var</parameter></methodparam>
     </methodsynopsis>
    <para>
     Die Funktion <function>sizeof</function> ist ein
     <link linkend="aliases">Alias</link> fr <function>count</function>.
    </para>
    <para>
     Siehe auch <function>count</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.sort">
   <refnamediv>
    <refname>sort</refname>
    <refpurpose>Sortiert ein Array</refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>sort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam choice="opt"><type>int</type><parameter>sort_flags</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion sortiert ein Array. Die Elemente werden
     aufsteigend vom niedrigsten zum hchsten Wert sortiert.
     <example>
      <title><function>sort</function></title>
      <programlisting role="php">
<![CDATA[
<?php

$fruits = array ("Zitrone", "Orange", "Banane", "Apfel");
sort ($fruits);
reset ($fruits);
while (list ($key, $val) = each ($fruits)) {
    echo "fruits[".$key."] = ".$val."\n";
}

?>
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Dieses Beispiel wrde folgendes anzeigen:
    </para>
    <para>
     <screen>
<![CDATA[
fruits[0] = Apfel
fruits[1] = Banane
fruits[2] = Orange
fruits[3] = Zitrone
]]>
     </screen>
    </para>
    <para>
     Die Frchte wurden in alphabetischer Reihenfolge sortiert.
    </para>
    <para>
     Der optionale zweite Parameter <parameter>sort_flags</parameter>
     kann benutzt werden, um das Sortierverhalten mit den folgenden
     Flags zu beeinflussen.
    </para>
    <para>
     Flags fr Sortiertypen:
     <itemizedlist>
      <listitem>
       <simpara>SORT_REGULAR - Vergleiche Eintrge normal</simpara>
      </listitem>
      <listitem>
       <simpara>SORT_NUMERIC - Vergleiche Eintrge numerisch</simpara>
      </listitem>
      <listitem>
       <simpara>SORT_STRING - Vergleiche Eintrge als Strings</simpara>
      </listitem>
     </itemizedlist>
    </para>
    <para>
     Siehe auch <function>arsort</function>,
     <function>asort</function>, <function>ksort</function>,
     <function>natsort</function>, <function>natcasesort</function>,
     <function>rsort</function>, <function>usort</function>,
     <function>array_multisort</function> und
     <function>uksort</function>.
    </para>
    <note>
     <para>
      Der zweite Parameter wurde in PHP 4 eingefhrt.
     </para>
    </note>
   </refsect1>
  </refentry>

  <refentry id="function.uasort">
   <refnamediv>
    <refname>uasort</refname>
    <refpurpose>
     Sortiert ein Array mittels einer benutzerdefinierten
     Vergleichsfunktion und behlt Indexassoziationen bei.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>uasort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam><type>function</type><parameter>cmp_function</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion sortiert ein Array so, dass die Beziehung der
     Indices zu den Arrayelementen beibehalten bleibt. Dies wird
     hauptschlich bei assoziativen Arrays angewandt, wenn die
     aktuelle Reihenfolge der Arrayelemente signifikant ist. Die
     Vergleichsfunktion wird vom Benutzer definiert.
    </para>
    <note>
     <para>
      Siehe <function>usort</function> und <function>uksort</function>
      fr Beispiele von benutzerdefinierten Vergleichsfunktionen
     </para>
    </note>
    &note.func-callback;
    <para>
     Siehe auch <function>usort</function>, <function>uksort</function>,
     <function>sort</function>, <function>asort</function>,
     <function>arsort</function>, <function>ksort</function>,
     und <function>rsort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.uksort">
   <refnamediv>
    <refname>uksort</refname>
    <refpurpose>
     Sortiert ein Array nach Schlsseln mittels einer
     benutzerdefinierten Vergleichsfunktion.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>uksort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam><type>function</type><parameter>cmp_function</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion sortiert die Schlssel eines Arrays mittels einer
     benutzerdefinierten Vergleichsfunktion. Soll das Array nach nicht
     trivialen Kriterien sortiert werden, sollten Sie diese Funktion
     verwenden.
    </para>
     <example>
      <title><function>uksort</function></title>
      <programlisting role="php">
<![CDATA[
function cmp ($a, $b) {
    if ($a == $b) return 0;
    return ($a > $b) ? -1 : 1;
}

$a = array (4 => "vier", 3 => "drei", 20 => "zwanzig", 10 => "zehn");

uksort ($a, "cmp");

while (list ($key, $value) = each ($a)) {
    echo "$key: $value\n";
}
]]>
      </programlisting>
     </example>
    <para>
     Dieses Beispiel wrde folgendes ausgeben:
    </para>
    <para>
     <screen>
<![CDATA[
20: zwanzig
10: zehn
4: vier
3: drei
]]>
     </screen>
    </para>
    &note.func-callback;
    <para>
     Siehe auch <function>usort</function>, <function>uasort</function>,
     <function>sort</function>, <function>asort</function>,
     <function>arsort</function>, <function>ksort</function>,
     <function>natsort</function> und <function>rsort</function>.
    </para>
   </refsect1>
  </refentry>

  <refentry id="function.usort">
   <refnamediv>
    <refname>usort</refname>
    <refpurpose>
     Sortiert ein Array nach Werten mittels einer benutzerdefinierten
     Vergleichsfunktion.
    </refpurpose>
   </refnamediv>
   <refsect1>
    <title>Beschreibung</title>
     <methodsynopsis>
      <type>void</type><methodname>usort</methodname>
      <methodparam><type>array</type><parameter>array</parameter></methodparam>
      <methodparam><type>string</type><parameter>cmp_function</parameter></methodparam>
     </methodsynopsis>
    <para>
     Diese Funktion sortiert ein Array nach seinen Werten mittels
     einer benutzerdefinierten Vergleichsfunktion. Soll das Array nach
     nicht trivialen Kriterien sortiert werden, sollten Sie diese
     Funktion verwenden.
    </para>
    <para>
     Die Vergleichsfunktion muss einen Integer zurckgeben, der
     kleiner, gleich, oder grer ist als &null;, wenn fr das erste
     Argument auch angenommen wird, dass es kleiner, gleich, oder
     grer ist als das zweite. Sind zwei Elemente gleich, ist deren
     Reihenfolge nicht definiert.
    </para>
    <para>
     <example>
      <title><function>usort</function></title>
      <programlisting role="php">
<![CDATA[
function cmp ($a, $b) {
    if ($a == $b) return 0;
    return ($a > $b) ? -1 : 1;
}

$a = array (3, 2, 5, 6, 1);

usort ($a, "cmp");

while (list ($key, $value) = each ($a)) {
    echo "$key: $value\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Dieses Beispiel wrde folgendes anzeigen:
    </para>
    <para>
     <screen>
<![CDATA[
0: 6
1: 5
2: 3
3: 2
4: 1
]]>
     </screen>
    </para>
    <note>
     <para>
      Offensichtlich wrde <function>rsort</function> fr diesen
      einfachen Fall besser passen.
     </para>
    </note>
    <para>
     <example>
      <title>
       <function>usort</function> Beispiel mit einem mehrdimensionalen
       Array
      </title>
      <programlisting role="php">
<![CDATA[
function cmp ($a, $b) {
    return strcmp($a["fruit"], $b["fruit"]);
}

$fruits[0]["fruit"] = "Zitronen";
$fruits[1]["fruit"] = "pfel";
$fruits[2]["fruit"] = "Trauben";

usort($fruits, "cmp");

while (list ($key, $value) = each ($fruits)) {
    echo "\$fruits[$key]: " . $value["fruit"] . "\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Wird ein mehrdimensionales Array sortiert, enthalten $a und $b
     Referenzen zu dem ersten Index des Arrays.
    </para>
    <para>
     Dieses Beispiel wrde folgendes anzeigen:
    </para>
    <para>
     <screen>
<![CDATA[
$fruits[0]: pfel
$fruits[1]: Trauben
$fruits[2]: Zitronen
]]>
     </screen>
    </para>
    &note.func-callback;
    <para>
     <example>
      <title>
       <function>usort</function> mit Verwendung einer Member Funktion eines Objektes
      </title>
      <programlisting role="php">
<![CDATA[
class TestObj {
    var $name;

    function TestObj($name)
    {
        $this->name = $name;
    }

    /* Dies ist die statische Vergleichsfunktion: */
    function cmp_obj($a, $b)
    {
        $al = strtolower($a->name);
        $bl = strtolower($b->name);
        if ($al == $bl) return 0;
        return ($al > $bl) ? +1 : -1;
    }
}

$a[] = new TestObj("c");
$a[] = new TestObj("b");
$a[] = new TestObj("d");

uasort($a, array ("TestObj", "cmp_obj"));

foreach ($a as $item) {
    print $item->name."\n";
}
]]>
      </programlisting>
     </example>
    </para>
    <para>
     Dieses Beispiel wrde folgendes anzeigen:
    </para>
    <para>
     <screen>
b
c
d
     </screen>
    </para>
    <warning>
     <para>
      Die zugrundeliegende quicksort Funktion in machen C
      Bibliotheken (wie z.B. Solaris Systeme) knnte einen PHP Crash
      verursachen, wenn die Vergleichsfunktion keine gleichbleibenden
      Werte zurckgibt.
     </para>
    </warning>
    <para>
     Siehe auch <function>uasort</function>,
     <function>uksort</function>, <function>sort</function>,
     <function>asort</function>,
     <function>arsort</function>,<function>ksort</function>,
     <function>natsort</function> und <function>rsort</function>.
    </para>
   </refsect1>
  </refentry>

 </reference>

<!-- 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:"../../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
-->