PHP – Grundlagen

Daniel Höfer
Programmieren – PHP

• PHP – PHP: Hypertext Preprocessor
• Entwickelt von: PHP Group
• Aktuelle Version: 5.3.0
• Webpräsenz: http://www.php.net

• Skriptsprache für Webentwicklung
• Skript wird von Server interpretiert und
abgearbeitet. Ergebnis wird an den Client
geschickt und dort interpretiert (IE, FF, …)
• Dateiendung: .php
• Grundlegend ist Syntax mit C / C++
vergleichbar

Anfrage: news.html
1. Client fordert Datei vom
Server an (z.B. news.html)

news.html
1. Client fordert Datei vom
Server an (z.B. news.html)
2. Server sucht Datei und
übermittelt den Inhalt an den
Client
Apache Webserver

1. Client fordert Datei vom
Server an (z.B. news.html)
2. Server sucht Datei und
übermittelt den Inhalt an den
Client
3. Client (Browser) interpretiert
HTML-Code aus news.html und
zeigt Inhalt an.
news.
html

Anfrage: news.php
1. Client fordert Datei vom
Server an (z.B. news.php)

news.php
1. Client fordert Datei vom
Server an (z.B. news.php)
2. Server sucht Datei und
interpretiert PHP Code (Skript
wird ausgeführt)

news.php
Generierter
HTML Code
PHP Interpreter
1. Client fordert Datei vom
Server an (z.B. news.php)
2. Server sucht Datei und
interpretiert PHP Code (Skript
wird ausgeführt)
3. Generierter HTML-Code der
PHP Datei wird anschließend an
den Client übermittelt
Apache Webserver

news.php
1. Client fordert Datei vom
Server an (z.B. news.php)
2. Server sucht Datei und
interpretiert PHP Code (Skript
wird ausgeführt)
3. Generierter HTML-Code der
PHP Datei wird anschließend an
den Client übermittelt
4. Client (Browser) interpretiert
HTML-Code aus news.html und
zeigt Inhalt an.
HTML
Code

• HTML
• Benötigt einen simplen Webserver
▪ z.B.: Apache, IIS, …
• HTML Dateien werden nur übermittelt
• PHP
• Benötigt einen simplen Webserver und den PHP
Interpreter.
• PHP-Anbindung für alle gängigen Webserver.

• PHP
• Installation der einzelnen Komponenten erfordert
extra Konfiguration.
• Lösung: Gesamtpacket XAMPP
▪ Wird von „Apache Friends“ bereitgestellt
▪ Beinhaltet unter anderem
▪ Apache Webserver
▪ PHP Interpreter
▪ MySQL Datenbank
▪ Interface zur Administration dieser Komponenten

• PHP Dateien enden mit „.php“ und befinden
sich, wie HTML Dateien im Webverzeichnis
des Webservers.
• In einer PHP Datei kann sich
• PHP Code
• HTML Code
befinden

• PHP Code wird mit „“ abgeschlossen.
• PHP Bereiche können beliebig oft in einer
PHP Datei vorkommen.
• Text außerhalb eine PHP Bereichs wird als
Text bzw. HTML interpretiert.

• Beispiel (reine Textausgabe)
echo „Hello World!“;

• Testen der PHP-Installation
• Ausgabe: Detaillierte Informationen über die PHP
Installation und alle aktivierten Module
phpinfo();

• Beginn einer Variable mit einem
Dollarzeichen ($)
• Anschließend zwingend ein Buchstabe oder „_“
• Bei der Definition werden keine Datentypen
angegeben.
• Typ wird anhand der Variablenzuweisung
bestimmt.

• Groß-Kleinschreibung wird beachtet
• $var und $vAr sind unterschiedliche Variablen
• unset() – Löschen einer Variablenbelegung
• isset()
– Prüft, ob die Variable belegt ist

• Variablentypen
Datentyp
Beispiel / Beschreibung
String
„a“, „bla“, „Test test“
Integer 1, 2, 500
Float / Double
1.5, 20.0, 17e2
Boolean
frue, false
Array
Mehrwertiger Datentyp
Object
Mehrwertiger Datentyp
Resource
Referenz auf externe Quellen
Null
Typ ohne Wert

• Variablentypen
Datentyp Konvertierung Prüfung
String (string) is_string
Integer (int) is_int, is_integer
Float / Double (float), (double) is_float, is_double
Boolean (bool), (boolean) is_bool
Array (array) is_array
Object (object) is_object
Null - is_null

• Operatoren mit Variablen
• Zuweisung einer Variable (by Value)
▪ $var = 10;
$var2 = $var;
$var2 = 20;
Zuweisung des Wertes 10 auf $var2
▪ $var hat den Wert 10, $var2 hat den Wert 20

• Operatoren mit Variablen
• Zuweisung einer Variable (by Reference)
▪ $var = 10;
$var2 = &$var;
$var2 = 20;
& signalisiert Zuweisung by Reference
Zuweisung der Adresse von $var auf
$var2. $var2 „zeigt“ auf $var
▪ $var hat den Wert 20, $var2 hat den Wert 20

• Operatoren mit Variablen
• Doppeltes $ Zeichen
▪ Variable wird ausgewertet und Wert der Variable als
tatsächlicher Variablennamen herangezogen.
▪ Beispiel
▪ $gehalt = 1000;
$variable = „gehalt“;
echo $$variable;
$$variable
„gehalt“
$variable hat den Wert „gehalt“
▪ Ergebnis: Es wird „1000“ ausgegeben

• Operatoren mit Variablen
• Funktionsaufruf aus Variablen
▪ $wert = „hallo“;
$funktion = „strlen“;
echo $funktion($wert);
Wird übersetzt in strlen(„hallo“);
und mit echo ausgegeben.
▪ Es wird die Funktion strlen(„hallo“) aufgerufen. Diese
gibt den Wert „5“ aus.

• Strings
• sind Zeichenketten
• String werden mit einem Punkt (.)
zusammengefügt
• $var = „Hallo“.“wie“.“gehts“;
• Zeichenkette mit „“ oder ‚‘ definieren
• $var = „Hallo“;
$var2 = ‚Hallo‘;
// = „Hallowiegehts“

• Zeichenkette mit „“ oder ‚‘ definieren
• $var = „Hallo“;
$var2 = ‚Hallo‘;
• Unterschied
▪ Passende Werte innerhalb von „“ werden aufgelöst.
▪ Werte innerhalb von ‚‘ werden nicht aufgelöst
▪ $a = „Test“;
echo „Das ist eine $a-Variable“;
▪ Ergebnis: „Das ist eine Test-Variable“

• Stringfunktionen
• string ltrim(string $str);
• string rtrim(string $str);
• string trim(string $str);
• string substr(string $str, int $start [,int $len]);
• string str_replace(string $alt, string $neu, string $str);
• string strpos(string $str, string $suche [, int $startpos]);
• string strstr(string $str, string $suche);
• …

• Integer
• Gängige Operationen
▪ +
Addieren
▪ -
Subtrahieren
▪ *
Multiplizieren
▪ /
Dividieren
▪ %
Modulo
▪ ++
Inkrement
▪ --
Dekrement
▪ +=, -=, /=, *=, … Operation und Zuweisung in einem
▪ …

• Float / Double
• Definition durch einen Punkt (.) als Kommastrich
▪ $var = 100.25;
• Rundungsfunktionen
▪ floor()
Abrunden
▪ ceil()
Aufrunden
▪ round()
Runden

• Boolean
• Kann zwei gültige Werte annehmen
▪ true
▪ false
• Operatoren
▪ == Vergleich ob der Wert identisch ist
▪ === Vergleich ob die Operatoren den gleichen Typ
haben.
▪ Logische Operatoren: || (or), && (and), xor, ! (not)

• Boolean (Beispiel)
• $var = 10;
$str = ‚10‘;
$var == $str; // Ausdruck liefert den Wert true
$var === $str; // Ausdruck liefert den Wert false

• Array
• Sind Objekte, die mehrere Elemente beinhalten
können.
• Elemente können durch einen eindeutigen Namen
(assoziatives Array) oder durch eine Nummer
(nummerisches Array) identifiziert werden.

• Array
• Array anlegen
$arr = array(); // Erzeugt ein leeres Array
$arr = array(10, 20, 30); // Erzeugt Array mit {10, 20, 30}
• Array befüllen
$arr[10] = „Hallo“;
// Befüllt Arrayindex 10 mit dem
// Wert „Hallo“
$arr[] = „wie geht’s?“; // Erzeugt neuen Arrayindex und
// befüllt ihn mit „wie geht‘s?“

• Array
• Assoziatives Array anlegen
$arr = array(„stadt“ => „Wien“, „plz“ => „1010“);
• Ausgabe aller Arrayelemente
print_r($arr);
• Abfrage aus einem Array
$arr[„stadt“]
// Liefert den Wert „Wien“

• Array sortieren
• sort(array $arry [,$sortierTyp])
▪ Normale Sortierung der Werte
▪ Schlüssel werden nicht behandelt
• asort(array $arry [,$sortierTyp])
▪ Sortiertung mit Bezug auf Werte und Schlüssel
• ksort(array $arry [,$sortierTyp])
▪ Sortierung mit Bezug auf den Schlüssel
• rsort(array $arry [,$sortierTyp])
▪ Inverse Sortierung der Werte
▪ Schlüssel werden nicht behandelt

• Array sortieren
• Sortiertypen
▪ SORT_REGULAR
▪ Werte werden normal interpretiert
▪ SORT_NUMERIC
▪ Werte werden als Zahlen interpretiert
▪ SORT_STRING
▪ Werte werden als Zeichenketten interpretiert

• Array sortieren
$arr = array(„a“ => „Rapid“,
„b“ => „Salzburg“,
„c“ => „Austria“)
• sort($arr) liefert
(„0“ => „Austria“,
„1“ => „Rapid“,
„2“ => „Salzburg“)

• Array sortieren
$arr = array(„a“ => „Rapid“,
„b“ => „Salzburg“,
„c“ => „Austria“)
• asort($arr) liefert
(„c“ => „Austria“,
„a“ => „Rapid“,
„b“ => „Salzburg“)

• Array sortieren
$arr = array(„a“ => „Rapid“,
„b“ => „Salzburg“,
„c“ => „Austria“)
• ksort($arr) liefert
(„a“ => „Austria“,
„b“ => „Rapid“,
„c“ => „Salzburg“)

• Array sortieren
$arr = array(„a“ => „Rapid“,
„b“ => „Salzburg“,
„c“ => „Austria“)
• rsort($arr) liefert
(„0“ => „Salzburg“,
„1“ => „Rapid“,
„2“ => „Austria“)

• Arrayfunktionen
• Suche nach Werten in einem Array
bool in_array($suche, array $array [, bool $typ])
▪ Gibt true / false zurück (ob Wert vorhanden ist)
▪ Wenn $typ = true: Es wird typsicher geprüft (===)
mixed array_search($suche, array $array [,bool $typ])
▪ Gibt den Key des Wertes zurück falls vorhanden
▪ Gibt false zurück fall der Wert nicht vorhanden ist
▪ Wenn $typ = true: Es wird typsicher geprüft (===)
bool array_key_exists($gesucht, array $array)
▪ Gibt true / false zurück (ob Key vorhanden ist)

• Arrayfunktionen zur Zeigerbewegung
• Zeiger hält aktuelle Arrayposition
• Funktionen dazu
▪ current() Aktuelles Element im Array
▪ prev() Vorheriges Element
▪ next() Nächstes Element
▪ reset() Zurück zum ersten Element
▪ end() Zeiger auf die letzte Position setzen

• Arrayfunktionen für Stackoperationen
• Stack als Stapel von Elementen
• Zwei Funktionen
▪ int array_push(array $stack, mixed $var)
▪ mixed array_pop(array $stack)
• Push legt Element oben auf den Stapel
• Pop holt Element oben vom Stapel

• Objekte
• Objektorientiertes Sprachelement
• Objekte repräsentieren Elemente die vom
Programm abgebildet werden sollen
• …beinhalten Attribute
• …besitzen Funktionen

• Ressourcen
• Elemente aus externen Datenquellen
• z.B.:
▪ Dateien zum lesen / schreiben
▪ Ergebnisse von Datenbankabfragen

• NULL
• Variablen, denen kein Wert zugewiesen wurde
• Variablen, die mit unset() entladen wurden
• Funktion is_null($variable) prüft auf NULL

• Feste Werte im Programm
• Wert kann nur bei der Definition festgelegt
werden.
• Konstanten werden GROß geschrieben um
diese leichter zu identifizieren.
• Definition mit
define(„“, );
• z.B.
define(„VORWAHL“, „+43“);

• Konstante kann dann im Programm
verwendet werden.
• z.B.
$telefon = VORWAHL + „1234567“;
• Typ kann mit gettype();
abgefragt werden.

• // Kommentar
• für einzeilige Kommentare bis Zeilenende
• /* Kommentar */
• für mehrzeiligen Kommentar
• /** PHPDoc Kommentar */
• für mehrzeiligen PHPDoc Kommentar
• Beinhalten Parameter beginnend mit @
▪ @param
▪ @return
▪ @version
▪ …
Parameterbeschreibung einer Funktion
Returnwertbeschreibung
Versionsnummer

• Funktionen werden mit function definiert
function funktionsname($param1, $param2) {
// PHP Code
}
• return, wenn die Funktion einen Wert liefern soll
function addiere($param1, $param2) {
return $param1 + $param2;
}

• Globale Variablen in Funktionen verwenden
• In Funktion muss angegeben werden, welche
globale Funktion verwendet werden soll
▪ Schlüsselwort: global
Function piRechnung($param1) {
global $pi;
return $param1 * $pi;
}

• If - Konstrukt
if ($bedingung) {
// PHP Code
} elseif ($alternative) {
// PHP Code
} else {
}
// PHP Code

• If - Konstrukt
if ($bedingung) {
// PHP Code
} elseif ($alternative) {
// PHP Code
} else {
// PHP Code
}
Code wird ausgeführt, wenn
$bedingung den Wert true
liefert
Code wird ausgeführt, wenn
$bedingung nicht zutrifft
jedoch $alternative zutrifft
Wird ausgeführt, wenn
keine Bedingung zutrifft

• If - Konstrukt (alternative)
echo ($x == 10) ? „Ja“ : „Nein“;
Bedingung
Wert, wenn Bedingung True
Wert, wenn Bedingung False

• Switch - Konstrukt
• Entscheidung, wenn mehrere bestimmte Werte
geprüft werden müssen.
switch($variable) {
case ‚100‘: // Code für Wert ‚100‘
break;
case ‚200‘: // Code für Wert ‚200‘
break;
}

• Switch - Konstrukt
• break sorgt für Ende der Abarbeitung im Switch. Fehlt
der Break-Befehl, werden alle Befehle danach im
Switch noch ausgeführt. Kann auch gewollt sein:
switch($variable) {
case ‚100‘:
case ‚200‘: // Code für Wert ‚100‘ und Wert ‚200‘
break;
}

• Switch - Konstrukt
• default wird verwendet, wenn kein Wert im Switch
zutrifft.
switch($variable) {
case ‚100‘: // PHP Code
break;
default: // Wird ausgeführt wenn $variable != ‚100‘
}

• While - Schleife
• Schleife, die so oft wiederholte wird, wie die
Bedingung zutrifft.
while ($bedingung) {
}
// PHP Code

• Do-While - Schleife
• Schleife, die so oft wiederholte wird, wie die
Bedingung zutrifft. Die Bedingung wird jedoch
erst am Ende geprüft.
• Inhalt der Schleife wird min. einmal durchlaufen
do {
// PHP Code
} while ($bedingung)

• For - Schleife
for(startanweisung; laufbedingung; schlussbefehl) {
// PHP Code
}
• Beispiel
for($x = 1; $x < 10; $x++) {
echo „Aktueller Wert von x = „.$x;
}

• For - Schleife
for(startanweisung; laufbedingung; schlussbefehl) {
// PHP Code
}
• Beispiel
for($x = 1; $x < 10; $x++) {
echo „Aktueller Wert von x = „.$x;
}

• For-Each - Schleife
• Schleife für iterierbare Elemente (z.B.: Array)
$arr = array();
$arr[‚ab‘] = „Erster Eintrag“;
$arr[‚cd‘] = „Zweiter Eintrag“;
foreach($arr as $key => $value) {
echo „Element $key mit Wert $value“;
}

• Sind Arrays, die Daten von PHP bzw. über den
Webserver beinhalten und somit dem Programmierer
zugänglich gemacht werden.
• Arten
• Arrays mit Daten über den Webserver / PHP
• Arrays mit Daten über Benutzereingaben
• Beginnen immer mit $_
• $_POST
• $_GET
• …

• $_POST Array
• Liefert Inhalte, die mittels POST übertragen
werden (z.B. aus einem HTML Formular).
• Wenn es z.B. das Formularfeld „name“ gibt, wird
dieses mit $_POST[‚name‘] ausgelesen.
• $_GET Array
• Wie beim $_POST Array, nur bei der GET
Anweisung.

• $_FILES
• Beinhaltet Informationen über alle Dateien, die
auf den Server hochgeladen wurden.
• Jedes Arrayelement beinhaltet die Informationen
▪ name
▪ type
▪ tmp_name
▪ error
▪ size
Name der Datei
Mime-Type
Temporärer Name auf dem Server
Fehlercode
Größe der Datei in Byte

• $_FILES
• Beispielausgabe mittels print_r($_FILES)
Array
(
[uploadFile] => Array
(
[name] => datei.txt
[type] => text/plain
[tmp_name] => C:\xampp\tmp\php102.tmp
[error] => 0
[size] => 102
)
)

• $_REQUEST
• Sammelarray für Benutzereingaben / Werte
• Beinhaltet unter anderem Werte aus den Arrays
▪ $_POST
▪ $_GET
▪ $_COOKIE

• $_COOKIE
• Cookies
▪ sind kleine Informationsspeicher auf dem Client
▪ haben eine bestimmte Lebensdauer.
• Anwendungsbeispiele
▪ Speichern von Kundendaten
▪ Session ID speichern
▪ Einkaufswagen im Onlineshop
▪ …
• $_COOKE[‚Keksname‘] liefert entsprechendes Cookie

• $_SESSION
• Eine Session wird beim Start des Clients (Browser)
angelegt und identifiziert diesen eindeutig.
• Anwendungsgebiete
▪ Übergabe von Informationen zwischen PHP Skripts auf
einer Webseite.
▪ Anmeldung als User über eine bestimmte Zeit.
▪ …
• Mit $_SESSION[‚session-id‘] kann der Inhalt der
Session mit der ID ‚session-id‘ abgerufen werden.

• $_SERVER
• Enthält Informationen über den HTTP Header der aktuellen
Anfrage, sowie lokale Pfade des Betriebssystems und Skriptes.
• Wichtige Einträge
• $_SERVER[‚DOCUMENT_ROOT‘]
▪ Webverzeichnis
• $_SERVER[‚PHP_SELF‘]
▪ Relativer Pfad im Webverzeichnis
• $_SERVER[‚HTTP_USER_AGENT‘]
▪ Enthält Identifier über verwendeten Browser
• $_SERVER[‚HTTP_REFERER‘]
▪ Enthält letzte Website, wenn verlinkt. Sonst leer

• $GLOBALS
• Enthält alle Referenzen aus den superglobalen
Arrays
• z.B.
▪ $GLOBALS[‚_POST‘][‚file‘]

• Unter anderem bei der Fehlersuche von
Interesse.
• __LINE__
▪ Aktuelle Zeilennummer
• __FILE__
▪ Aktueller Pfad des ausgeführten Skripts
• __FUNCTION__
▪ Aktuelle Funktion

• Skript kann jederzeit mit der Funktion
die($msg); beendet werden.
if($fehler) {
}
die(„Es ist ein Fehler in Zeile „.__LINE__.“
aufgetreten“);

• Callback zur Fehlerbehandlung
• Es kann eine Callback-Funktion registriert werden, die im
Fehlerfall aufgerufen wird.
• Ermöglicht eine individuelle Fehlerausgabe.
• Registrieren der Callbackfunktion
mixed set_error_handler($callback [, int $typ]);
• Callback – Signatur
funktionsname($fehlernr, $fehlertext [,$fehlerskript [, $fehlerzeile [,
array $fehlerkontext]]])

• Callback zur Fehlerbehandlung (Beispiel)

• PHP Skripte können andere Dateien zur
Laufzeit inkludieren.
• Mehrfach verwendeter Code kann so in eine Datei
ausgelagert werden.
• Externe Bibliotheken / Skripte müssen ebenfalls
auf diese Art eingebunden werden

• Inkludieren mit include(Datei)
• Sucht die Datei und liest den Code aus der Datei
an die Stelle der include Anweisung.
• Wenn ein Fehler beim inkludieren auftritt, wird
eine Warnung ausgegeben.
• Inkludieren mit require(Datei)
• Sucht die Datei und liest den Code aus der Datei
an die Stelle der require Anweisung.
• Wenn ein Fehler beim inkludieren auftritt, wird
das Skript mit einem Fehler abgebrochen.

• Problem
• Wenn include(‚DateiXY‘) öfters ausgeführt wird,
kann es z.B. passieren, dass eine Variable,
Funktion, Klasse öfters definiert wird => FEHLER
• Lösung:
• include_once(Datei);
• require_once(Datei);
• Funktion wie include bzw. require, nur wird eine
Datei bei mehrmaliger Ausführung nur einmal
inkludiert!