references.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: f4f96ef8b2a95283c92ea2183fe1dedf06f3ad22 Maintainer: nobody Status: ready -->
<!-- Reviewed: yes -->
<!-- Rev-Revision: fe18943c11c6fe9be88688574153013ff249452d Reviewer: samesch -->
 <chapter xml:id="language.references" xmlns="http://docbook.org/ns/docbook">
  <title>Referenzen</title>

  <sect1 xml:id="language.references.whatare">
   <title>Was Referenzen sind</title>
   <simpara>
    Referenzen sind in PHP ein Mechanismus, um verschiedene Namen für den
    gleichen Inhalt von Variablen zu ermöglichen. Sie sind nicht mit Zeigern
    in C zu vergleichen; zum Beispiel ist damit keine Zeigerarithmetik
    möglich, sie sind keine tatsächlichen Speicheradressen usw. Siehe
    <xref linkend="language.references.arent" /> für weitere Informationen.
    Stattdessen sind sie Aliasdefinitionen für die
    <link linkend="features.gc.refcounting-basics">Symboltabelle</link>. PHP
    unterscheidet zwischen Variablenname und Variableninhalt, wobei der
    gleiche Variableninhalt unterschiedliche Namen besitzen kann. Der
    bestmögliche Vergleich ist der mit Dateinamen und Dateien im Dateisystem
    von Unix – Variablennamen sind Verzeichniseinträge, während der
    Variableninhalt die eigentliche Datei darstellt. Referenzen können nun als
    Hardlinks im Dateisystem verstanden werden.
   </simpara>
  </sect1>

  <sect1 xml:id="language.references.whatdo">
   <title>Was Referenzen leisten</title>
   <para>
    Es können grundsätzlich drei Operationen mit Referenzen durchgeführt werden:
    <link linkend="language.references.whatdo.assign">Referenzzuweisung</link>,
    <link linkend="language.references.whatdo.pass">Referenzübergabe</link> und
    <link linkend="language.references.whatdo.return">Referenzrückgabe</link>.
    Dieser Abschnitt enthält eine Einführung zu diesen Operationen mit Links zu
    weiteren Informationen.
   </para>
   <sect2 xml:id="language.references.whatdo.assign">
    <title>Referenzzuweisung</title>
    <para>
     PHP Referenzen erlauben es, zwei Variablennamen, sich auf den gleichen
     Variableninhalt beziehen zu lassen. Zum Beispiel:
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php

$a =& $b;

?>
]]>
      </programlisting>
     </informalexample>
     Das bedeutet, dass <varname>$a</varname> und <varname>$b</varname>
     auf denselben Inhalt zeigen.
     <note>
      <para>
       <varname>$a</varname> und <varname>$b</varname> sind hier gleichwertig,
       und <varname>$a</varname> ist kein Zeiger auf <varname>$b</varname>
       oder umgekehrt, sondern <varname>$a</varname> und <varname>$b</varname>
       zeigen auf dieselben Stelle.
      </para>
     </note>
    </para>
    <note>
     <para>
      Wenn man eine undefinierte Variable per Referenz zuweist, übergibt oder
      zurückgibt, wird sie erstellt.
      <example>
       <title>Referenzen mit undefinierten Variablen benutzen</title>
       <programlisting role="php">
<![CDATA[
<?php

function foo(&$var) {}

foo($a); // $a wird "erstellt" und dem Wert null zugewiesen

$b = array();
foo($b['b']);
var_dump(array_key_exists('b', $b)); // bool(true)

$c = new stdClass();
foo($c->d);
var_dump(property_exists($c, 'd')); // bool(true)

?>
]]>
       </programlisting>
      </example>
     </para>
    </note>
    <para>
     Diese Syntax kann auch mit Funktionen, die Referenzen zurückgeben, benutzt
     werden:
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php

$foo =& find_var($bar);

?>
]]>
      </programlisting>
     </informalexample>
    </para>
    <para>
     Die Verwendung der gleichen Syntax bei einer Funktion, die
     <emphasis>nicht</emphasis> per Referenz zurückgibt, führt zu einem
     Fehler, ebenso wie die Verwendung mit dem Ergebnis des
     <link linkend="language.oop5.basic.new">new</link>-Operators. Obwohl
     Objekte als Zeiger übergeben werden, sind diese nicht dasselbe wie
     Referenzen, wie im Abschnitt über
     <link linkend="language.oop5.references">Objekte und Referenzen</link>
     erläutert wird.
    </para>
    <warning>
     <para>
      Wird eine Referenz auf eine Variable zugewiesen, die in einer Funktion
      als <literal>global</literal> deklariert wurde, dann ist die Referenz
      nur innerhalb der Funktion sichtbar. Das kann vermieden werden, indem
      das <varname>$GLOBALS</varname>-Array verwendet wird.
      <example>
       <title>Referenzieren globaler Variablen innerhalb von Funktionen</title>
       <programlisting role="php">
<![CDATA[
<?php

$var1 = "Beispiel-Variable";
$var2 = "";

function global_references($use_globals)
{
    global $var1, $var2;

    if (!$use_globals) {
        $var2 =& $var1; // nur innerhalb der Funktion sichtbar
    } else {
        $GLOBALS["var2"] =& $var1; // ebenso im globalen Kontext sichtbar
    }
}

global_references(false);
echo "Der Wert von var2 ist '$var2'\n"; // Der Wert von var2 ist ''

global_references(true);
echo "Der Wert von var2 ist '$var2'\n"; // Der Wert von var2 ist 'Beispiel-Variable'

?>
]]>
       </programlisting>
      </example>
      <literal>global $var;</literal> kann als Abkürzung für
      <literal>$var =&amp; $GLOBALS['var'];</literal> angesehen werden. Daher
      ändert die Zuweisung einer anderen Referenz zu <literal>$var</literal>
      nur die Referenz der lokalen Variable.
     </para>
    </warning>
    <note>
     <para>
      Wenn man einer Variable einen Wert per Referenz in einer
      &foreach;-Anweisung zuweist, werden auch die Referenzen geändert.
      <example>
       <title>Referenzen und die foreach-Anweisung</title>
       <programlisting role="php">
<![CDATA[
<?php

$ref = 0;
$row =& $ref;

foreach (array(1, 2, 3) as $row) {
    // Mach was
}

echo $ref; // 3 - letztes Element des durchlaufenen Arrays

?>
]]>
       </programlisting>
      </example>
     </para>
    </note>
    <para>
     Obgleich keine Referenzzuweisung im engeren Sinne, können Ausdrücke, die
     mit dem Sprachkonstrukt
     <link linkend="function.array"><literal>array()</literal></link> erstellt
     werden, sich ebenso verhalten, wenn dem hinzuzufügenden Array-Element
     <literal>&amp;</literal> vorangestellt wird. Beispiel:
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php

$a = 1;
$b = array(2, 3);

$arr = array(&$a, &$b[0], &$b[1]);
$arr[0]++;
$arr[1]++;
$arr[2]++;
/* $a == 2, $b == array(3, 4); */

?>
]]>
      </programlisting>
     </informalexample>
    </para>
    <para>
     Es ist allerdings zu beachten, dass Referenzen in Arrays potentiell
     gefährlich sind. Eine normale Zuweisung (also nicht per Referenz) mit
     einer Referenz auf der rechten Seite wandelt die linke Seite nicht in
     eine Referenz um, aber Referenzen innerhalb von Arrays bleiben bei
     solchen normalen Zuweisungen erhalten. Dies gilt ebenso für
     Funktionsaufrufe, bei denen das Array als Wertübergabe entgegengenommen
     wird. Beispiel:
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php

/* Zuweisung skalarer Variablen */
$a = 1;
$b =& $a;
$c = $b;
$c = 7; // $c ist keine Referenz; keine Änderung an $a oder $b

/* Zuweisung von Array-Variablen */
$arr = array(1);
$a =& $arr[0]; // $a und $arr[0] sind in derselben Referenzmenge
$arr2 = $arr; // Keine Referenzzuweisung!
$arr2[0]++;
/* $a == 2, $arr == array(2) */
/* Der Inhalt von $arr hat sich geändert, obwohl es keine Referenz ist! */

?>
]]>
      </programlisting>
     </informalexample>
     Anders ausgedrückt ist das Referenzverhalten von Arrays auf einer
     Element-für-Element-Basis definiert; das Referenzverhalten einzelner
     Elemente ist getrennt vom Referenzzustand des Array-Behälters.
    </para>
   </sect2>
   <sect2 xml:id="language.references.whatdo.pass">
    <title>Referenzübergabe</title>
    <para>
     Eine weitere Einsatzmöglichkeit von Referenzen ist die Übergabe von
     Variablen an eine Funktion per Referenz. Hierbei beziehen sich sowohl der
     lokale Variablenname als auch der Variablenname der aufrufenden Instanz
     auf denselben Variableninhalt:
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var++;
}

$a=5;
foo($a);

?>
]]>
      </programlisting>
     </informalexample>
     Nach der Ausführung hat <varname>$a</varname> den Wert 6, da sich in der
     Funktion <varname>foo</varname> der Variablenname <varname>$var</varname>
     auf denselben Variableninhalt bezieht wie <varname>$a</varname>. Weitere
     Information hierzu sind dem Abschnitt
     <link linkend="language.references.pass">Referenzübergabe</link> zu
     entnehmen.
    </para>
   </sect2>
   <sect2 xml:id="language.references.whatdo.return">
    <title>Referenzrückgabe</title>
    <para>
     Als Drittes bieten Referenzen die Möglichkeit, Werte aus Funktionen heraus
     <link linkend="language.references.return">per Referenz zurückzugeben</link>.
    </para>
   </sect2>
  </sect1>

  <sect1 xml:id="language.references.arent">
   <title>Was Referenzen nicht sind</title>
   <para>
    Wie bereits gesagt: Referenzen sind keine Zeiger. Das bedeutet, der
    folgende Code tut nicht, was man erwarten könnte:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var =& $GLOBALS["baz"];
}

foo($bar);

?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <simpara>
    Folgendes passiert: <varname>$var</varname> in <varname>foo</varname> wird
    zunächst an <varname>$bar</varname> aus der aufrufenden Instanz gebunden,
    wird dann aber neu gebunden an <varname>$GLOBALS["baz"]</varname>. Es gibt
    keine Möglichkeit, <varname>$bar</varname> unter Verwendung des
    Referenzmechanismus im aufrufenden Geltungsbereich an etwas anderes zu
    binden, da <varname>$bar</varname> in der Funktion <varname>foo</varname>
    nicht zur Verfügung steht (es wird durch <varname>$var</varname>
    repräsentiert, aber <varname>$var</varname> hat in der aufrufenden
    <link linkend="features.gc.refcounting-basics">Symboltabelle</link>) nur
    Variableninhalte und keine Name-an-Wert-Bindung). Man kann die.
    <link linkend="language.references.return">Rückgabe von Referenzen</link>
    verwenden, um die von der Funktion ausgewählten Variablen zu
    referenzieren.
   </simpara>
  </sect1>

  <sect1 xml:id="language.references.pass">
   <title>Parameterübergabe per Referenz</title>
   <para>
    Man kann Variablen an Funktionen per Referenz übergeben, so dass die
    Funktion die Variable modifizieren kann. Dazu benutzt man folgende
    Syntax:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var++;
}

$a=5;

foo($a);
// $a ist 6

?>
]]>
     </programlisting>
    </informalexample>
    <note>
     <simpara>
      Zu beachten ist, dass beim Funktionsaufruf kein Referenz-Zeichen steht,
      sondern nur in der Funktionsdefinition. Diese allein ist ausreichend, um
      das Argument per Referenz zu übergeben.
     </simpara>
    </note>
   </para>
   <para>
    Folgende Dinge können per Referenz übergeben werden:
    <itemizedlist>
     <listitem>
      <simpara>
       Variablen, zum Beispiel <literal>foo($a)</literal>
      </simpara>
     </listitem>
     <listitem>
      <para>
       Referenzen, zurückgegeben von einer Funktion, zum Beispiel:
       <informalexample>
        <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var++;
}

function &bar()
{
    $a = 5;
    return $a;
}

foo(bar());

?>
]]>
        </programlisting>
       </informalexample>
       Es gibt detailliertere Erläuterungen zur
       <link linkend="language.references.return">Rückgabe per Referenz</link>.
      </para>
     </listitem>
    </itemizedlist>
   </para>
   <para>
    Alle anderen Ausdrücke sollten nicht per Referenz übergeben werden, da das
    Ergebnis undefiniert ist. Folgende Beispiele sind etwa ungültig:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

function foo(&$var)
{
    $var++;
}

function bar() // Beachte das fehlende &
{
    $a = 5;
    return $a;
}

foo(bar()); // Erzeugt einen Hinweis

foo($a = 5); // Ausdruck, nicht Variable
foo(5); // Erzeugt einen fatalen Fehler

class Foobar {}

foo(new Foobar()) // Erzeugt einen Hinweis von PHP 7.0.7 an
                  // Hinweis: Nur Variablen sollten als Referenz übergeben werden

?>
]]>
     </programlisting>
    </informalexample>
   </para>
  </sect1>

  <sect1 xml:id="language.references.return">
   <title>Referenzen zurückgeben</title>
   <para>
    Das Zurückgeben von Ergebnissen per Referenz aus Funktionen heraus kann
    manchmal recht nützlich sein, um herauszufinden, an welche Variable eine
    Referenz gebunden werden soll. Man sollte diese Funktionalität
    <emphasis>nicht</emphasis> aus Performancegründen benutzen, der Kern ist
    intelligent genug, um dies selbst zu optimieren. Man sollte Referenzen nur
    dann zurückgeben, wenn man sinnvolle technische Gründe hat. Hierbei ist
    folgende Syntax zu verwenden:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

class Foo
{
    public $value = 42;

    public function &getValue()
    {
        return $this->value;
    }
}

$obj = new Foo();
$myValue = &$obj->getValue(); // $myValue ist eine Referenz auf $obj->value, was den Wert 42 hat
$obj->value = 2;
echo $myValue;                // Zeigt den neuen Wert von $obj->value, also 2.

?>
]]>
     </programlisting>
    </informalexample>
     In diesem Beispiel weisen wir der Eigenschaft des von der Funktion
     <varname>getValue</varname> zurückgegebenen Objekts einen Wert zu, und
     nicht seiner Kopie, wie es der Fall wäre, wenn wir nicht die
     Referenzsyntax verwendet hätten.
   </para>
   <note>
    <simpara>
     Im Gegensatz zur Parameterübergabe ist hier an beiden Stellen die Angabe
     des <literal>&amp;</literal> notwendig. Dies zeigt an, dass Sie eine
     Referenz und keine Kopie zurückgeben. Ebenfalls wird angezeigt, dass für
     <varname>$myValue</varname> im Gegensatz zur normalen Zuweisung eine
     Referenzbindung durchgeführt werden soll.
    </simpara>
   </note>
   <note>
    <simpara>
     Wenn man versucht, eine Referenz aus einer Funktion mit der Syntax
     <literal>return ($this->value);</literal> zurückzugeben, wird das
     <emphasis>nicht</emphasis> funktionieren, weil man versucht, das Ergebnis
     eines <emphasis>Ausdrucks</emphasis> zurückzugeben und nicht eine
     Variable per Referenz. Man kann nur Variablen per Referenz aus einer
     Funktion zurückgeben - sonst nichts.
    </simpara>
   </note>
   <para>
    Um die zurückgegebene Referenz zu verwenden, muss Referenzzuweisung
    benutzt werden:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

function &collector()
{
    static $collection = array();
    return $collection;
}

$collection = &collector();
$collection[] = 'foo';

?>
]]>
     </programlisting>
    </informalexample>
    Um die zurückgegebene Referenz an eine andere Funktion zu übergeben, die
    eine Referenz erwartet, kann diese Syntax verwendet werden:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

function &collector()
{
    static $collection = array();
    return $collection;
}

array_push(collector(), 'foo');

?>
]]>
     </programlisting>
    </informalexample>
   </para>
   <note>
    <simpara>
     Es ist zu beachten, dass
     <literal>array_push(&amp;collector(), 'foo');</literal>
     <emphasis>nicht</emphasis> funktioniert; es erzeugt einen fatalen Fehler.
    </simpara>
   </note>
  </sect1>

  <sect1 xml:id="language.references.unset">
   <title>Referenzen aufheben</title>
   <para>
    Wird eine Referenz aufgehoben, so wird nur die Bindung zwischen einem
    Variablennamen und dem Variableninhalt entfernt. Der Inhalt der Variablen
    wird hierbei nicht gelöscht. Betrachten wir folgendes Beispiel:
    <informalexample>
     <programlisting role="php">
<![CDATA[
<?php

$a = 1;
$b =& $a;
unset($a);

?>
]]>
     </programlisting>
    </informalexample>
    Dies wird <varname>$b</varname> nicht aufheben, sondern nur
    <varname>$a</varname>.
   </para>
   <simpara>
    Wiederum sieht man die Analogie zwischen Unix und den Referenzen: Das
    Aufheben einer Referenz entspricht einem Aufruf von
    <command>unlink</command> unter Unix.
   </simpara>
  </sect1>

  <sect1 xml:id="language.references.spot">
   <title>Referenzen entdecken</title>
   <simpara>
    Viele Sprachelemente von PHP sind intern mit der Benutzung von Referenzen
    implementiert, daher gilt alles bisher gesagte auch für diese Konstrukte.
    Manche Konstrukte, wie das Übergeben und Rückgeben per Referenz, wurden
    oben erwähnt. Andere Konstrukte, die Referenzen verwenden, sind:
   </simpara>

   <sect2 xml:id="references.global">
    <title>Globale Referenzen</title>
    <para>
     Wird eine Variable als <command>global $var</command> deklariert, wird
     eine Referenz auf die globale Variable <varname>$var</varname> erzeugt.
     Das ist also dasselbe wie:
     <informalexample>
      <programlisting role="php">
<![CDATA[
<?php

$var =& $GLOBALS["var"];

?>
]]>
      </programlisting>
     </informalexample>
    </para>
    <simpara>
     Dies hat zur Folge, dass das Anwenden von unset() auf
     <varname>$var</varname> keinen Einfluss auf die globale Variable hat.
    </simpara>
   </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
-->