Variablen in PHP-Funktionen
Beim Funktionsaufruf kann man als Parameter nicht nur feste Werte übergeben, sondern auch Variablen. Hierbei gilt, dass die Variablen außerhalb der Funktion ihren Wert beibehalten, selbst wenn die Parameter in der Funktion bearbeitet werden. Der Grund hierfür ist, dass Variablen in der Funktion zunächst nichts mit den Variablen außerhalb der Funktion gemein haben.
Beim folgenden Beispiel wird beim Funktionsaufruf die Variable $wert übergeben, in der Funktion um 1 hochgezählt und als Rückgabewert festgelegt. Danach werden zwei Texte mit der Variable $wert ausgegeben. Über den Funktionsaufruf wird die Variable in der Funktion ausgegeben und ohne den Funktionsaufruf die Variable außerhalb. Man erhält dabei zwei unterschiedliche Zahlen. Die Variable $wert in der Funktion ist trotz identischer Namen etwas anderes als die Variable außerhalb.
<?php
// Globale Variable $wert
$wert = 10;
function variable ($wert)
{
// Lokale Variable $wert
$wert++;
return $wert;
}
// Ausgabe 11, lokale Variable
echo 'Wert in der Funktion: ' . variable ($wert) . '<br>';
// Ausgabe 10, globale Variable
echo 'Wert außerhalb der Funktion: ' . $wert;
?>Die Variablen in Funktionen werden auch lokale Variablen genannt, da sie in der Hierarchie unterhalb der globalen Ebene liegen. Die Variablen außerhalb der Funktionen nennt man globale Variablen, da sie in der globalen Ebene liegen.
Verweis auf eine Variable als Parameter
Es kann vorkommen, dass man beim Funktionsaufruf als Parameter eine Variable übergeben möchte und die Bearbeitung in der Funktion auch eine Auswirkung auf die Variable außerhalb (in der globalen Ebene) haben soll. In solchen Fällen ist es möglich, den Parameter bei der Funktionsdeklaration als Verweis anzugeben. Man nennt das auch Referenzieren.
Hierfür verwendet man das kaufmännische Und-Zeichen &, das man bei der Deklaration der Funktion vor dem Parameter setzt. Gibt man beim Funktionsaufruf als Parameter eine Variable an, arbeitet man in der Funktion mit einem Verweis darauf. Dann wird in der Funktion nicht mit einer eigenständigen (lokalen) Variable gearbeitet. Beim folgenden Beispiel werden erhält man als Ausgabe von $wert in beiden Fällen die Zahl 11.
<?php
$wert = 10;
function variable (&$wert)
{
$wert++;
return $wert;
}
// Ausgabe 11, Verweis auf globale Variable
echo 'Wert in der Funktion: ' . variable ($wert) . '<br>';
// Ausgabe 11, globale Variable
echo 'Wert außerhalb der Funktion: ' . $wert;
?>Verweis auf globale Variable mit global
Es ist innerhalb einer Funktion möglich, auf eine globale Variable zu verweisen, obwohl diese bei den Parametern als Verweis nicht angegeben wurde. Hierfür verwendet man in der Funktion das Schlüsselwort global, mit dem man ebenfalls einen Verweis auf eine globale Variable setzen kann. Beim folgenden Beispiel hat man denselben Effekt wie beim Verweis über Parameter, nur mit dem Unterschied, dass keine Parameter definiert wurden und der Verweis innerhalb der Funktion gesetzt wird.
<?php
$wert = 10;
function variable()
{
// Variable als global kennzeichnen
global $wert;
$wert++;
return $wert;
}
// Ausgabe 11, Verweis auf globale Variable
echo 'Wert in der Funktion: ' . variable() . '<br>';
// Ausgabe 11, globale Variable
echo 'Wert außerhalb der Funktion: ' . $wert;
?>Zugriff auf globale Variable über Superglobals
Es gibt sogenannte Superglobals, die auch häufig superglobale Variablen genannt werden. Da das im Grunde Arrays sind, nennt man sie auch superglobale Arrays. Zwei bekannte superglobale Arrays sind $_GET und $_POST, über die man abgeschickte Formulardaten auslesen kann. Die Besonderheit hierbei ist, dass man von überall im Programm auf sie zugreifen kann, auch in Funktionen. Es gibt das superglobale Array $GLOBALS['...'], in dem globale Variablen gespeichert werden. Als Key für das Array verwendet man den Variablennamen, z.B. $GLOBALS['wert']. Beim folgenden Beispiel wird in der Funktion der Wert der globalen Variable $wert um 1 hochgezählt und gleichzeitig der lokalen Variable $wert zugewiesen. Der Rückgabewert der Funktion und der globalen Variable $wert ist 11. Man hat in der Funktion dafür gesorgt, dass die globale Variable um 1 hochgezählt wird.
<?php
$wert = 10;
function variable()
{
// Superglobal hochzählen und Variable zuweisen
$wert = ++$GLOBALS['wert'];
return $wert;
}
// Ausgabe 11, lokale Variable
echo 'Wert in der Funktion: ' . variable() . '<br>';
// Ausgabe 11, globale Variable
echo 'Wert außerhalb der Funktion: ' . $wert;
?>Hierbei entsteht jedoch kein Verweis auf die globale Variable, wie das beim Verwenden des Schlüsselworts global der Fall ist. Die Variable $wert in der Funktion ist eine andere als die globale Variable $wert, auch wenn sie identisch heißen. Deutlich wird das beim nächsten Beispielcode. Hierbei wird in der Funktion zuerst das superglobale Array $GLOBALS['wert'] der Variable $wert zugewiesen und erst danach um 1 hochgezählt. Die Ausgabe der lokalen Variable ist 11, die der globalen Variable dagegen 10.
<?php
$wert = 10;
function variable()
{
// Superglobal Variable zuweisen, danach hochzählen
$wert = $GLOBALS['wert'];
$wert++;
return $wert;
}
// Ausgabe 11, lokale Variable
echo 'Wert in der Funktion: ' . variable() . '<br>';
// Ausgabe 10, globale Variable
echo 'Wert außerhalb der Funktion: ' . $wert;
?>Wert der Variable mit static speichern
Wenn eine lokale Variable in der Funktion verändert wird, geht die Änderung nach Beendigung der Funktion normalerweise verloren. Ruft man die Funktion mehrmals auf, beginnen die Variablen mit ihrem Initialwert. Beim folgenden Beispielcode wird die Funktion 3x hintereinander aufgerufen. Der ausgegebene Wert ist jedoch immer 1, da bei jedem Funktionsaufruf der Wert der Variable auf 0 gesetzt, um 1 hochgezählt und dann ausgegeben wird.
<?php
function variable()
{
$wert = 0;
$wert++;
return $wert;
}
// Ausgabe immer 1
echo variable();
echo variable();
echo variable();
?>Es kann vorkommen, dass man den geänderten Wert für einen erneuten Aufruf der Funktion behalten möchte. Hierfür kann man die Variable mit dem Schlüsselwort static als statisch kennzeichnen. Dadurch wird der zuletzt gültige Wert für einen erneuten Aufruf gespeichert. Beim folgenden Beispiel ist die Ausgabe 123, da der um 1 hochgezählte Wert behalten wird.
<?php
function variable()
{
// Variable als statisch kennzeichnen
static $wert = 0;
$wert++;
return $wert;
}
// Ausgabe 123
echo variable();
echo variable();
echo variable();
?>Solche statischen Variablen kann man auch sehr gut für rekursive Funktionen nutzen. Das sind Funktionen, die wie bei einer Schleife sich selbst aufrufen, solange eine Bedingung erfüllt ist. Beim folgenden Beispiel beginnt die Variable mit dem Wert 0, gibt den aus und zählt danach um 1 hoch. Die folgende if-Abfrage bewirkt an der Stelle, dass solange der Wert kleiner oder gleich 10 ist, die Funktion quasi sich selbst wieder aufruft. Das sorgt dafür, dass der jeweils um 1 hochgezählte Wert solange ausgegeben wird, bis der Wert der Variable 10 ist. Zum Schluss wird die Variable $wert für den erneuten Aufruf wieder auf 0 gesetzt. Der mehrmalige Aufruf der Funktion sorgt dafür, dass jeweils die Zahlen von 0 bis 10 ausgegeben werden.
<?php
function variable()
{
static $wert = 0;
echo $wert;
$wert++;
if ($wert <= 10) {
variable();
}
// Anfangswert für den erneuten Aufruf
$wert = 0;
}
// Ausgabe jeweils von 0 - 10
variable();
variable();
variable();
?>Konstanten in Funktionen
Konstanten, die im globalen Bereich definiert wurden, sind auch in Funktionen verfügbar.
<?php
define ('K', 'Inhalt');
function konstante()
{
return K;
}
echo konstante();
?>Konstanten, die in Funktionen definiert wurden, sind im globalen Bereich verfügbar, wenn die Funktion zuvor aufgerufen wurde.
<?php
function konstante()
{
define ('K', 'Inhalt');
}
konstante();
echo K;
?>Der Bereich, innerhalb der Variablen gültig sind, wird auch Geltungsbereich von Variablen (scope) genannt.