Was ist nun eine Variable und was eine Konstante? Ganz einfach: Der Inhalt einer Variablen kann, wie der Name schon sagt, variieren, ist also veränderlich. Wogegen der Inhalt einer Konstanten "konstant" bleibt, also einmal festgelegt und dann nicht mehr verändert wird.

Variablen  nach oben

In PHP werden alle Variablen mit einem Dollarzeichen $ begonnen. Namen für Variablen können aus Buchstaben, Ziffern und dem Unterstrich bestehen, allerdings dürfen Ziffern nie als erstes im Namen stehen:

$variable2 = 0;  // gültig
$2variable = 0;  // ungültig

Vordefinierte Variablen  nach oben

In PHP gibt es noch eine Reihe vordefinierte Variablen, mit denen man die Informationen zu PHP , dessen Konfiguration als auch die Serverumgebung (Environmentvariablen) auslesen kann. Im Regelfall sind diese Variablen immer groß geschrieben und beginnen oft mit einem Unterstrich:

print_r($_GET); 
//gibt alle mittels Get-Methode übergebenen Variablen aus 

print_r($_POST); 
//gibt alle mittels POST übergebenen Variablen aus

phpinfo(INFO_VARIABLES); 
//Infos über alle PHP-Variablen

Es gibt natürlich noch eine Menge weiterer vordefinierter Variablen, dessen Auflistung hier aber den Rahmen sprengen würde.

Gültigkeitsbereiche  nach oben

Der Gültigkeitsbereich einer Variable sagt aus, wo eine Deklaration und eine Wertzuweisung an diese Bestand hat. PHP macht es hier insofern einfach, dass man auch ohne Fehlermeldung auf Variablen zugreifen kann, die man nicht deklariert hat.

echo 'Mein Name ist ',$name,'.';
//gibt keine Fehlermeldung, Ausgabe: Mein Name ist .

Nichtdeklarierte Variablen haben je nach Typ keinen Inhalt oder 0.

Im Wesentlichen gibt es zwei verschiedene Geltungsbereiche: den globalen und den lokalen. Der Unterschied ist, dass alle im globalen Bereich deklarierten Variablen im gesamten Bereich inklusive aller Funktionen im Script verfügbar sind. Der globale Bereich ist der komplette Bereich inklusive der Funktionen und Objekte. Lokale Bereiche dagegen sind Bereiche innerhalb von Funktionen, Objekten oder Includes. Alle dort deklarierten Variablen sind auch nur dort verfügbar.

//globaler Bereich
$name='Fred';           
//hier wird $name global definiert, ihr Wert ist 'Fred' 

function get_name() 
{
 //lokaler Bereich

 echo "lokal: $namen"; 
 //hier ist $name nicht bekannt, deshalb leer

 $name='Franz';         
 //jetzt wird $name lokal deklariert

 echo "lokal: $namen"; 
 //und $name hat den Wert 'Franz'
}

echo "global: $namen"; 
//Ausgabe des globalen $name

get_name();             
//Sprung in den lokalen Bereich

echo "global: $namen"; 
//Ausgabe des globalen $name

Wer aufgepasst hat wird jetzt sicherlich fragen, warum $name bei der ersten Ausgabe in der Funktion get_name() nicht deklariert war, eigentlich sollten doch globale Variablen innerhalb von Funktionen sichtbar sein? Sind sie ja auch, man muss PHP nur ein bisschen die Augen öffnen: schreiben wir einfach mal folgende Zeile als erste in den Rumpf unserer Funktion get_name():

global $name;

Durch das Schlüsselwort global wird dem Interpreter mitgeteilt, dass die Variable nicht im lokalen Bereich neu definiert werden soll sondern auf eine eventuell im globalen Bereich existierende Variable zugegriffen wird.
Des weiteren gibt es auch noch die Möglichkeit, lokale Variablen am Leben zu erhalten: die sogenannten statischen Variablen:

function counter() 
{
  $cnt=0;
  echo $cnt,"n";
  $cnt++;
}
  
for($a=0;$a<100;$a++) 
{
  counter();
}

In diesem Beispiel wird in der Funktion counter() eine lokale Variable $cnt deklariert und mit 0 initialisiert. Dann wird diese ausgegeben und um 1 erhöht. Unsere for-Schleife ruft nun diese Funktion 100 mal auf und was passiert? Es wird 100 mal 0 ausgegeben, da die Variable $cnt jedes Mal neu deklariert und initialisiert wird. Aber es geht auch anders: ersetzen wir die erste Zeile der Funktion mit folgender Anweisung:

static $cnt=0;

Das Schlüsselwort static bewirkt, dass nach Verlassen der Funktion die Variable $cnt zwar immer noch nicht global gültig ist, diese aber bestehen bleibt und beim nächsten Aufruf der Funktion ihren vorigen Wert noch "kennt". So werden hier die Zahlen 0 bis 99 ausgegeben.

Variable Variablen  nach oben

So kann man die Möglichkeit nennen, über den in einer anderen Variablen gespeicherten Namen auf eine existierende Variable mit diesem Namen zuzugreifen. Langer Satz, kurzer Sinn:

$var='Inhalt von var';
$name_von_var='var';
echo $$name_von_var; //gibt 'Inhalt von var' aus

Durch die doppelten Dollarzeichen wird PHP mitgeteilt, dass es auf die Variable mit dem in der Variable enthaltenen Namen zugreifen soll. Sozusagen eine doppelte Dereferenzierung.

Variablentypen  nach oben

In PHP gibt es insgesamt sechs wesentliche Typen:

  • die skalaren Typen: Boolean (Wahrheitswert), Integer (Ganzzahl), Double (Gleitkommazahl), String (Text)
  • und die zusammengesetzten Typen: Array (Liste von Variablen), Objekt (Struktur mit Funktionen)

Die skalaren Typen werden im Prinzip nicht vom Programmierer zugewiesen sondern durch den PHP-Interpreter bestimmt, wobei sich aber die Typen erzwingen lassen.

$var=1.276; 
//der Interpreter weißt hier den Typ Float zu

settype($var,"integer"); 
//Typumwandlung zu Integer erzwingen

echo $var; 
//ergibt 1, da Integer keine Kommastellen speichern kann

Im folgenden werden wir auf die sechs Typen näher eingehen.

Boolean

Dieser Datentyp kennt nur zwei Inhalte: Wahr (true) oder Falsch (false), wobei hier alle Werte außer 0 wahr sind, die Null dagegen falsch entspricht.

$var=false; 
//$var enthält jetzt false

$var=1<2; 
//$var ist jetzt true, da 1 kleiner 2 wahr ist

Falsch-Entsprechungen der anderen Datentypen:

  • Integer - 0
  • Double - 0.0
  • String - "" (leere Zeichenkette)
  • Array - keine Elemente
  • Objekt - keine Elemente

Alle anderen Werte werden mit Wahr gleichgesetzt.

Integer

Dieser Datentyp wird für vorzeichenbehaftete Ganzzahlen im Bereich von -2147483647 bis 2147483647 verwendet. Wird einer Variablen eine Zahl außerhalb diesen Bereiches zugewiesen erhält diese den Typ Double.

$var=2147483647; 
echo $var," ist ein ",gettype($var); 
//Ausgabe: 214783647 ist ein integer

$var=2147483648; 
// außerhalb des Darstellungsbereichs

echo $var," ist ein ",gettype($var); 
//Ausgabe: 214783648 ist ein double

Double

Für mathematische Darstellungen ist dieser Typ unerlässlich, da er aufgrund seiner Strukturierung nicht nur sehr große sondern auch gebrochene Zahlen darstellen kann. Um in PHP eine Variable vom Type Double zu deklarieren, kann man zwei Varianten nutzen:

//Variante 1
$var_1=1.0; 
//hier wird der Typ durch das Komma festgelegt

$var_2=2; 
settype($var_2,"double"); 
//und hier durch explizites Setzen des Typs

echo "var_1 = ",gettype($var_1),", var_2 = ",gettype($var_2);

String

Dieser Typ wird zur Darstellung von Zeichenketten genutzt. Es gibt drei verschiedene Möglichkeiten, eine Zeichenkette im Code darzustellen:

  • einfache Anführungszeichen (single quoted)
  • doppelte Anführungszeichen (double quoted)
  • Heredoc-Syntax

Die einfachen Anführungszeichen kann man für einfache Zeichenketten verwenden.

echo 'Das ist ein einfacher String.';

Um in dieser Zeichenkette ein einfaches Anführungszeichen wiedergeben zu können, muss diesem ein Backslash vorangestellt werden:

echo 'Das gibt's doch nicht.'; //so geht's nicht:
echo 'Das gibt's doch nicht.'; //aber so

Doppelte Anführungszeichen werden verwendet, um ein String-Parsing zu ermöglichen. Das bedeutet, dass die Zeichenkette innerhalb der Anführungszeichen nicht einfach nur ausgegeben sondern vorher auf Enthaltensein von Variablen und erweiterten Formatierungszeichen geprüft wird:

for ($a=1;$a<10;$a++)
{
 echo "Das ist der $a. Durchlauf.n";
}

Das heißt also, das direkt in dem String auch Variablen enthalten sein können und diese auch korrekt ausgegeben werden.
Die erweiterten Formatierungsanweisungen, auch genannt Escapesequenzen, werden an dem vorangestellten Backslash erkannt. Folgende sind verfügbar:

n        Zeilenvorschub (10 als ASCII-Code)
r        Wagenrücklauf (13 als ASCII-Code)
t        horizontaler Tabulator (9 als ASCII-Code)
"        Doppelte Anführungszeichen
$        Dollarzeichen
        Backslash

Dabei ist allerdings zu beachten, dass Formatierungen wie Zeilenvorschub und Tabulator im Browser nur ein Leerzeichen bewirken. Um dann die Formatierung sehen zu können, muss man sich den Quelltext der von PHP generierten Ausgabe ansehen.

Zu guter Letzt noch die Heredoc-Syntax. Diese hat im Prinzip die gleichen Eigenschaften wie die "double-quoted" - Variante, nur können hier die Stringbegrenzer frei gewählt werden:

echo <<<MyString
Dieser Text wird jetzt genauso ausgegeben, 
wie er hier folgt. Dabei werden
Auch Formatierungen wie Zeilenvorschub und 
 Tabulatoren
berücksichtigt.
MyString;

Bei dieser Zeichenkettenkennzeichnung wird einfach einem Bezeichner, der den gleichen Namenskonventionen unterliegt, ein "<<<" vorangestellt. In dem obigen Beispiel habe ich ihn "MyString" genannt. Folgt jetzt nach dem "<<<MyString" nochmals der gleiche Bezeichner, hier also "MyString", so erkennt PHP die Zeichenkette als abgeschlossen:
Der Vorteil dieser Methode besteht darin, dass auf diese Weise lange, mehrzeilige Strings sehr leicht in den Code eingefügt werden können.

Um innerhalb von Zeichenketten die Variablennamen zu begrenzen, kann man diese in geschweifte Klammern setzen:

$name='Mike';

echo '$name's PC.'; 
//ergibt: $name's PC., da single-quoted

echo "$name's PC.";  
//ergibt: Mike's PC., da double-quoted

echo "$names PC."; 
//ergibt:  PC., da $names nicht definiert und somit leer ist

echo "{$name}s PC."; 
//ergibt: Mikes PC., da hier Begrenzung der Variable

Arrays

Einer der "quellcodesparendsten" Variablentypen ist wohl das Array. Frei übersetzt mit "Anordnung" stellt das Array eine ein- oder mehrdimensionale Liste von Variablen dar, auf die über den sogenannten Index-Operator [] unter Angabe eines Schlüssels zugegriffen werden kann.
Ein Array wird über das Sprachkonstrukt array() gebildet.

//reales Array
$namen=array('Klaus','Dieter','Maria','Sepp','Michael');
print_r($namen);

Die Werte eines Arrays müssen dabei nicht wie in den Compilersprachen vom gleichen Datentyp sondern können vollkommen unterschiedlich sein.

//reales Array
$datatypes=array('String',1,2.0,array(1,2,3,4),true);
print_r($datatypes);

//assoziatives Array
$alter=array("Klaus"=>25,"Dieter"=>42,"Maria"=>24,
             "Sepp"=>13,"Michael"=>26);
print_r($alter);

Auf die Elemente des Arrays kann jetzt über den jeweiligen Schlüssel zugegriffen werden, wobei im realen Array der Index, insofern nicht anders angegeben, immer bei 0 beginnt:

$namen=array('Klaus','Dieter','Maria','Sepp','Michael');
for ($a=0;$a<5;$a++) 
{
  echo "$a: $namen[$a]n";
}

Im assoziativen Array kann man die einzelnen Elemente über den bei der Zuweisung angegebenen Schlüssel holen:

$alter=array("Klaus"=>25,"Dieter"=>42,"Maria"=>24,"Sepp"=>13,
             "Michael"=>26);
echo "Das Alter von Klaus ist ",$alter['Klaus']," Jahre.";

Hierbei kann der Schlüssel ebenfalls von jedem beliebigen Datentyp sein, wobei bei der Verwendung der beiden Booleeschen Werte true als (int)1 und false als (int)0 angenommen wird.
Die Zuweisung von Werten zu bestehenden Elementen sowie das Hinzufügen neuer Elemente ist ebenfalls denkbar simpel:

$alter=array("Klaus"=>25,"Dieter"=>42,"Maria"=>24,
             "Sepp"=>13,"Michael"=>26);
$namen=array('Klaus','Dieter','Maria','Sepp','Michael');

$alter['Dieter']=40; 
//Dieter ist jetzt zwei Jahr jünger 

$alter['Franz']=35; 
//$alter ein Element 'Franz' mit Wert 35 hinzufügen

array_push($namen,'Franz'); 
// $namen wurde Element mit dem Wert 'Franz' angehängt

Eine Verschachtelung und der Schlüsselzugriff über Variablen ist auch möglich:

//...
for($a=0;$a<6;$a++) 
{
  echo $namen[$a]," ist ",$alter[$namen[$a]]," Jahre alt.n";
}

Der Wert eines Elementes kann auch ein Array sein, so ist die Bildung mehr- und multidimensionaler Arrays möglich:

$zeile=array(); //leeres Array für Zeilen bilden

for ($a=0;$a<5;$a++) 
{
  $zeile[$a]=array(1,2,3,4,5); 
  //jede Zeile erhält jetzt ein Array mit 5 Elementen
}

//und jetzt die Ausgabe
for ($y=0;$y<5;$y++) 
{
  echo "nZeile $y:t";
  for ($x=0;$x<5;$x++) 
  { echo $zeile[$y][$x],"t"; }
}

Um ein Element eines Arrays zu löschen, kann man die Funktion unset() verwenden:

// Array mit Monatsnamen erzeugen, dabei nicht 
// mit 0 sondern mit 1 beginnen
$monate=array(1=>'Januar','Februar','März');
unset($monate[2]); //löscht Februar aus der Liste
print_r($monate);

Objekt

Das Objekt ist eigentlich mehr als nur ein Datentyp. Mit diesem werden nicht nur reine Daten gehalten sondern auch gleich die notwendigen Bearbeitungs-, Ein- und Ausgabefunktionen mitgeliefert:

//Deklaration und Implementation des Objekttyps
class meinObjekt 
{
  var $name="Objekt";
  function print_name() 
  { 
    echo "Mein Name ist ",$this->name,"."; 
  }
}

//Verwendung des Objekts
$obj=new meinObjekt(); //Objekt generieren
$obj->print_name();    //Ausgabe: Mein Name ist Objekt.

Mehr dazu im Kapitel "Klassen und Objekte".

Referenzen

Seit dem Release von PHP 4 ist es nun auch möglich, sogenannte Referenzen auf Variablen übergeben zu können. Setzt man das Referenzzeichen & vor den Übergabeparameter, so wird keine Kopie des Parameters übergeben, sondern ein Variable, die auf den gleichen Inhalt zeigt.

function mitKopie($param) 
{
 $param=12;
 echo "Kopie: $paramn";
}

function mitReferenz(&$param) 
{
 $param=12;
 echo "Referenz: $paramn";
}

$param=6;

echo "Vor Aufruf mitKopie(): $paramn";
mitKopie($param);
echo "Nach Aufruf mitKopie(): $paramnn";

echo "Vor Aufruf mitReferenz(): $paramn";
mitReferenz($param);
echo "Nach Aufruf mitReferenz(): $paramn";

Des weiteren ist es natürlich auch möglich, über Variablen zu referenzieren.

$a="Text";
$b=&$a;     //$b zeigt jetzt auf den gleichen Inhalt wie $a
$b="Anderer Text"; 
echo $a;    //gibt 'Anderer Text' aus

Das kommt daher, dass der PHP-Interpreter intern eine Tabelle führt in der der Variablenname, der Typ sowie ein Zeiger auf den Inhalt der Variablen abgelegt ist. Weißt man einer Variablen jetzt die Referenz auf eine andere Variable zu, so ist dann bei beiden Variablen der Zeiger auf den Inhalt und somit auch der Typ gleich.

$a=12;
echo gettype($a); //gibt 'integer' aus
$b=&$a;     
$b=5.2; 
echo gettype($a); //gibt 'double' aus

Typumwandlung

Vom Prinzip her braucht man sich als PHP-Programmierer keine Gedanken um die Typumwandlung zu machen, da der PHP-Interpreter diese automatisch durchführt. Dennoch ist es manchmal wichtig, den Typ einer Variablen zu kennen beziehungsweise ihn festzulegen.
Neben der automatischen Typzuweisung durch den Interpreter gibt's es noch zwei andere Arten, den Typ eines Ausdrucks beziehungsweise einer Variablen festzulegen:

Datentypsettype() / gettype()UmwandlungPrüfung
Boolean"boolean"(bool)is_bool()
Integer"integer"(int)is_int()
Double"double"(double)is_double()
String"string"(string)is_string()
Array"array"(array)is_array()
Objekt"object"(object)is_object()

$a=(int)(12/3); 
//Ergebnis von 12/3 ist Double, wird hier aber zu Integer

settype($b,gettype($a)); 
//Typ von $b wird jetzt der von $a

Konstanten  nach oben

Konstanten sind prinzipiell Variablen, deren Inhalt nur einmal zugewiesen und dann nur noch gelesen werden darf.

Syntax

Die Syntax der Konstante entspricht der einer Variablen, nur dass hier kein Dollarzeichen vorangestellt wird und sie definiert werden muss.

define("Name_Index",2);
echo Name_Index; //gibt '2' aus

Eine einmal definierte Konstante kann im Script nicht wieder gelöscht oder verändert werden. Des weiteren sind für Konstanten nur skalare Typen zugelassen, also Boolean, Integer, Double und String.
Ein Vorteil von Konstanten ist ihre Verfügbarkeit. Im Gegensatz zu Variablen sind Konstanten immer global und brauchen in lokalen Bereichen und Namensräumen nicht extra "globalisiert" werden.
Man kann auch die Verfügbarkeit von Konstanten abprüfen:

define("Name_Index",2);
if (defined("Name_Index")) echo "Konstante existiert!";