mirror of
https://github.com/php/doc-de.git
synced 2026-03-24 07:12:15 +01:00
1226 lines
36 KiB
XML
1226 lines
36 KiB
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
|
|
(&) 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>&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><input name="a.b"
|
|
/></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><input name="foo[bar]baz"></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
|
|
-->
|