Datentypen

Variablen können unterschiedliche Datentypen speichern. PHP kennt folgende Datentypen:

Ein Datentyp beschreibt die Art der Informationen, die eine Variable enthalten kann. Der Typ einer Variablen wird normalerweise nicht vom Programmierer bestimmt. Vielmehr wird zur Laufzeit von PHP entschieden, welchen Datentyp eine Variable erhält, abhängig vom Kontext, in dem die Variable verwendet wird.

Variablen Deklaration

PHP kennt keine explizite Variablen-Deklaration wie z.B. in VB oder C++, sondern PHP erkennt den Datentyp selbsständig. Erst zur Laufzeit wird von PHP entschieden, welchen Typ eine Variable bekommt.

<?php
$x = "Hallo Welt!"; // string
$y = true; // boolean
$z = 3.14; // double
echo gettype($x);
echo gettype($y);
echo gettype($z);
?>

String

Ein String wird auch Zeichenkette genannt und ist eine Folge von Buchstaben, Ziffern und Sonderzeichen. Ein String wird von Anführungszeichen eingeschlossen, entweder von einfachen oder doppelten (single- oder double-quoted).

<?php
$meinVorname = "Adi";
$meinNachname = 'Prinz';
$meinGanzname = $meinVorname . " " . $meinNachname;
echo 'Mein Name ist: ' . $meinGanzname;
// Ausgabe: Mein Name ist: Adi Prinz
?>

Einfache Anführungszeichen (single-quoted)

Der leichteste Weg, einen einfachen String zu schreiben, ist der Einschluss in einfache Anführungszeichen ('). Anders als bei der Schreibweise mit doppelten Anführungszeichen werden Variablen innerhalb von single-quoted Strings nicht ausgewertet.

<?php
$meinVorname = 'Adi';
$meinNachname = 'Prinz';

echo 'Mein Name ist $meinVorname'; // liefert Mein Name ist $meinVorname
?>

In diesem Beispiel konzentrieren sie sich nur auf die echo-Anweisung. Diese ist ohne Verkettung in einfachen Anführungszeichen geschrieben und die Variable $meinVorname wird nicht ausgewertet.

Doppelte Anführungszeichen (double-quoted)

Dasselbe Beispiel nochmals, aber diesmal mit doppelten Anführungszeichen.

<?php
$meinVorname = 'Adi';

echo "Mein Name ist $meinVorname"; // liefert Mein Name ist Adi
?>

HERDOC & NOWDOC

Ähnliche Ergebnisse erreicht man mit den Operatoren HERDOC (<<<(Var)) und NOWDOC (<<<('Var')), wobei sich HERDOC wie double-quoted String und NOWDOC wie single-quoted String benimmt.

<?php
$meinVorname = 'Adi';

$str = <<<EOD
Mein Name ist $meinVorname
EOD;
echo $str; // liefert Mein Name ist Adi

$str = <<<'EOD'
Mein Name ist $meinVorname
EOD;
echo $str; // liefert Mein Name ist meinVorname
?>

Anführungszeichen innerhalb von Strings

Wenn jetzt ein Anführungszeichen im Text vorkommen soll, kann man alternative Anführungszeichen schreiben:

<?php
$x = "Mein Name ist 'Hase', ich weiß von Nichts"; 
$y = 'Mein Name ist "Hase", ich weiß von Nichts';
echo $x;
echo "<br>";
echo $y;
?>

Wenn der String in doppelte Anführungszeichen (") eingeschlossen wird, interpretiert PHP zusätzliche Escape-Sequenzen für Sonderzeichen.

Code Rückgabe
\n Zeilenvorschub
\r Wagenrücklauf
\t Tabulator
\\ Backslash
\$ Dollar-Symbol
\' Einfaches Anführungszeichen
\" Doppelte Anführungszeichen
\[0-7]{1,3} Die Zeichenfolge, die dem regulären Ausdruck entspricht, ist ein Zeichen in Oktal-Schreibweise.
\x[0-9A-Fa-f]{1,2} Die Zeichenfolge, die dem regulären Ausdruck entspricht, ist ein Zeichen in Hexadezimal-Schreibweise.
<?php
$x = "Mein Name ist \"Hase\", ich weiß von Nichts"; 
echo $x;
?>

String Funktionen

PHP kennt eine Menge an Funktionen für Strings z.B. das Ermitteln der Zeichenanzahl, oder das Ersetzen von Zeichenketten usw. Einige Beispiele habe ich hier:

  • trim() / Leerzeichen entfernen
  • str_replace() / Teilstring ersetzen
  • substr() / liefert einen Teilstring
  • htmlentities() / wandelt Zeichen in HTML-Codes um

trim()

Die trim()-Funktion entfernt Leerzeichen vor und nach einem String.

<?php
$x = " Hallo Welt!    "; 
echo trim($x); // liefert Hallo Welt!
?>

str_replace()

Die str_replace-Funktion ersetzt alle Vorkommen des Suchstrings durch einen anderen String. Der erste Parameter ist der gesuchte Wert, der zweite Parameter ist der zu ersetzende Wert und der dritte Parameter ist die zu durchsuchende Zeichenkette.

<?php
$x = "Hallo Welt!"; 
echo str_replace("Welt","Adi",$x); // liefert Hallo Adi!
?>

substr()

Die substr()-Funktion liefer teinen Teilstring einer Zeichenkette. Das erste Argument ist die Zeichenkette, das zweite Argument ist die Position ab der ein String zurückgegeben wird. Achtung, der Zähler beginnt bei Null (0) und Leerzeichen werden mitgezählt.

<?php
$x = "Hallo Welt!"; 
echo substr($x, 6); // liefert Welt!
?>

htmlentities()

Die htmlentities()-Funktion wandelt alle geeigneten Zeichen in entsprechende HTML-Codes um, z.B. HTML-Tags.

<?php
$x = "Dieser Text ist <b>fett</b>";
echo htmlentities($x); 
?>

Funktions Referenzen

Eine Liste der Funktionen zur Bearbeitung von Strings finden sie hier:

php.net

w3schools.com

Integer

PHP kennt zwei unterschiedliche Zahlen-Typen, Integer und Float. Ganze Zahlen (Integer) können dezimal, oktal, hexadezimal oder binär geschrieben werden. Ein Integer Datentyp darf keine Dezimalstellen haben und repräsentiert den Wert zwischen -2.147.483.648 and 2.147.483.647.

Integer Formate

Mit der Funktion var_dump() ermittelt PHP alle Informationen (z.B. Datentyp und Wert) einer Variablen und gibt den Inhalt im HTML zurück..

<?php
$a = 1234; // Dezimal
$b = -123; // Dezimal
$c = 0123; // Oktal 
$d = 0x1A; // Hexadezimal
$e = 0b11111111; // Binär 

var_dump($e); // liefert int(255) 
?>

Float

Der Datentyp Float wird oft auch als Double bezeichnet und speichert Zahlen mit Nachkommastellen im Format dezimal oder exponential.

Float Formate

<?php
$a = 1.234; 
$b = 7E-10;

var_dump($a); // liefert float(1.234)  
?>

Die Größe einer Fließkommazahl ist plattformabhängig, dennoch stellt ein Maximum von ~1.8e308 mit einer Genauigkeit von 14 Nachkommastellen einen üblichen Wert dar.

Mathematische Funktionen

Hier ist ein kleiner Auszug der mathematischen Funktionen von PHP:

  • abs() / liefert den Absolutwert
  • round() / rundet ein Float
  • mt_rand() / generiert Zufallszahl ais Integer
  • pi() / liefert pi

abs()

abs() liefert den Absoluwert einer Zahl.

<?php
$x = abs(-123.456);
var_dump($x); // liefert float(123.456)  
?>

round()

round() rundet eine Zahl, der erste Parameter ist die zu rundende Zahl, der zweite, optionale Parameter bestimmt die Anzahl der Nachkommastellen (Standard 0) und der dritte, optionale Parameter legt den Modus mit einer Konstante fest (PHP_ROUND_HALF_UP, PHP_ROUND_HALF_DOWN, PHP_ROUND_HALF_EVEN oder PHP_ROUND_HALF_ODD).

<?php
$x = round(1234.5678, 2);
var_dump($x); // liefert float(1234.57)   
?>

mt_rand()

mt_rand() generiert eine Zufallszahl als Integer. Wenn kein Parameter angegeben wird ein positiver Zufalls-Integer generiert, der ertste, optionale Parameter kann den kleinsten Integer, der zweite, optionale Parameter den größten Intiger bestimmen.

<?php
$x = mt_rand();
$y = mt_rand(1000, 2000);
var_dump($x);  
echo "<br>"; 
var_dump($y);  
?>

pi()

pi() liefert den Wert pi.

<?php
$x = pi();
$y = round($x, 2);
var_dump($y);   
?>

Referenz von Mathematische Funktionen

Eine Liste der Mathematische Funktionen finden sie hier:

php.net

w3schools.com

Boolean

Die Datentypen für Zahlen und Strings können beliebig viele verschiedene Werte annehmen. Der Datentyp Boolean kennt hingegen nur zwei mögliche Werte. Die zwei zulässigen Booleschen Werte sind true (wahr) und false (falsch). Ein boolescher Wert stellt einen Wahrheitswert dar, er besagt, ob ein Sachverhalt wahr ist oder nicht. Die beiden Schlüsselwörter true und false unterscheiden nicht zwischen Groß- und Kleinschreibung.

<?php
$x = true;
$y = false;

var_dump($x);  
echo "<br>"; 
var_dump($y);  
?>

Boolesche Werte sind im Allgemeinen das Ergebnis von Vergleichen, die in einem Programm vorgenommen werden.

<?php
$name = "Adi";
$name == "Adi" ? print "Mein Name ist Adi" : print "Mein Name ist nicht Adi";
// liefert Mein Name ist Adi 
?>

Bei der Umwandlung nach boolean werden folgende Werte als false angesehen:

  • das boolesche FALSE
  • die Integer 0 (Null)
  • die Fließkommazahl 0.0 (Null)
  • die leere Zeichenkette und die Zeichenkette "0"
  • ein Array ohne Elemente
  • ein Objekt ohne Elemente
  • der spezielle Type null (einschließlich nicht definierter Variablen)

Arrays

Ein Array ist ein Datentyp, in dem beliebig viele Werte abgespeichert werden können. Während eine Variable eines elementaren Datentyps immer nur einen einzelnen Wert enthält, kann eine Arrayvariable eine größere Anzahl verschiedenster Werte enthalten.
Die Elemente eines Arrays können Werte wie Zahlen, Strings, boolesche Werte, aber auch andere Arrays, Objekte oder Funktionen sein. PHP unterscheidet dabei zwischen:

Ein indiziertes Array wird mit dem Index angesprochen. Der Index entsteht automatisch bei der Initialisierung. Der Index beginnt bei Null (0), kann aber auch selbst definiert werden.
Von assoziativen Arrays oder Hashes spricht man, wenn die Elemente im Array nicht über Indizes, sondern über Strings bzw. Schlüssel angesprochen werden.

Indizierte Arrays

Indizierte Arrays verwenden Ganzzahlen als Schlüssel, die PHP vergibt. Die Syntax ist ähnlich der JavaScript-Schreibweise, anhand der eckigen Klammern erkennt PHP, dass es sich um ein Array handelt.

<?php
$color[] = "FF0000";
$color[] = "00FF00";
$color[] = "000000";
echo $color[0]; // liefert FF0000
?>

Der Index eines Arrays kann in PHP auch selbst definiert werden.

<?php
$color[2] = "FF0000";
$color[5] = "00FF00";
$color[9] = "000000";
echo $color[0]; // liefert Fehlermeldung
?>

Die Array Funktion

PHP stellt auch eine Funktion für die initialisierung von Arrays zur Verfügung. Die Funktionsparameter sind dabei die Array-Eintrgäge, den Index vergibt PHP selbstständig.

<?php
$color = array("FF0000", "00FF00", "000000");
echo $color[0]; // liefert FF0000
?>

Sie wollen einem Array mehrere Elemente auf einmal zuweisen, hierbei soll jedoch der erste Index nicht 0 sein. Bringen Sie array() dazu, einen anderen Index zu verwenden, indem Sie die Syntax mit dem Operator => verwenden. Im Beispiel bekommt der erste Array-Eintrag den Index 1, weitere Einträge passen sich automatisch an.

<?php
$color = array(1 => "FF0000", "00FF00", "000000");
echo $color[3]; // liefert 000000
?>

Sogar ein Konstrukt wie das folgende Beispiel ist möglich!

<?php
$color = array(1 => "FF0000", "00FF00", 12 =>"0000FF", "000000");
echo $color[13]; // liefert 000000
?>

Indiziertes Array in einer for-Schleife ausgeben

Die count-Funktion ermittelt die Anzahl der Array-Einträge.

<?php
$person = array("Adi", "Prinz", 60);
 $arrlength = count($person);

for($x = 0; $x < $arrlength; $x++) {
    echo $person[$x];
    echo "<br>";
}
?>

Assoziative Arrays

Schlüsselnamen müssen nicht numerisch sein. Sie können einen beliebigen Wert annehmen, etwa eine Zeichenkette, die Assoziationen zum Schlüssel erzeugt. Diese Assoziationen heißen HASHES.

<?php
$color["red"] = "FF0000";
$color["green"] = "00FF00";
$color["blue"] = "0000FF";
$color["black"] = "000000";
echo $color["blue"]; // liefert 0000FF
?>

Ein assoziatives Array lässt sich natürlich auch mithilfe der array()-Funktion erzeugen. Dabei kommt wieder der Operator => zum Einsatz.

<?php
$color = array("red" => "FF0000", "green" => "00FF00", "blue" => "0000FF", "black" => "000000");
echo $color["blue"]; // liefert 0000FF
?>

Assoziatives Array in einer foreach-Schleife ausgeben

<?php
$person = array("vorname" => "Adi", "nachname" => "Prinz", "age" => 60);

foreach($person as $x => $x_value) {
    echo "Key = " . $x . ", Value = " . $x_value;
    echo "<br>";
}
?>

Mehrdimensionale Arrays

Die Elemente eines Arrays können nicht nur Werte einfacher Datentypen (Zahlen, Strings, boolesche Werte), sondern auch Objekte oder andere Arrays sein. Letzteres eröffnet einige interessante Möglichkeiten.

<?php
// indiziert
$kunden = array(
  array("Adi","Prinz"),
  array("Gabi","Müller"),
  array("Harald","Maier")
);
echo $kunden[0][1]; // liefert Prinz

// indiziert & assoziativ
echo "<br>";
$firma = array(
  "chef" => array("Adi","Prinz"),
  "chefin" => array("Gabi","Müller")
);
echo $firma["chefin"][1]; // liefert Müller

// assoziativ
echo "<br>";
$firma = array(
  "chef" => array("vorname" => "Adi", "nachname" => "Prinz"),
  "chefin" => array("vorname" => "Gabi", "nachname" => "Müller")
);
echo $firma["chefin"]["vorname"]; // liefert Gabi
?>

Arrays in lesbarer Form ausgeben

Für Testzwecke ist es oftmals notwendig, alle Array-Einträge in lesbarer Form auszugeben. PHP bietet dafür u.A. zwei Funktionen an, idealerweise im pre-Element von HTML.

  • print_r()
  • var_dump()
<?php
$firma = array(
  "chef" => array("Adi","Prinz"),
  "chefin" => array("Gabi","Müller")
);
echo "<pre>";
print_r($firma);
echo "<br>";
var_dump($firma);
echo "</pre>";
?>

Array Löschen

Die Zuweisung einer leere Zeichenkette löscht zwar sämtliche Einträge des Arrays, das Array selbst existiert jedoch immer noch.

<?php
$firma = array(
  "chef" => array("Adi","Prinz"),
  "chefin" => array("Gabi","Müller")
);

$firma = array();
?>

Um ein Array völlig zu löschen, verwenden Sie unset().

<?php
$firma = array(
  "chef" => array("Adi","Prinz"),
  "chefin" => array("Gabi","Müller")
);

unset($firma);
?>

Array Funktionen

Hier ist ein kleiner Auszug der Array Funktionen von PHP:

  • array_unshift() / Array-Elemente anfügen
  • sort() / sortiert ein Array
  • ksort() / sortiert ein Array
  • list() / Elemente als Variablen
  • count() / Elemente Anzahl

array_unshift()

Fügt ein oder mehr Elemente am Anfang eines Arrays ein. Der erste Parameter der Funktion definiert die Array-Variable, weitere Parameter definierne die neuen Elemente.

<?php
$x = array("red", "green");
array_unshift($x, "blue", "yellow");
print $x[0]; // liefert blue
?>

sort()

Sortiert ein indiziertes Array nach einem optionalen Sortiertyp im zweiten Parameter. Achtung, alle vorher definierten Indizien gehen verloren.

<?php
$x = array("red", "green", "blue", "black");
sort($x, SORT_STRING);
print $x[0]; // liefert blue
?>

ksort()

Sortiert ein assoziatives Array nach Schlüsseln und einem optionalen Sortiertyp im zweiten Parameter.

<?php
$x = array("red" => "FF0000", "green" => "00FF00", "blue" => "0000FF", "black" => "000000");
ksort($x, SORT_STRING);
echo "<pre>";
foreach ($x as $key => $val) {
    echo "$key = $val\n";
}
echo "</pre>";
?>

list()

Weist Variablen zu, als wären sie ein Array. Die Parameter in der list()-Funktion übernehmen die Werte des Arrays $x.

<?php
$x = array('Adi', 'Prinz', 'Bad Hofgastein');
list($firstName, $lastName, $homeTown) = $x;
echo $homeTown; // liefert Bad Hofgastein
?>

count()

Liefert die Anzahl der Elemente eines Arrays.

<?php
$x = array('Adi', 'Prinz', 'Bad Hofgastein');
echo count($x); // liefert 3
?>

NULL

Der spezielle Wert NULL repräsentiert eine Variable ohne Wert. NULL ist der einzig mögliche Wert des Typs null. Eine Variable gilt als vom Typ null wenn:

<?php
$vorname = "";
$vorname == NULL ? print("Vorname ist NULL") : print ("Vorname ist nicht NULL");
// Ausgabe Vorname ist NULL
?>

Der Wert NULL kann in verschiedenen Situationen verwendet werden. Hier einige Beispiele für derartige Situationen:

Ressourcen

Als Ressourcen werden spezielle Variablen, die eine Referenz zu einer externen Ressource herstellen, bezeichnet. Ressourcen werden mit Hilfe spezieller Funktionen erzeugt und genutzt. PHP kennt unzählige Erweiterungen (Resourcen), in diesem Skript werden wir ausschließlich Datenbank- und Grafikerweiterungern kennenlernen.

Liste der Ressourcen in PHP

php.net

Objekte

Objekte haben etwas mit objektorientierter Programmierung in PHP zu tun. Diesem Thema habe ich ein eigenes Kapitel gewidmet.
siehe: OOP.