Variablen

Eine der wichtigsten Merkmale einer Programmiersprache ist das Verwalten von Daten in Variablen. Der Variablen kann beim Deklarieren ein Wert zugewiesen werden, das wird als Initialisieren einer Variablen bezeichnet. Der Datentyp des Werts einer Variablen erkennt PHP am Inhalt.

Variablen Deklaration

Variablen bestehen aus drei Teilen:

  • dem Variablennamen
  • einem Speicherbereich
  • einem Wert
$vorname = "Adi";

Jede Variable besitzt einen Namen oder auch Bezeichner. Bei der Benennung von Variablen sind einige Regeln zu beachten:

  • Bezeichner müssen immer mit einem Dollarzeichen ($) beginnen.
  • Nach dem Dollarzeichen muss ein Buchstabe oder ein Unterstrich folgen (keine Ziffer)
  • Die darauf folgenden Zeichen können beliebige Buchstaben, Ziffern oder Unterstriche sein.
  • Zwischen Groß- und Kleinschreibung wird unterschieden.
  • Es dürfen keine von PHP reservierten Wörter als Bezeichner verwendet werden.
  • Bezeichner müssen in einer Zeile Platz finden.
  • Bezeichner dürfen keine Leerzeichen enthalten.

Variablen Beispiele

$einheit = "Meter";
$zahl1 = 1000;
$zahl2 = 10 * 12;
$_bilder = "foto.jpg";
$spielerName =   "Thomas";
$max_wert = 100;

Variablen Prüfen

Die Funktion isset(Variablenname) prüft eine Variable auf deren Existenz. Das Beispiel ist eine einfache Fehlerbehandlung:

<?php
$preis = 9.99;
if (isset($preis)) {
echo $preis;
} else {
echo "Umsonst!";
}
// Ausgabe 9.99
?>

Variablenfunktionen

PHP unterstützt das Konzept der Variablenfunktionen. Wenn Sie an das Ende einer Variablen Klammern hängen, versucht PHP eine Funktion aufzurufen, deren Name der aktuelle Wert der Variablen ist.

<?php
function foo()
{
echo "Hallo Welt!";
}

function bar($arg)
{
echo $arg;
}

$func = 'foo';
$func();        // Dies ruft foo() auf
$func = 'bar';
$func('Hallo Adi!');  // Dies ruft bar() auf
?>

Variablenfunktionen funktionieren nicht mit Sprachkonstrukten wie echo(), print(), unset(), isset(), empty(), include() und require(). Für solche Sprachkonstrukte werden Wrapperfunktionen verwenden, um diese Konstrukte als variable Funktionen benutzen zu können. Ein Wrapper ist eine Funktion oder eine Methode, welche eine andere Methode oder Funktion kapselt.

<?php
// Das ist eine Wrapperfunkiton für echo
function MyFunc($string) {
echo $string;
}

$myVar = 'MyFunc';
$myVar('Hallo Welt!');  // Dies ruft MyFunc() auf
?>

Variablen Scope (Sichtbarkeit)

PHP Variablen sind normalerweise nur in ihrem lokalen Kontext sichtbar sind. Dieser beinhaltet auch den Bereich für Dateien, die per include- oder require-Anweisung eingebunden wurden. PHP stellt drei Variablen Scopes zur Verfügung:

  • local
  • global
  • static

Eine innerhalb einer Funktion definierte Variable ist außerhalb der Funktion nicht sichtbar. Umgekehrt gilt dasselbe, eine außerhalb von Funktionen definierte Variable hat innerhalb eines Funktionsblocks keine Gültigkeit. Um zu erreichen, dass eine Variable auch lokal innerhalb einer Funktion bekannt ist, muss diese explizit mithilfe des Schlüsselworts global innerhalb der Funktion bekannt gemacht werden.

Globale Variablen

<?php
$x = 5;
$y = 10;

function myFunc() {
global $x, $y;
$y = $x + $y;
}

myFunc();
echo $y; // Ausgabe 15
?>

Die Variablen $x und $y sind nun sowohl von außerhalb der Funktion und mit der Funktion myFunc() änderbar.

Static Variablen

Nachdem eine Funktion ausgeführt wurde, werden alle lokalen Variablen der Funktion wieder gelöscht. Manchmal möchte man eine lokale Variable nicht gelöscht haben, sonder ihr Wert soll für spätere Verwendung gespeichert werden. Um zu erreichen, dass ein Variablenwert innerhalb einer Funktion gespeichert wird, muss diese explizit mithilfe des Schlüsselworts static bekannt gemacht werden.

<?php
function myFunc() {
static $x = 0;
echo $x . "<br>";
$x++;
}

myFunc();
myFunc();
myFunc();
?>

Der Wert der Variablen $x wird bei jedem Funktionsaufruf mit Eins (1) inkrementiert.

Zugriff über $GLOBALS

Eine andere Möglichkeit, innerhalb einer Funktion auf eine Variable zuzugreifen, steht über das von PHP definierte Array $GLOBALS zur Verfügung. $GLOBALS ist ein assoziatives Array, das die Namen der globalen Variablen als Schlüsselwörter verwendet. Den Zugriff innerhalb des lokalen Kontextes einer Funktion über das Array $GLOBALS auf die lokale Variable $netto zeigt folgendes Beispiel:

<?php
$netto = 9.99;
function mwst() {
return $GLOBALS['netto'] * 0.2;
}
echo mwst();
?>

Dynamische Variablen

Interessant ist die Möglichkeit in PHP, auch Variablennamen selbst in Variablen zu speichern und so quasi auf Variablen zuzugreifen. Die Zuweisung erfolgt in zwei Schritten. Zuerst wird eine normale Variable erzeugt, der Sie den Namen der dynamischen Variablen zuordnen:

$varName = "myVar";

Eine dynamische Variable nimmt den Wert einer Variablen als Namen. Der implizierten Variablen können Sie einen Wert zuweisen, indem zwei $$-Zeichen vorangestellt werden:

<?php
$varName = "myVar";
$$varName = "PHP";
echo $myVar; // liefert PHP
?>

Der echo-Befehl gibt nun den Wert "PHP" aus.

Konstanten

Eine Konstante ist ein Bezeichner (Name) für eine simple Variable. Der Wert einer Konstanten kann sich zur Laufzeit eines Skripts nicht ändern. Eine Konstante unterscheidet zwischen Groß- und Kleinschreibung (case-sensitive). Nach gängiger Konvention werden Konstanten immer in Großbuchstaben geschrieben.

Unterschiede zwischen Konstanten und Variablen

  • Konstanten haben kein Dollarzeichen ($) vorangestellt.
  • Konstanten können nur über die Funktion define() definiert werden, nicht durch einfache Zuweisung.
  • Konstanten können überall definiert werden und auf ihren Wert können Sie ohne Rücksicht auf Scope von Variablen zugreifen.
  • Sobald Konstanten definiert sind, können sie nicht neu definiert oder gelöscht werden.
  • Konstanten können nur skalare Datenwerte besitzen.
<?php
define("SPRUCH", "Hallo Welt!");
echo SPRUCH; // liefert Hallo Welt!
?>

Funktionen zur Behandlung von Variablen

PHP kennt einige Funktionen, die speziell für Variablen verwendet werden z.B. die Typ-Überprüfung oder das Auslesen von Informationen einer Variablen.

Beispiele

  • is_string() / prüft eine Variable auf den Datentyp String
  • isset() / prüft eine Variable auf deren Existenz und ob sie nicht NULL ist
  • gettype() / liefert den Datentyp einer Variablen
  • unset() / löscht eine Variable

is_string()

Mit den Funktionen is_string, is_float, is_null usw. wird eine Variable geprüft, ob sie auch den richtigen Datentyp entspricht.

<?php
$x = "Hallo Welt!";
if (is_string($x)) {
echo "Der Datentyp ist STRING";
} else {
echo "Der Datentyp ist nicht STRING";
}
?>

isset()

isset() prüft eine Variable auf deren Existenz und ob sie nicht NULL ist.

<?php
$x = "";
if ($x) {
echo "Der Wert ist WAHR";
} else {
echo "Der Wert ist FALSCH";
}

echo "<br>";

$x = "";
if (isset($x)) {
echo "Der Wert ist WAHR";
} else {
echo "Der Wert ist FALSCH";
}
?>

Die erste Überprüfung der Variable $x liefert FALSCH (false) denn ein leerer String hat einfach ein boolean false als Rückgabewert. Die zweite Überprüfung der Variable $x mit der Funktion isset() liefert WAHR, denn die Variable existiert, unabhänging vom Wert.

gettype()

Die Funktion gettype() liefer den Datentyp der Variablen.

<?php
$x = 3.14;
echo gettype($x); // liefert double
?>

unset()

Die Funktion unset() entfernt eine Variablen aus dem Scope. Im folgenden Beispiel liefert die echo-Anweisung eine Fehlermeldung, weil die Variable $x nicht mehr existiert.

<?php
$x = 3.14;
unset($x);
echo $x;
?>

Im folgenden Beispiel wird nur die lokale Variable der Fumktion entfernt, aber nicht die globale Variable $x. Bei jedem Aufruf der Funktion wird die Variable $x wieder initialisiert.

<?php
$x = 3.14;
function myFunc() {
global $x;
$x = 2.0;
unset($x);
}

myFunc();
echo $x;
?>

Um eine globale Variable aus dem gesamten Script mit weiner Funktion zu entfernen gibt es aber noch das superglobale Array $GLOBALS. Im folgenden Beispiel wird die Variable entgültig gelöscht. Die echo-Anweisung liefert wieder eine Fehlermeldung, weil die Variable $x nun nicht mehr existiert.

<?php
$x = 3.14;
function myFunc() {
global $x;
$x = 2.0;
unset($GLOBALS['x']);
}

myFunc();
echo $x;
?>

Referenz

Eine Liste der Funktionen zur Behandlung von Variablen finden sie hier:

php.net