Variablen und Konstanten in PHP

Genau wie die Mathematik kommt auch die Informatik ohne Platzhalter, die sogenannten Variablen und Konstanten, nicht weit. Diese haben in der Programmierung verschiedene Typen, die beschreiben was in einer Variable steht.

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:

Datentyp settype() / gettype() Umwandlung Pr√ľ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!”;

Weiterlesen

Hinterlasse eine Antwort

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind markiert *

Du kannst folgende HTML-Tags benutzen: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>