====== Variablen ======

Eine Variable ermöglicht das Speichern eines Wertes an einer bestimmten [[glossary:address|Speicheradresse]]. Für bequemes Arbeiten mit diesen Adressen verwenden Programmiersprachen oft die sogenannten Variablennamen, die eine solche Adresse repräsentieren.

Gültige Zeichen für Variablennamen sind alle Buchstaben aus dem englischen Alphabet (Also keine Umlaute und kein ß), Ziffern und Unterstriche. Am Anfang steht ein Buchstabe oder Unterstrich, aber auf keinen Fall eine Ziffer. Selbst definierte Variablen solltest Du stets mit einem Buchstaben beginnen, denn PHP stellt System-Variablen zur Verfügung, die mit dem Unterstrich beginnen. Eine Ausnahme stellt die Verwendung von bestimmten Variablen in mehreren Skripten dar, was aber später erläutert wird.
PHP unterscheidet zwischen Groß- und Kleinschreibung!

Wie aus der Bezeichnung hervorgeht, ist der Inhalt variabel und der Wert der Variablen kann vom Programmierer jederzeit neu zugewiesen werden.

===== Wertzuweisungen =====

Um Variablen zuzuweisen, schreibst Du ein $-Zeichen (Dollar), den Namen der Variable und anschließend den Operator = (Gleich). Hinter dem Operator steht der Wert der Variablen.

<code php>
<?php
   $variablename = "Inhalt";
   $ganzzahl = 10;
   $fliesskommazahl = 10.5;
?>
</code>

Um Variablen einen numerischen Wert zuzuweisen, setzt Du kein Anführungszeichen, sonst wird der Wert als Zeichenkette (String) verarbeitet. PHP kann den [[glossary:datatypes|Datentyp]] automatisch nach ihrem zugewiesenen Wert bestimmen.

An Variablen kann auch indirekt ein Wert vergeben werden.
<code php>
<?php
    $a = 10;
    $b = $a;
    echo "Der Wert der Variable \$b ist der von \$a, also ".$b;
?>
</code>

**Ausgabe:**
   Der Wer der Variable $b ist der von $a, also 10.

===== Globale Variablen =====

Sobald Strukturen wie [[php:loop|Schleifen]] oder [[php:functions|Funktionen]] auftauchen, beachtest Du bitte Folgendes:
  * Variablen, die Du außerhalb von Funktionen deklarierst, sind innerhalb dieser nicht bekannt
  * Jede Variable, die Du innerhalb eines Funktionsblocks deklarierst, ist außerhalb unbekannt. Man sagt auch, der Gültigkeitsbereich ([[glossary:Scope]]) der Variable ist auf die Funktion beschränkt.

<code php>
<?php
    $a = 10;
    function zeige()
    {
        echo $a;
    }
?>
</code>

Diese Funktion gibt nicht, wie erwartet, 10 aus. Der Bildschirm bleibt leer (oder es wird ein E_NOTICE Fehler ausgegeben), da die Variable <php>$a</php> nicht der Funktion bekannt gemacht wurde (Also nicht im Scope der der Variable liegt).

Mehr zu Funktionen findest du [[php:functions|Hier]].

Um die Variable bekannt zu machen, musst du ''global'' verwenden. Damit kannst du Variablen und deren Werte strukturübergreifend benutzen. Allerdings zeugt dies von einem schlechten Programmierstil. Variablen sollten bewusst einer Funktion übergeben und wieder ausgelesen werden. Dies wird ausführlich im Kapitel [[php:functions|Funktionen]] gezeigt.

<code php>
<?php
    $a = 10;
    function zeige()
    {
        global $a;
        echo $a;
    }
?>
</code>

**Ausgabe:**
  10

----
Möchtest Du trotzdem (mehrere) Variablen als ''global'' definieren, kannst Du dies mit dem Komma.
<code php>
<?php
  global $variable1, $variable2, $variable3;
?>
</code>
----

Der Server lädt diese Variablen in ein assoziatives [[php:arrays|Array]]. Mit <php>$GLOBALS['Variablenname']</php> rufst du nun eine <php>global</php> deklarierte Variable auf.
<code php>
<?php
    global $a,$b,$c;
    $a = 10;
    $b = 10.5;
    $c = "PHP";

    function zeige()
    {
      echo " Der Wert der Variable \$a ist".$GLOBALS['a']." und der Wert von \$b ist ".
      $GLOBALS['b']." und von \$c ist der Wert '".$GLOBALS['c']."'.";
    }
?>
</code>

**Ausgabe:**
  Der Wert der Variable $a ist 10 und der Wert von $b ist 10.5 und von $c ist der Wert 'PHP'.
  
Mehr zu Arrays erfährst Du [[php:arrays|im Kapitel Arrays]].

===== Statische Variablen =====

Normalerweise verlieren Variablen nach Verlassen eines Anweisungsblocks, zum Beispiel einer Funktion oder einer Schleife, ihren in der Struktur neu berechneten Wert (Nach PHP 5.1 ist dies nicht mehr der Fall, wenn Schleifen benutzt wurden). Ist das nicht erwünscht, kannst du die Variable mit <php>static</php> deklarieren.

<code php>
<?php
    function zeige()
    {
        $var1 = 10;
        $var2 = $var1 + $var1;
        echo "Der Wert der Variable ist: ".$var1."<br />";
    }
    zeige();
    zeige();
?>
</code>
**Ausgabe:**
  Der Wert der Variable ist 20
  Der Wert der Variable ist 20

<code php>
<?php
    function zeige()
    {
        static $var1 = 10; //Statische Deklaration
        $var1 = $var1 + $var1;
        echo "Der Wert der Variable ist: ".$var1."<br />";
    }
    zeige();
    zeige();
?>
</code>

**Ausgabe:**
  Der Wert der Variable ist 20
  Der Wert der Variable ist 40
  
Die statische deklarierte Variable behält ihren in der Struktur neu zugewiesenen Wert bei.

===== Dynamische Variablen =====

PHP bietet die Möglichkeit, eine Variable in einer anderen zu speichern. Im folgenden Beispiel wird zuerst der Variable <php>$a</php>  der Wert ''name'' zugewiesen. Im zweiten Schritt wird eine neue Variable dynamisch erzeugt, indem zwei <php>$</php>-Zeichen (<php>$$</php>) verwendet werden. Der neuen Variable wird der Wert ''Lernen'' zugewiesen. Der Variablenname der dynamisch erzeugten Variable hat den Wert der Variable <php>$a</php> angenommen. Das bedeutet, dass die dynamische Variable jetzt eigentlich <php>$name</php> heißt.
<code php>
<?php
     $a = "name";
     $$a = "Lernen";
     echo $name;
?>
</code>
** Ausgabe: **
''Lernen''

----
Diese Art der Deklaration von Variablen ist auch mit [[php:arrays|Arrays]] möglich. Für weitere Infos zum Thema variable/dynamische Variablen empfehle ich das [[http://php.net/manual/de/language.variables.variable.php|PHP-Manual]].
----

===== Variablenfunktionen =====

Durch die Funktion ''isset()'' wird eine Variable auf ihre Existenz überprüft.

<code php>
<?php
    $test = "PHP";
    $existent = isset($test);
?>
</code>

Ist die Variable <php>$test</php> nicht deklariert, erhält <php>$existent</php> den Wert <php>FALSE</php>, was falsch bedeutet. Anders in diesem Beispiel: Hier wurde $existent der Wert <php>TRUE</php> zugewiesen.

Um zu testen, ob der Wert einer Variable existiert, wird die Funktion <php>empty()</php> genutzt. Diese Funktion  gibt ebenfalls <php>FALSE</php> oder <php>TRUE</php> zurück.

<code php>
<?php
 $variable = "Proggen.org";
 $test = empty($variable);
?>
</code>

Während ''isset'' nur überprüft, ob die Variable existiert, führt ''empty'' zusätzlich den Test auf einen gültigen Wert durch. Das bedeutet: ''empty'' liefert ''TRUE'', wenn die Variable nicht existiert (wie ''isset'') und auch dann, wenn die Variable den Wert 0 oder ''FALSE'' beinhaltet.

Variablen können mit der Funktion ''unset'' gelöscht werden. Wenn Variablen nicht mehr benötigt werden, ist diese Funktion sinnvoll, aber veraltet - da PHP alle Werte beim Beenden des Skripts löscht.

<code php>
<?php
  $variable = "Proggen.org";
  unset($variable);
?>
</code>
----
Info: Du löschst eine Variable auch, indem Du ihr den Wert ''NULL'' (Also nichts) zuweist.
----

===== Konstanten =====

Konstanten sind [[glossary:address|Speicherplätze]], deren Wert nicht verändert werden kann. Ist eine Konstante deklariert, ist sie global im Skript nutzbar.
Das ist sinnvoll, wenn Du einen Wert an mehreren Stellen des Skripts benötigst, aber sicher sein möchtest, dass er sich nicht ändert. Damit Du bei Änderungen des Wertes nicht das gesamte Skript nach dem Wert durchsuchen musst, lohnt sich die Definition der Konstanten, um dann nur diesen Wert ändern zu müssen.

==== Deklaration von Konstanten ====

Konstanten werden mit ''define'' deklariert, die Syntax ist folgendermaßen:
<code php>
<?php
  define("KonstantenName","Wert der Konstante");
  echo "Der Wert der Konstante 'KonstantenName' ist".KonstantenName;
?>
</code>

**Ausgabe:**
  Der Wert der Konstante 'KonstantenName' ist Wert der Konstante.

An erster Stelle wird der Name der Konstante festgelegt. Im Beispiel lautet der Name ''KonstantenName''. Der Wert steht, mit einem Komma getrennt vom Konstanten-Name, an zweiter Stelle. Im Gegensatz zu Variablen muss beim Aufrufen einer Konstanten das <php>$</php>-Zeichen weggelassen werden.

Konstanten werden häufig komplett groß geschrieben; wie bei Variablen wird Groß- und Kleinschreibung beachtet.

<code php>
define( "PI", 3 )
</code>

===== Einige in PHP vordefinierte Konstanten =====

^Konstante^Beschreibung^
|''NULL''|''NULL'' ist ein Wert - Naja eigentlich nicht wirklich, denn er beinhaltet wortwörtlich Nichts. Der Datentyp ist ebenfalls ''NULL'' nach der Zuweisung.|
|''TRUE''|Der Boolean-Wert ist wahr oder auch 1.|
|''FALSE''|Der Boolean-Wert ist falsch oder auch 0.|
|''PHP_VERSION''|Gibt die installierte PHP-Version zurück.|
|''PHP_OS''|Gibt den Namen des Betriebssystems zurück, auf dem PHP aktiv ist.|
|''<nowiki>__FILE__</nowiki>''|Gibt den Dateinamen des Skriptes zurück, welches gerade ausgeführt wird.|
|''<nowiki>__LINE__</nowiki>''|Gibt die Zeilennummer im Skript zurück, welches gerade ausgeführt wird.|
|''<nowiki>__FUNCTION__</nowiki>''|Gibt den Namen der Funktion zurück, in der diese Konstante ausgelesen wird.|
|''<nowiki>__CLASS__</nowiki>''|Gibt den Namen der Klasse zurück, in der diese Konstante ausgelesen wird.|
|''<nowiki>__METHOD__</nowiki>''|Gibt den Namen der Methode zurück, in der diese Konstante ausgelesen wird.|

=====Datentypen=====

In PHP ist es nicht nötig, jeden Datentyp explizit zu deklarieren. Der Typ einer Variable wird automatisch durch den zugewiesenen Wert (Siehe [[php:type-juggling|Type Juggling]]) bestimmt. Es gibt jedoch Situationen, in denen das Erzwingen von Datentypen erforderlich ist.

==== Datentypen ====

^Datentyp^ Beschreibung^
|integer (int)  | Ganzzahl |
|float (float)  | Fließkommazahl |
|string         | Zeichenkette mit 0 bis einer beliebigen Anzahl Zeichen |
|boolean (bool) | Wahrheitswert (''TRUE'', ''FALSE'') |
|array          | Array |
|object         | Objekt (Einer Klasse oder anderem) |
|resource       | Spezieller Datentyp mit einem Verweis auf eine Ressource (zum Beispiel ein [[php:images|Bild]]) |

==== Bestimmen von Datentypen ====

Zum Ermitteln eines Datentyps einer Variable stehen Dir folgende Funktion zur Verfügung:

^Funktion^Beschreibung^
|gettype()|Gibt den Datentypen einer Variable zurück. Ist der Datentyp unbekannt, wird ''unknown type'' zurückgegeben|
|is_long()|Gibt den Boolean-Wert ''TRUE'' zurück, wenn der Datentyp integer ist|
|is_int()|Siehe ''is_long()''|
|is_integer()|Siehe ''is_long()''|
|is_double()|Gibt den Boolean-Wert ''TRUE'' zurück, wenn der Datentyp double ist|
|is_real()|Siehe ''is_double()''|
|is_float()|Siehe ''is_double()''|
|is_string()| Gibt den Boolean-Wert ''TRUE'' zurück, wenn der Datentyp string ist|
|is_array()|Gibt den Boolean-Wert ''TRUE'' zurück, wenn der Datentyp array ist|
|is_object()|Gibt den Boolean-Wert ''TRUE'' zurück, wenn der Datentyp object ist|
|is_numeric()|Gibt den Boolean-Wert ''TRUE'' zurück, wenn ein nummerische Wert oder eine Zeichenkette, die Ziffern enthält gegeben wurde|
|is_bool()|Gibt den Boolean-Wert ''TRUE'' zurück, wenn ein boolscher Wert vorliegt|
|is_scalar()|Gibt den Boolean-Wert ''TRUE'' zurück, wenn ein nummerischer Datentyp vorliegt|
|is_resource()|Gibt den Boolean-Wert ''TRUE'' zurück, wenn es sich um eine Ressource handelt|
|is_NULL()|Gibt den Boolean-Wert ''TRUE'' zurück, wenn die Variable  NULL ist|

==== Datentypen in der Praxis ====

Folgende Beispiele verdeutlichen Dir, wie PHP verschiedene Datentypen anhand von Wertzuweisung erkennt (weitere Infos im nächsten Kapitel [[php:type-juggling|Type Juggling]]). Dabei wird der Variable <php>$a</php> der Wert zugewiesen, der durch die Funktion gettype() erkannt werden soll.

Zuerst wird an die Variable <php>$a</php> eine Ganzzahl mit dem Wert 10 vergeben:
<code php>
<?php
$a = 10;
$datentyp = gettype($a);
echo "Der Datentyp der Variable \$a ist: ".$datentyp.".";
?>
</code>

**Ausgabe:**
  Der Datentyp der Variable <php>$a</php> ist: integer.''

Jetzt erhält die Variable <php>$a</php> den Fließkomma-Wert 2.45. In PHP verwendest Du die amerikanische Schreibweise mit einem Punkt anstelle eines Kommas.

<code php>
<?php
$a = 2.45;
$datentyp = gettype($a);
echo "Der Datentyp der Variable \$a ist: ".$datentyp.".";
?>
</code>
**Ausgabe:**
  Der Datentyp der Variable $a ist: double.

Nachfolgend steht der Wert der Variable <php>$a</php> für eine Zeichenkette, die PHP durch einfache oder doppelte Anführungszeichen erkennt.

<code php>
<?php
$a = "Dies ist eine Zeichenkette.";
$datentyp = gettype($a);
echo "Der Datentyp der Variable \$a ist: ".$datentyp.".";
?>
</code>

**Ausgabe:**
  Der Datentyp der Variable $a ist: string.''

Wenn Du unterschiedliche Datentypen miteinander verknüpfst, wird dem entstandenem Wert automatisch der (wahrscheinlich) sinnvollste Datentyp zugewiesen:
<code php>
<?php
$a = 10;    //Integer
$b = 10.65; // Double
$c = $a + $b;
echo "Der Wert der Variable \$c ist $c und vom Datentyp ."gettype($c);
?>
</code>
**Ausgabe:**
  Der Wert der Variale $c ist 20.65 und vom Datentyp double.''

Für das oben gezeigte Beispiel gibt es weitere Infos im Kapitel [[php:operators|PHP-Operatoren]].

Die Datentypen Integer und Float ergeben zusammen Float. Die Datentypen Integer und String ergeben String. Und die Datentypen Float und String ergeben ebenfalls String.
----
**Merke: Variablen, egal von welchem Datentyp, ergeben immer String, falls ein String in der Rechnung benutzt wird.**
----
==== Umwandlung von Datentypen ====

Gegenfalls ist es erforderlich, eine Variable manuell in einen bestimmten Typ umzuwandeln. Dazu dient die Funktion ''settype()''. Im Beispiel ist der Wert der Variable <php>$a</php> zunächst vom Typ ''integer'' und wird dann in eine Fließkommazahl umgewandelt.

<code php>
<?php
$a = 10;
settype($a,"float");
echo "Der Datentyp der Variable \$a ist: ".gettype($a);
?>
</code>

**Ausgabe:**
''Der Datentyp der Variable $a ist: double''

PHP unterstützt zudem auch so genannte [[c:cast|Cast]]-Operatoren. Durch das Voranstellen des Operatoren vor eine Variable wird ebenfalls der Datentyp geändert. Alle ''Cast''-Operatoren findest du im Kapitel [[php:operators|Operatoren]].

<code php>
<?php
$a = 10;
$a = (float) $a; //Vorangestellter cast-operator
echo "Der Datentyp der Variable \$a ist: ".gettype($a);
?>
</code>

**Ausgabe:**
  Der Datentyp der Variable $a ist: float
  
Weiter geht es auf der nächsten Seite mit einer Erklärung zum Thema [[php:type-juggling|dynamische Datentyp Anpassung (type juggling)]].