variables.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 22583751fbfdaa3eaa41aeb6470d1343f5cb2c78 Maintainer: nobody Status: ready -->
<!-- Reviewed: no -->
<!-- Credits: betz -->
 <chapter xml:id="language.variables" xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink">
  <title>Variablen</title>

  <sect1 xml:id="language.variables.basics">
   <title>Grundlegendes</title>

   <simpara>
    Variablen werden in PHP durch ein Dollar-Zeichen ($) gefolgt vom Namen der
    Variable dargestellt. Bei Variablennamen wird zwischen Groß- und
    Kleinschreibung unterschieden (case-sensitive).
   </simpara>

   <para>
    Ein gültiger Variablenname beginnt mit einem Buchstaben
    (<literal>A-Z</literal>, <literal>a-z</literal> oder die Bytes von 128 bis 255)
    oder einem Unterstrich ("_"), gefolgt von einer beliebigen Anzahl von
    Buchstaben, Zahlen oder Unterstrichen. Als regulärer Ausdruck
    (Regular Expression) würde das wie folgt ausgedrückt:
    <code>^[a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]*$</code>
   </para>

   <note>
    <simpara>
     PHP unterstützt keine Unicode-Variablennamen, aber einige
     Zeichenkodierungen (&zb; UTF-8) kodieren Zeichen so, dass alle Bytes eines
     Multi-Byte-Zeichens in den erlaubten Bereich fallen und somit einen
     gültigen Variablennamen darstellen.
    </simpara>
   </note>

   <note>
    <simpara>
     <literal>$this</literal> ist eine spezielle Variable, die nicht geändert
     werden kann. Vor PHP 7.1.0 war die indirekte Zuweisung, &zb; durch die
     Verwendung von <link linkend="language.variables.variable">variable
     Variablen</link>, möglich.
    </simpara>
   </note>

   &tip.userlandnaming;

   <example>
    <title>Gültige Variablennamen</title>
    <programlisting role="php">
<![CDATA[
<?php
$var = "du";
$Var = "ich";
echo "$var, $Var";       // gibt "du, ich" aus

$_4site = 'noch nicht';  // gültig, da Unterstrich am Anfang
$täbyte = 'irgendwas';   // gültig, da 'ä' dem (Erweiterten) ASCII-Wert 228 entspricht
?>
]]>
    </programlisting>
   </example>

   <example>
    <title>Ungültige Variablennamen</title>
    <programlisting role="php">
<![CDATA[
<?php
$4site = 'noch nicht';     // ungültig, da Anfang eine Zahl
]]>
    </programlisting>
   </example>

   <simpara>
    PHP akzeptiert eine Folge von beliebigen Bytes als Variablennamen. Auf
    Variablennamen, die nicht den oben genannten Benennungsregeln entsprechen,
    kann nur dynamisch zur Laufzeit zugegriffen werden. Siehe
    <link linkend="language.variables.variable">variable Variablen</link>
    für Informationen, wie man auf sie zugreifen kann.
   </simpara>

   <example>
    <title>Zugriff auf unklare Variablennamen</title>
    <programlisting role="php">
<![CDATA[
<?php
${'ungueltiger-name'} = 'bar';
$name = 'ungueltiger-name';
echo ${'ungueltiger-name'}, " ", $$name;
?>
]]>
    </programlisting>
    &example.outputs;
    <screen>
<![CDATA[
bar bar
]]>
    </screen>
   </example>

   <para>
    Standardmäßig wird Variablen immer ein Wert zugewiesen. Das heißt, wenn
    einer Variablen ein Ausdruck zugewiesen wird, wird der gesamte Inhalt des
    Originalausdrucks in die Zielvariable kopiert. Das bedeutet zum Beispiel,
    dass nach der Zuweisung des Wertes einer Variablen an eine andere die
    Änderung einer der Variablen keinen Einfluss auf die andere hat. Für
    weitere Informationen zu dieser Art der Zuordnung lesen Sie bitte das
    Kapitel unter
    <link linkend="language.expressions">Expressions / Ausdrücke</link>.
   </para>
   <para>
    PHP bietet eine andere Möglichkeit der Wertzuweisung bei Variablen:
    <link linkend="language.references">Zuweisung durch Referenzierung</link>.
    Das bedeutet, dass der Wert der neuen Variablen eine Referenz zur
    Ursprungs-Variablen darstellt (mit anderen Worten: Der Wert ist ein Alias
    bzw. Zeiger auf den Inhalt der Ursprungsvariablen). Änderungen der neuen
    Variablen ändern auch deren Ursprungs-Variable und umgekehrt.
   </para>
   <para>
    Für die Zuweisung per Referenz müssen Sie der Ursprungsvariablen, die Sie
    einer anderen Variablen zuweisen wollen, lediglich ein kaufmännisches Und
    (&amp;) voranstellen. Das folgende Code-Schnipsel wird zweimal
    '<literal>Ich heiße Bob</literal>' ausgeben:

    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$foo = 'Bob';             // 'Bob' der Variablen $foo zuweisen.
$bar = &$foo;             // $foo per $bar referenzieren.
$bar = "Ich heiße $bar";  // $bar verändern...
echo $bar;
echo $foo;                 // $foo wurde ebenfalls verändert.
?>
]]>
     </programlisting>
    </informalexample>
   </para>

   <para>
    Zu beachten ist, dass nur Variablen referenziert werden können.
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
$foo = 25;
$bar = &$foo;      // Gültige Zuweisung.
$bar = &(24 * 7);  // Ungültig, da ein unbenannter Ausdruck referenziert wird.

function test()
{
    return 25;
}

$bar = &test();    // Ungültig, da test() keine Variable per Referenz zurückgibt.
?>
]]>
     </programlisting>
    </informalexample>
   </para>

   <para>
    Es ist in PHP nicht notwendig, Variablen zu deklarieren, aber es wird
    empfohlen. Der Versuch, auf eine undefinierte Variable zuzugreifen, führt
    zu einem Fehler der Stufe <constant>E_WARNING</constant> (vor PHP 8.0.0,
    <constant>E_NOTICE</constant>).
    Eine undefinierte Variable hat den Standardwert &null;.
    Um zu prüfen, ob eine Variable bereits initialisiert wurde, kann das
    Sprachkonstrukt <function>isset</function> verwendet werden.
   </para>
   <para>
    <example>
     <title>Vorgabewert einer nicht initialisierten Variable</title>
     <programlisting role="php">
<![CDATA[
<?php
// Nicht gesetzte UND nicht referenzierte (kein Verwendungskontext) Variable.
var_dump($unset_var);
?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
Warning: Undefined variable $unset_var in ...
NULL
]]>
     </screen>
    </example>
   </para>

   <simpara>
    PHP erlaubt die Autovivifikation von Arrays (automatische Erstellung neuer
    Arrays) aus einer undefinierten Variable.
    Das Anhängen eines Elements an eine undefinierte Variable erzeugt ein neues
    Array und führt nicht zu einer Warnung.
   </simpara>
   <example>
    <title>Autovivifikation eines Arrays aus einer undefinierten Variable</title>
    <programlisting role="php">
<![CDATA[
<?php
$unset_array[] = 'value'; // Erzeugt keine Warnung.
?>
]]>
    </programlisting>
   </example>

   <warning>
    <simpara>
     Sich auf den Standardwert einer nicht initialisierten Variablen zu
     verlassen, ist problematisch, wenn eine Datei in eine andere eingebunden
     wird, die denselben Variablennamen verwendet.
    </simpara>
   </warning>

   <simpara>
    Eine Variable kann mit dem Sprachkonstrukt <function>unset</function>
    gelöscht werden.
   </simpara>

   <simpara>
    Für Informationen zu variablenbezogenen Funktionen siehe
    <link linkend="ref.var">Referenz zu Variablenfunktionen</link>.
   </simpara>
  </sect1>

  <sect1 xml:id="language.variables.predefined">
   <title>Vordefinierte Variablen</title>

   <para>
    PHP bietet eine Reihe
    <link linkend="reserved.variables">vordefinierter Variablen</link>.
    Darüber hinaus bietet PHP eine Reihe zusätzlicher vordefinierter Arrays,
    die Variablen vom Webserver (gegebenenfalls), von der Umgebung und von
    Benutzereingaben enthalten. Diese Arrays stehen automatisch in jedem
    Geltungsbereich zur Verfügung. Aus diesem Grund werden sie oft als
    "Superglobale" bezeichnet. (Es gibt in PHP keinen Mechanismus für
    benutzerdefinierte Superglobale.) Details hierzu sind unter
    <link linkend="language.variables.superglobals">Liste der Superglobalen</link>
    zu finden.
   </para>

   <note>
    <title>Variable Variablen</title>
    <para>
     Superglobale können innerhalb von Funktionen und Methoden nicht als
     <link linkend="language.variables.variable">variable Variablen</link>
     verwendet werden.
    </para>
   </note>

   <para>
    Falls bestimmte Variablen nicht unter
    <link linkend="ini.variables-order">variables_order</link> angegeben sind,
    dann bleiben auch ihre entsprechenden vordefinierten Arrays leer.
   </para>
  </sect1>

  <sect1 xml:id="language.variables.scope">
   <title>Geltungsbereich von Variablen</title>

   <simpara>
    Der Geltungsbereich einer Variablen ergibt sich aus dem Zusammenhang, in
    dem sie definiert wurde.
    PHP hat einen Funktionsbereich und einen globalen Bereich.
    Jede Variable, die außerhalb einer Funktion definiert wird, ist auf den
    globalen Bereich beschränkt. Wenn eine Datei eingebunden wird, erbt der
    darin enthaltene Code den Variablenbereich der Zeile, in der die Einbindung
    erfolgt.
   </simpara>
   <example>
    <title>Beispiel für den Geltungsbereich globaler Variablen</title>
    <programlisting role="php">
<![CDATA[
<?php
$a = 1;
include 'b.inc'; // Die Variable $a wird in b.inc verfügbar sein
?>
]]>
    </programlisting>
   </example>

   <simpara>
    Jede Variable, die innerhalb einer benannten Funktion oder einer
    <link linkend="functions.anonymous">anonymen</link> Funktion erstellt
    wird, ist auf den Bereich des Funktionskörpers beschränkt.
    Im Gegensatz dazu binden
    <link linkend="functions.arrow">Pfeilfunktionen</link> Variablen aus dem
    übergeordneten Bereich, um sie im Körper verfügbar zu machen.
    Wenn eine Datei innerhalb einer Funktion der aufrufenden Datei eingebunden
    wird, sind die in der aufgerufenen Datei enthaltenen Variablen so
    verfügbar, als wären sie innerhalb der aufrufenden Funktion definiert
    worden.
   </simpara>

   <example>
    <title>Beispiel für den Geltungsbereich lokaler Variablen</title>
    <programlisting role="php">
<![CDATA[
<?php
$a = 1; // globaler Geltungsbereich

function test()
{
    echo $a; // Die Variable $a ist undefiniert, da sie sich auf eine lokale
             // Version von $a bezieht
}
?>
]]>
    </programlisting>
   </example>

   <simpara>
    Das obige Beispiel erzeugt ein <constant>E_WARNING</constant> wegen einer
    undefinierten Variable (oder ein E_NOTICE vor PHP 8.0.0). Das liegt daran,
    dass sich die echo-Anweisung auf eine lokale Variable namens
    <varname>$a</varname> bezieht, und dieser kein Wert im lokalen
    Geltungsbereich zugewiesen wurde. Es ist zu beachten, dass sich dies etwas
    von C unterscheidet, da in C globale Variablen automatisch für Funktionen
    zur Verfügung stehen, es sei denn, sie werden durch eine funktionsinterne
    Definition überschrieben. Dies kann zu Problemen führen, da eine globale
    Variable versehentlich geändert werden kann. In PHP müssen globale
    Variablen innerhalb einer Funktionen deklariert werden, wenn sie in dieser
    Funktion verwendet werden sollen.
   </simpara>

   <sect2 xml:id="language.variables.scope.global">
    <title>Das Schlüsselwort <literal>global</literal></title>
    <simpara>
     Das Schlüsselwort <literal>global</literal> wird verwendet, um eine
     Variable aus einem globalen Bereich in einen lokalen Bereich zu binden.
     Das Schlüsselwort kann mit einer Liste von Variablen oder einer einzelnen
     Variablen verwendet werden. Es wird eine lokale Variable erstellt, die auf
     die gleichnamige globale Variable verweist. Wenn die globale Variable
     nicht existiert, wird sie im globalen Bereich erstellt und erhält den Wert
     &null;.
    </simpara>
    <para>
     <example>
      <title>Verwendung von <literal>global</literal></title>
      <programlisting role="php">
<![CDATA[
<?php
$a = 1;
$b = 2;

function Sum()
{
    global $a, $b;

    $b = $a + $b;
}

Sum();
echo $b;
?>
]]>
      </programlisting>
      &example.outputs;
      <screen>
<![CDATA[
3
]]>
      </screen>
     </example>
    </para>

   <simpara>
    Durch das Deklarieren der Variablen <varname>$a</varname> und
    <varname>$b</varname> innerhalb der Funktion als global weisen alle
    Referenzen zu beiden Variablen auf die nun globalen Werte. Es gibt keine
    Beschränkungen bei der Anzahl an globalen Variablen, die durch eine
    Funktion verändert werden können.
   </simpara>

   <simpara>
    Eine weitere Möglichkeit, auf Variablen aus dem globalen Bereich
    zuzugreifen, besteht in der Verwendung des speziellen, von PHP definierten
    Arrays <varname>$GLOBALS</varname>. Das obige Beispiel kann damit auch so
    geschrieben werden:
   </simpara>
   <para>
    <example>
     <title>Verwendung von <varname>$GLOBALS</varname> statt global</title>
     <programlisting role="php">
<![CDATA[
<?php
$a = 1;
$b = 2;

function Sum()
{
    $GLOBALS['b'] = $GLOBALS['a'] + $GLOBALS['b'];
}

Sum();
echo $b;
?>
]]>
     </programlisting>
    </example>
   </para>

   <simpara>
    Das <varname>$GLOBALS</varname>-Array ist ein assoziatives Array mit dem
    Namen der globalen Variablen als Schlüssel und dem Inhalt dieser Variablen
    als Wert des Array-Elements. Beachten Sie, dass
    <varname>$GLOBALS</varname> in jedem Geltungsbereich existiert, weil
    <varname>$GLOBALS</varname> eine
    <link linkend="language.variables.superglobals">Superglobale</link> ist.
    Hier ist ein Beispiel, das die Stärke von Superglobalen verdeutlicht:
   </simpara>
   <para>
    <example>
     <title>Beispiel zur Demonstration von Superglobalen und Geltungsbereich</title>
     <programlisting role="php">
<![CDATA[
<?php
function test_superglobal()
{
    echo $_POST['name'];
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <note>
    <simpara>
     Die Verwendung des Schlüsselworts <literal>global</literal> außerhalb
     einer Funktion ist kein Fehler. Es kann verwendet werden, wenn die Datei
     innerhalb einer Funktion eingebunden wird.
    </simpara>
   </note>
  </sect2>

  <sect2 xml:id="language.variables.scope.static">
   <title>Die Verwendung von <literal>static</literal> Variablen</title>
   <simpara>
    Ein weiterer wichtiger Anwendungszweck von Variablen-Bereichen ist die
    <emphasis>statische</emphasis> Variable. Eine statische Variable existiert
    nur in einem lokalen Funktions-Geltungsbereich, der Wert geht beim
    Verlassen dieses Bereichs aber nicht verloren. Schauen Sie das folgende
    Beispiel an:
   </simpara>
   <para>
    <example>
     <title>Beispiel, das die Notwendigkeit von statischen Variablen demonstriert</title>
     <programlisting role="php">
<![CDATA[
<?php
function test()
{
    $a = 0;
    echo $a;
    $a++;
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <simpara>
    Diese Funktion ist sinnlos, da sie bei jedem Aufruf <varname>$a</varname>
    auf <literal>0</literal> setzt und <literal>0</literal> ausgibt. Die
    Anweisung <varname>$a</varname>++, welche den Wert erhöht, erfüllt keinen
    Zweck, da der Wert von <varname>$a</varname> beim Verlassen der Funktion
    verloren geht. Um eine sinnvolle Zählfunktion zu implementieren, die ihren
    aktuell gesetzten Wert nicht vergisst, müssen Sie die Variable
    <varname>$a</varname> als statisch deklarieren:
   </simpara>
   <para>
    <example>
     <title>Beispiel zur Verwendung statischer Variablen</title>
     <programlisting role="php">
<![CDATA[
<?php
function test()
{
    static $a = 0;
    echo $a;
    $a++;
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <simpara>
    Nun wird <varname>$a</varname> nur beim ersten Aufruf der Funktion
    initialisiert, und jedes mal wenn die Funktion <literal>test()</literal>
    aufgerufen wird, wird sie den Wert von <varname>$a</varname> ausgeben und
    den Variablenwert erhöhen.
   </simpara>

   <simpara>
    Statische Variablen ermöglichen auch einen Weg zum Umgang mit rekursiven
    Funktionen. Die folgende einfache Funktion zählt rekursiv bis 10. Die
    statische Variable <varname>$count</varname> wird verwendet, um die
    Rekursion zu beenden:
   </simpara>
   <para>
    <example>
     <title>Statische Variablen in rekursiven Funktionen</title>
     <programlisting role="php">
<![CDATA[
<?php
function test()
{
    static $count = 0;

    $count++;
    echo $count;
    if ($count < 10) {
        test();
    }
    $count--;
}
?>
]]>
     </programlisting>
    </example>
   </para>
   <para>
    Vor PHP 8.3.0 konnten statische Variablen nur mit einem konstanten Ausdruck
    initialisiert werden. Seit PHP 8.3.0 sind auch dynamische Ausdrücke (&zb;
    Funktionsaufrufe) erlaubt:
   </para>
   <para>
    <example>
     <title>Statische Variablen deklarieren</title>
     <programlisting role="php">
<![CDATA[
<?php
function foo(){
    static $int = 0;          // korrekt
    static $int = 1+2;        // korrekt
    static $int = sqrt(121);  // korrekt seit PHP 8.3.0

    $int++;
    echo $int;
}
?>
]]>
     </programlisting>
    </example>
   </para>

   <simpara>
    Statische Variablen innerhalb anonymer Funktionen bleiben nur innerhalb der
    jeweiligen Funktionsinstanz bestehen. Wenn die anonyme Funktion bei jedem
    Aufruf neu erstellt wird, wird die statische Variable neu initialisiert.
   </simpara>
   <example>
    <title>Statische Variablen in anonymen Funktionen</title>
    <programlisting role="php">
<![CDATA[
<?php
function exampleFunction($input) {
    $result = (static function () use ($input) {
        static $counter = 0;
        $counter++;
        return "Eingabe: $input, Zähler: $counter\n";
    });

    return $result();
}

// Bei Aufrufen von exampleFunction wird die anonyme Funktion neu erstellt,
// so dass die statische Variable ihren Wert nicht beibehält.
echo exampleFunction('A'); // Ausgabe: Eingabe: A, Zähler: 1
echo exampleFunction('B'); // Ausgabe: Eingabe: B, Zähler: 1
?>
]]>
    </programlisting>
   </example>

   <para>
    Wenn eine Methode, die statische Variablen verwendet, vererbt (aber nicht
    überschrieben) wird, teilt die vererbte Methode seit PHP 8.1.0 die
    statischen Variablen mit der Elternmethode. Das bedeutet, dass sich
    statische Variablen in Methoden nun genauso verhalten wie statische
    Eigenschaften.
   </para>

   <simpara>
    Seit PHP 8.3.0 können statische Variablen mit beliebigen Ausdrücken
    initialisiert werden.
    Das bedeutet, dass &zb; Methodenaufrufe verwendet werden können, um
    statische Variablen zu initialisieren.
   </simpara>

   <example>
    <title>Verwendung statischer Variablen in geerbten Methoden</title>
    <programlisting role="php">
<![CDATA[
<?php
class Foo {
    public static function counter() {
        static $counter = 0;
        $counter++;
        return $counter;
    }
}
class Bar extends Foo {}
var_dump(Foo::counter()); // int(1)
var_dump(Foo::counter()); // int(2)
var_dump(Bar::counter()); // int(3), vor PHP 8.1.0 int(1)
var_dump(Bar::counter()); // int(4), vor PHP 8.1.0 int(2)
?>
]]>
    </programlisting>
   </example>
  </sect2>

  <sect2 xml:id="language.variables.scope.references">
   <title>Referenzen bei <literal>global</literal> und <literal>static</literal> Variablen</title>
   <simpara>
    PHP implementiert die Modifikatoren
    <link linkend="language.variables.scope.static">static</link> und
    <link linkend="language.variables.scope.global">global</link> für
    Variablen als
    <link linkend="language.references">Referenzen</link>. Zum Beispiel
    erzeugt eine echte globale Variable, die mit der Anweisung
    <literal>global</literal> in den Funktions-Geltungsbereich importiert
    wurde, tatsächlich eine Referenz zur globalen Variable. Das kann zu einem
    unerwarteten Verhalten führen, auf das im folgenden Beispiel eingegangen
    wird:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
function test_global_ref() {
    global $obj;
    $new = new stdClass;
    $obj = &$new;
}

function test_global_noref() {
    global $obj;
    $new = new stdClass;
    $obj = $new;
}

test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>
]]>
    </programlisting>
   </informalexample>

   &example.outputs;

   <screen>
<![CDATA[
NULL
object(stdClass)#1 (0) {
}
]]>
   </screen>

   <simpara>
    Ein ähnliches Verhalten gilt auch für die Anweisung
    <literal>static</literal>. Referenzen werden nicht statisch gespeichert:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
function &get_instance_ref() {
    static $obj;

    echo 'Statisches Objekt: ';
    var_dump($obj);
    if (!isset($obj)) {
        $new = new stdClass;
        // Der statischen Variablen eine Referenz zuweisen
        $obj = &$new;
    }
    if (!isset($obj->property)) {
        $obj->property = 1;
    } else {
        $obj->property++;
    }
    return $obj;
}

function &get_instance_noref() {
    static $obj;

    echo 'Statisches Objekt: ';
    var_dump($obj);
    if (!isset($obj)) {
        $new = new stdClass;
        // Der statischen Variablen ein Objekt zuweisen
        $obj = $new;
    }
    if (!isset($obj->property)) {
        $obj->property = 1;
    } else {
        $obj->property++;
    }
    return $obj;
}

$obj1 = get_instance_ref();
$still_obj1 = get_instance_ref();
echo "\n";
$obj2 = get_instance_noref();
$still_obj2 = get_instance_noref();
?>
]]>
    </programlisting>
   </informalexample>
   &example.outputs;
   <screen>
<![CDATA[
Statisches Objekt: NULL
Statisches Objekt: NULL

Statisches Objekt: NULL
Statisches Objekt: object(stdClass)#3 (1) {
  ["property"]=>
  int(1)
}
]]>
   </screen>

   <simpara>
    Dieses Beispiel demonstriert, dass die Referenz, die einer statischen
    Variablen zugewiesen wird, beim zweiten Aufruf der Funktion
    <literal>&amp;get_instance_ref()</literal> <emphasis>vergessen</emphasis>
    ist.
   </simpara>
   </sect2>
  </sect1>

  <sect1 xml:id="language.variables.variable">
   <title>Variable Variablen</title>

   <simpara>
    Manchmal ist es komfortabel, variable Variablennamen zu verwenden. Das
    bedeutet, einen Variablennamen zu setzen und dynamisch zu verwenden. Eine
    normale Variable wird wie folgt festgelegt:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$a = 'Hallo';
?>
]]>
    </programlisting>
   </informalexample>

   <simpara>
    Eine variable Variable nimmt den Wert einer Variablen und behandelt ihn
    als Name der Variablen. Im obigen Beispiel kann <emphasis>Hallo</emphasis>
    als Variablenname verwendet werden, indem man zwei Dollar-Zeichen
    verwendet, also schreibt:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
$$a = 'Welt';
?>
]]>
    </programlisting>
   </informalexample>

   <simpara>
    Nun existieren in der PHP-Symbol-Struktur zwei definierte und gespeicherte
    Variablen: <varname>$a</varname> mit dem Inhalt "Hallo" und
    <varname>$Hallo</varname> mit dem Inhalt "Welt". Deshalb wird die
    Anweisung
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
echo "$a {$$a}";
?>
]]>
    </programlisting>
   </informalexample>

   <simpara>
    zur genau gleichen Ausgabe führen wie:
   </simpara>

   <informalexample>
    <programlisting role="php">
<![CDATA[
<?php
echo "$a $Hallo";
?>
]]>
    </programlisting>
   </informalexample>

   <simpara>
    also zu: <computeroutput>Hallo Welt</computeroutput>.
   </simpara>

   <simpara>
    Um variable Variablen mit Arrays zu verwenden, muss ein Problem der
    Zweideutigkeit gelöst werden. Das heißt, wenn der Parser auf
    <varname>$$a[1]</varname> stößt, muss er erkennen können, ob
    <varname>$a[1]</varname> als Variable verwendet werden soll, oder ob
    <varname>$$a</varname> als Variable verwendet werden soll und dann der
    <literal>[1]</literal>-Index dieser Variable. Die Syntax zur Auflösung
    dieser Zweideutigkeit lautet: <varname>${$a[1]}</varname> für den ersten
    Fall und <varname>${$a}[1]</varname> für den zweiten Fall.
   </simpara>

   <simpara>
    Auf Klasseneigenschaften kann ebenso unter Verwendung von variablen
    Eigenschaftsnamen zugegriffen werden. Der variable Eigenschaftsname wird
    innerhalb des Geltungsbereichs aufgelöst, aus dem der Aufruf erfolgt. Wenn
    es &zb; einen Ausdruck wie <varname>$foo->$bar</varname> gibt, dann wird
    der lokale Geltungsbereich auf <varname>$bar</varname> untersucht, und
    dessen Wert wird als Eigenschaftsname von <varname>$foo</varname>
    verwendet. Dies gilt analog, wenn <varname>$bar</varname> ein Arrayzugriff
    ist.
   </simpara>

   <simpara>
    Geschweifte Klammern können ebenfalls verwendet werden, um den
    Eigenschaftsnamen deutlich abzugrenzen. Sie sind besonders nützlich beim
    Zugriff auf Werte in einer Eigenschaft, die ein Array enthält, wenn der
    Eigenschaftsname aus mehreren Teilen besteht oder wenn der
    Eigenschaftsname Zeichen enthält, die andernfalls nicht gültig sind, &zb;
    von <function>json_decode</function> oder
    <link linkend="book.simplexml">SimpleXML</link>.
   </simpara>

   <para>
    <example>
     <title>Beispiel zu variablen Eigenschaften</title>
      <programlisting role="php">
<![CDATA[
<?php
class Foo {
    public $bar = 'Ich bin bar.';
    public $arr = array('Ich bin A.', 'Ich bin B.', 'Ich bin C.');
    public $r   = 'Ich bin r.';
}

$foo = new Foo();
$bar = 'bar';
$baz = ['foo', 'bar', 'baz', 'quux'];
echo $foo->$bar . "\n";
echo $foo->{$baz[1]} . "\n";

$start = 'b';
$end   = 'ar';
echo $foo->{$start . $end} . "\n";

$arr = 'arr';
echo $foo->{$arr[1]} . "\n";
echo $foo->{$arr}[1] . "\n";

?>
]]>
     </programlisting>
     &example.outputs;
     <screen>
<![CDATA[
Ich bin bar.
Ich bin bar.
Ich bin bar.
Ich bin r.
Ich bin B.
]]>
     </screen>
    </example>
   </para>

   <warning>
    <simpara>
     Bitte beachten Sie, dass variable Variablen nicht mit <link
     linkend="language.variables.superglobals">Superglobalen Arrays</link> in
     Funktionen oder Klassenmethoden verwendet werden können. Die Variable
     <literal>$this</literal> ist ebenfalls eine spezielle Variable, die nicht
     dynamisch referenziert werden kann.
    </simpara>
   </warning>

  </sect1>

  <sect1 xml:id="language.variables.external">
   <title>Variablen aus externen Quellen</title>

   <sect2 xml:id="language.variables.external.form">
    <title>HTML-Formulare (GET and POST)</title>

    <simpara>
     Sobald ein Formular an ein PHP-Skript übergeben wird, werden die
     Informationen dieses Formulars dem Skript automatisch zur Verfügung
     gestellt. Es gibt ein paar Möglichkeiten, auf diese Informationen
     zuzugreifen, zum Beispiel:
    </simpara>

    <para>
     <example>
      <title>Ein einfaches HTML-Formular</title>
      <programlisting role="html">
<![CDATA[
<form action="foo.php" method="post">
    Name:  <input type="text" name="username" /><br />
    E-Mail: <input type="text" name="email" /><br />
    <input type="submit" name="submit" value="Und ab!" />
</form>
]]>
      </programlisting>
     </example>
    </para>

    <para>
     Es gibt nur zwei Möglichkeiten, um auf die Daten von HTML-Formularen
     zuzugreifen. Die zurzeit verfügbaren Methoden werden unten aufgeführt:
    </para>

    <para>
     <example>
      <title>Zugriff auf die Daten eines einfachen HTML-POST-Formulars</title>
      <programlisting role="php">
<![CDATA[
<?php
echo $_POST['username'];
echo $_REQUEST['username'];
?>
]]>
      </programlisting>
     </example>
    </para>

    <para>
     Die Verwendung eines GET-Formulars ist, davon abgesehen, dass stattdessen
     die entsprechende vordefinierte GET-Variable verwendet werden kann,
     ähnlich. Außerdem wird GET auch für den <literal>QUERY_STRING</literal>
     (die Information nach dem '?' in einer URL) verwendet. So enthält zum
     Beispiel <literal>http://www.example.com/test.php?id=3</literal>
     GET-Daten, auf die mit <varname>$_GET['id']</varname> zugegriffen werden
     kann. Siehe auch <varname>$_REQUEST</varname>.
    </para>

    <note>
     <para>
      Punkte und Leerzeichen in Variablennamen werden in Unterstriche
      umgewandelt. Zum Beispiel wird <literal>&lt;input name="a.b"
      /&gt;</literal> zu <literal>$_REQUEST["a_b"]</literal>.
     </para>
    </note>

    <simpara>
     Im Zusammenhang mit Formular-Variablen versteht PHP auch Arrays (siehe
     auch die <link linkend="faq.html">zugehörige FAQ</link>). So können &zb;
     zusammengehörige Variablen gruppiert werden, oder diese Funktionalität
     kann verwendet werden, um Werte aus einer Eingabe mit Mehrfachauswahl
     abzurufen. Schicken wir zum Beispiel ein Formular an sich selbst und
     lassen nach dem Versand die Daten anzeigen:
    </simpara>

    <para>
     <example>
      <title>Komplexere Formular-Variablen</title>
      <programlisting role="php">
<![CDATA[
<?php
if ($_POST) {
    echo '<pre>';
    echo htmlspecialchars(print_r($_POST, true));
    echo '</pre>';
}
?>
<form action="" method="post">
    Name:  <input type="text" name="personal[name]" /><br />
    E-Mail: <input type="text" name="personal[email]" /><br />
    Bier: <br />
    <select multiple name="bier[]">
        <option value="oettinger">Öttinger</option>
        <option value="bitburger">Bitburger</option>
        <option value="stuttgarter">Stuttgarter Schwabenbräu</option>
    </select><br />
    <input type="submit" value="Und ab!" />
</form>
]]>
      </programlisting>
     </example>
    </para>

    <note>
     <simpara>
      Beginnt der Name einer externen Variablen mit einer gültigen
      Array-Syntax, dann werden darauf folgende Zeichen stillschweigend
      ignoriert. Zum Beispiel wird
      <literal>&lt;input name="foo[bar]baz"&gt;</literal> zu
      <literal>$_REQUEST['foo']['bar']</literal>.
     </simpara>
    </note>

    <sect3 xml:id="language.variables.external.form.submit">
     <title>IMAGE-SUBMIT-Variablennamen</title>

     <simpara>
      Zur Übertragung eines Formulars kann auch ein Bild statt eines
      Übertragungs-Schalters (Submit-Button) verwendet werden, dessen Tag wie
      folgt aussieht:
     </simpara>

     <informalexample>
      <programlisting role="html">
<![CDATA[
<input type="image" src="image.gif" name="sub" />
]]>
      </programlisting>
     </informalexample>

     <simpara>
      Klickt der Benutzer irgendwo auf das Bild, wird das entsprechende
      Formular an den Webserver übertragen. Hierbei sind zwei zusätzliche
      Variablen vorhanden, <varname>sub_x</varname> und
      <varname>sub_y</varname>. Diese enthalten die Koordinaten des
      Klickpunktes innerhalb des Bildes. Die Erfahreneren werden bemerken,
      dass die Variablen, die vom Browser gesendet werden, einen Punkt statt
      eines Unterstrichs enthalten. Dieser Punkt wird von PHP automatisch in
      einen Unterstrich verwandelt.
     </simpara>
    </sect3>

   </sect2>

   <sect2 xml:id="language.variables.external.cookies">
    <title>HTTP-Cookies</title>
    <simpara>
     PHP unterstützt HTTP-Cookies auf völlig transparente Weise, wie in
     <link xlink:href="&url.rfc;6265">RFC 6265</link> definiert. Cookies sind
     ein Mechanismus zur Speicherung von Daten auf dem Client-Rechner, um
     damit wiederkehrende Benutzer nachzuverfolgen oder zu identifizieren. Mit
     der Funktion <function>setcookie</function> ist es möglich, Cookies zu
     erzeugen. Cookies sind Teil des HTTP-Headers, deshalb muss die Funktion
     <function>setcookie</function> aufgerufen werden, bevor irgendeine Ausgabe
     an den Browser gesendet wird. Dabei handelt es sich um die gleiche
     Einschränkung, die auch für die Funktion <function>header</function> gilt.
     Cookie-Daten stehen dann in den entsprechenden Cookie-Daten-Arrays, zum
     Beispiel <varname>$_COOKIE</varname>, sowie in
     <varname>$_REQUEST</varname> zur Verfügung. Weitere Details und Beispiele
     sind auf der Seite <function>setcookie</function> des Handbuchs zu finden.
    </simpara>

    <note>
     <simpara>
      Aus Sicherheitsgründen werden ab PHP 7.2.34, 7.3.23 bzw. 7.4.11 die
      <emphasis>Namen</emphasis> der eingehenden Cookies nicht mehr
      URL-dekodiert.
     </simpara>
    </note>

    <simpara>
     Wenn einer einzelnen Cookie-Variablen mehrere Werte zugewiesen werden
     sollen, müssen diese als Array zugewiesen werden. Zum Beispiel:
    </simpara>
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php
  setcookie("MeinCookie[foo]", 'Ich teste 1', time()+3600);
  setcookie("MeinCookie[bar]", 'Ich teste 2', time()+3600);
?>
]]>
     </programlisting>
    </informalexample>

    <simpara>
     Dadurch werden zwei einzelne Cookies erzeugt, obwohl
     <varname>MyCookie</varname> im Skript nun ein einziges Array ist. Wenn nur
     ein Cookie mit mehreren Werten gesetzt werden soll, empfiehlt es sich,
     zuerst <function>serialize</function> oder <function>explode</function>
     auf das Array anzuwenden.
    </simpara>

    <simpara>
     Es ist zu bedenken, dass ein Cookie ein vorhergehendes Cookie gleichen
     Namens im Browser überschreibt, es sei denn, der Pfad oder die Domain sind
     anders. Für eine Warenkorb-Anwendung kann somit &zb; ein Zähler mitgeführt
     und weitergegeben werden:
    </simpara>

    <example>
     <title>Ein <function>setcookie</function>-Beispiel</title>
     <programlisting role="php">
<![CDATA[
<?php
if (isset($_COOKIE['zaehler'])) {
    $count = $_COOKIE['zaehler'] + 1;
} else {
    $count = 1;
}
setcookie('zaehler', $count, time()+3600);
setcookie("Cart[$count]", $item, time()+3600);
?>
]]>
     </programlisting>
    </example>

   </sect2>

   <sect2 xml:id="language.variables.external.dot-in-names">
    <title>Punkte in eingehenden Variablennamen</title>
    <para>
     Normalerweise verändert PHP die Variablennamen nicht, wenn sie einem
     Skript übergeben werden. Es sollte aber beachtet werden, dass der Punkt
     (".") kein gültiger Bestandteil eines Variablennamens ist. Deshalb achten
     Sie auf folgendes:
     <programlisting role="php">
<![CDATA[
<?php
$varname.ext;  /* ungültiger Variablenname */
?>
]]>
     </programlisting>
     Der PHP-Parser sieht eine Variable namens <varname>$varname</varname>,
     gefolgt von einem Zeichenketten-Verbindungsoperator, dieser wiederum
     gefolgt von der offenen Zeichenkette 'ext' (also nicht eingegrenzt durch
     '"' und auch keinem Schlüsselwort oder reserviertem Bezeichner
     entsprechend). Das kann natürlich nicht zum gewünschten Ergebnis führen.
    </para>

    <para>
     Deshalb ist es wichtig zu wissen, dass PHP in den ihm übergebenen
     Variablen alle Punkte (.) automatisch durch einen Unterstrich (_)
     ersetzt.
    </para>

   </sect2>

   <sect2 xml:id="language.variables.determining-type-of">
    <title>Bestimmung des Variablen-Typs</title>

    <para>
     Da PHP den Typ der Variablen bestimmt und (im Allgemeinen) selbst eine
     entsprechende Umformung vornimmt, ist es nicht immer klar, welchen Typ
     eine Variable gerade hat. PHP beinhaltet einige Funktionen, die dies
     herausfinden, wie zum Beispiel: <function>gettype</function>,
     <function>is_array</function>, <function>is_float</function>,
     <function>is_int</function>, <function>is_object</function> und
     <function>is_string</function>. Lesen Sie bitte auch das Kapitel über
     <link linkend="language.types">Typen</link>.
    </para>
    <para>
     Da HTTP ein Text-Protokoll ist, werden die meisten, wenn nicht alle
     Inhalte von
     <link linkend="language.variables.superglobals">superglobalen Arrays</link>,
     wie <varname>$_POST</varname> und <varname>$_GET</varname>, als
     Zeichenketten erhalten bleiben. PHP wird nicht versuchen, die Werte in
     spezifische Typen umzuwandeln. Im Beispiel weiter unten enthält
     <varname>$_GET["var1"]</varname> die Zeichenkette "null" und
     <varname>$_GET["var2"]</varname> die Zeichenkette "123".
     <programlisting>
<![CDATA[
/index.php?var1=null&var2=123
]]>
     </programlisting>
    </para>
   </sect2>

   <sect2 xml:id="language.variables.external.changelog">
    &reftitle.changelog;

    <para>
     <informaltable>
      <tgroup cols="2">
       <thead>
        <row>
         <entry>&Version;</entry>
         <entry>&Description;</entry>
        </row>
       </thead>
       <tbody>
        <row>
         <entry>7.2.34, 7.3.23, 7.4.11</entry>
         <entry>
          Aus Sicherheitsgründen werden die <emphasis>Namen</emphasis> der
          eingehenden Cookies nicht mehr URL-dekodiert.
         </entry>
        </row>
       </tbody>
      </tgroup>
     </informaltable>
    </para>
   </sect2>

  </sect1>

 </chapter>

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