Diese Seite schaut viel besser in einem Browser aus, der Web-Standards unterstützt, die Seite ist aber für jeden Browser geeignet. Trotzdem empfehle ich den Download z.B. des Firefox, Opera oder Internet Explorers.
Dieser Abschnitt soll keine komplette Anleitung zum Erlernen von PHP sein.
Da kann ich nur auf das PHP-Handbuch verweisen.
Dieser Text dient mir lediglich als Grundlage, mich der Programmierung in PHP zu nähern.
Eine kleine Referenz, um meine ersten Schritte bis zur Erstellung meiner ersten Projekte zu dokumentieren.
PHP-Behle werden innerhalb eines HTML-Dokumentes folgendermaßen eingeleitet:
<?php
PHP-Anweisung(en);
?>
Um z.B. die Anweisung "Hallo Welt" auszuführen, muss eingegeben werden
<?php
echo ("Hallo Welt");
?>
Hier zur Kontrolle: Hallo Welt
Ein weiterer netter Befehl für den Anfang ist der Befehl phpinfo();, der genauso in die PHP-Tags eingebettet wird: PHP_Info.
Wie zu sehen ist, listet er die Server-Einstellungen des PHP-Moduls vollständig auf. So kann man erkennen, welche Module beim Server aktiviert sind.
Die erste Möglichkeit über PHP Variablen als Platzhalter für z.B. Namen (Strings) auszugeben, erfolgt über die Definition dieser.
Die Definition einer Variablen erfolgt mit dem Dollarzeichen ($).
$name = "Hartmut"; weist also der Variablen $name das Textstring "Hartmut" zu. Die Ausgabe erfolgt dann über den echo-Befehl (echo $name;)
Beispiel:
Mein Name ist Hartmut und ich wünsche viel Spaß auf meiner Webseite.
Mit freundlichen Grüßen Hartmut
Innerhalb einer PHP-Anweisung können beliebig viele Variablen definiert werden, dabei ist zu beachten, dass diese Variablen sog. case sensitiv sind, d.h. auf Groß- und Kleinschreibung muss geachtet werden: $Name = Hartmut wäre also eine vollkommen neue Variable. Leerzeichen und Umlaute innerhalb einer Variablen-Definition sind nicht erlaubt. Zahlen und Unterstriche "_" sind dagegen okay.
Ein gutes Beispiel für das Arbeiten mit Variablen ist das Rechnen mit Ihnen. Als Beispiel dient hier die Flächenberechnung eines Rechtecks.
Zunächst sollen einige Variablen definiert werden:
$a = 5;
$b = 25;
$einheit = "km";
$flaeche = $a * $b;
$umfang = ( 2 * $a ) + ( 2 * $b );
Die Ausgabe wäre dann:
Die Seitenlänge A des Rechtecks beträgt: <?php echo $a; ?> <?php echo $einheit; ?> und die Seitenlänge B des Rechtecks beträgt: <?php echo $b; ?> <?php echo $einheit; ?>
Die Fläche ist dann: <? echo $flaeche . "q" . $einheit; ?> und der Umfang beträgt: <?php echo $umfang . $einheit; ?>.
Und so sieht es jetzt in der Ausgabe aus:
Die Seitenlänge A des Rechtecks beträgt: 5 km und die Seitenlänge B des Rechtecks beträgt: 25 km.
Die Fläche ist dann: 125qkm und der Umfang beträgt: 60km.
Das obige Skript zeigt auch, wie man mit arithmetischen Operatoren umgeht: * bedeutet Multiplikation, - bedeutet Minus, + bedeutet Addition und / bedeutet Division. Zu beachten ist hierbei das Zeichen =, weil es zunächst einmal für eine Zuweisung von Variablen steht.
Desweiteren ist zubeachten, dass Punktrechnung vor Strichrechnung geht.
Um mehrere Strings miteinander zu verknüpfen können entweder mehrere php-Befehle aufeinander folgen oder die einzelnen Befehle werden mit einem . zusammengefügt. Auch ein normaler Textstring kann zwischen die Variablen gestzt werden, dieser ist dann aber in Anführungszeichen zu setzen.
Ein weiterer arithmetischer Operator ist der Restwertoperator, der Modulo, dieser wird mit einem % ausgewisen. Hier ein kleines Beispiel:
$zahl1 = 19;
$zahl2 = 7;
$rest = $zahl1 % $zahl2;
sieht als Anzeige dann so aus: Wenn man die Zahl 19 durch die Zahl 7 teilt bleibt ein Rest von 5.
Spezielle Zuweisungsoperatoren:
Die Anweisung Addiere zur Zahl 10 hinzu, kann mit der Anweisung $zahl = $zahl + 1; ausgegeben werden. Verkürzter kann die Ausgabe aber auch so erfolgen: $zahl +=;. Besonders in Schleifen gibt es aber auch diese Möglichkeit: $zahl++; zu benutzen. Analagon funktioniert das ganze auch mit Minus "-".
Datentypen
Mit dem Befehl gettype( $variable ); kann man den Datentyp einer Variablen auslesen, mit dem Befehl settype kann man ihn verändern.
Datentypen sind z.B. string (Textwerte), integer (Gannzahlen), double (Fließkommazahlen) und boolean (boolsche Werte wie TRUE oder FALSE).
Die Befehle gettype oder settype sind sog. Funktionen, die fest im PHP-Interpreter vorhanden sind.
Konstanten
Um der Gefahr vorzubeugen, Variablenwerte später in einem längeren Skript versehentlich zu überschreiben, können Konstante definiert werden.
Ein kleines Beispiel: Es soll eine Berechnung mit einem festen Mehrwertsteuersatz ausgeführt werden. Statt die Mehrwertsteuer in einer Variablen zu definieren, wird diese als feste Konstante angegeben. So kann sie später nicht mehr durch neue Variablenwerte überschrieben werden.Eine Konstante wird mit der Funktion define aufgerufen und benötigt zwei Werte. Den Namen - wobei es sich eingebürgert hat, diesen in Großschreibweise zu benutzen und den Wert, den diese haben soll.
Das Skript sähe so aus:
$nettopreis = 5.00;
// $mwst = 16; // die Variablendefinition habe ich auskommentiert
define( "MWST", 16 );
$bruttopreis = $nettopreis * ( 1+ MWST /100);
Die Ausgabe wäre dann: Der Nettopreis beträgt <? echo $nettopreis; ?> €. Die MwSt. beträgt <? echo MWST; ?> %;
Damit ist der Bruttopreis <? echo $bruttopreis; ?> €
So siehts aus: Der Nettopreis beträgt 5 €. Die MwSt. beträgt 16 %; Damit ist der Bruttopreis 5.8 €.
if-else-Abfrage
Mit dieser Anweisung können innerhalb des PHP-Codes Verzweigungen vorgenommen werden, um z.B. verschiedene Bedingungen abzufragen. Z.B. ist der Kunde männlich oder weiblich und so gezielt die richtige Ausgabe herbeiführen:
<?php
$anrede = "Herr";
$name = "Müller";
if ( $anrede == "Frau" )
{
echo "Sehr geehrte Frau " . $name;
}
else
{
echo "Sehr geehrter Herr " . $name;
}
?>
Es wird also zunächst geprüft, ob die Variable $anrede == (Achtung, dies ist jetzt ein Vergleichsoperator! Bei nur einem = würde die Variable mit dem Textstring "Frau" überschrieben werden), wahr ist, d.h. TRUE und würde dann ausgeführt werden. Da sie das in diesem Falle nicht ist, springt das Skript an die Stelle else (FALSE) - oder wenn mehrere Bedingungen abgefragt werden an eine erneute if-Abfrage. Zu beachten ist, dass die Anweisungen innerhalb der Abfragen in geschweiften Klammern "{" zu Beginn und "}" zum Ende zu stehen haben.
Eine Abfrage einer weiteren Bedingung innerhalb der if-else-Anweisung erfolgt über eine elseif-Abfrage. Um das obige Beispiel zu erweitern, soll ein Bekannter, der keine Anrede in der Variablen $name hat, persönlich mit seinem Vornamen begrüßt werden. Es wird also eine weitere Variable eingeführt:
<?php
$anrede = "";
$vorname = "Klaus";
$name = "Müller";
if ( $anrede == "Frau" )
{
// Der Kunde ist weiblich
echo "Sehr geehrte Frau " . $name;
}
elseif ( $anrede == "" )
{
// Die Anrede ist leer, also ist es ein Bekannter, d.h. in diesem Falle würde diese Anweisung ausgeführt werden
echo "Hallo " . $vorname;
}
else
{
// Der Kunde ist männlich
echo "Sehr geehrter Herr " . $name;
}
?>
switch-case-Abfrage
Eine weitere Möglichkeit, verschiedene Fälle (case) abzufragen, ist diese Anweisung. Als kleines Beispiel soll einem Kunden bei einem bestimmten Umsatz eine Prämie zugeschickt werden. Dazu werden zwei Variablen definiert. Einmal der Umsatz und einmal die Prämie mit einer Nummer.
<?php
$umsatz = 15000;
$praemie = 6; // 1-4 sind möglich
?>
da Sie im letzten Jahre einen Umsatz von <?php echo $umsatz; ?> € gemacht haben,
haben wir für Sie folgende Prämie ausgewählt:
<?php
switch( $praemie )
{
case 1:
echo "Einen modernen erdgasbetriebenen Kugelschreiber";
break;
case 2:
echo "Einen singenden Wecker";
break;
case 3:
echo " Einen Gutschein über eine Baggerfahrt durch den Westerwald";
break;
case 4:
echo "Eine Musik-CD Ihrer Wahl";
break;
default:
echo " Bitte melden Sie sich persönlich!";
}
?>
Wichtig ist, damit der PHP-Interpreter weiß, dass bei einem eingetretenen Fall (case) die Anweisung beendet ist, der break;-Befehl. Damit wird das PHP-Skript angewiesen, an das Ende der geschweiften Klammer zu springen und die switch-case-Abfrage zu beenden.
Wichtig ist auch eine Anweisung, die einen Befehl ausgibt, wenn keine der vorherigen Bedingungen erfüllt wurde. Dies erfolgt mit dem default-Befehl, der als Abschluß immer dastehen sollte.
Vergleichsoperatoren
Es gibt verschiedene Operatoren, um zwei Variablen zu vergleichen:
<?php
if ( $zahl1 < $zahl2 ) {
echo "z1 kleiner z2"; }
if ( $zahl1 >= $zahl2 ) {
echo "z1 größer oder gleich z2"; }
if ( $zahl1 != $zahl2 ) {
echo "z1 ist nicht gleich z2"; }
if ( $zahl1 === $zahl2 ) {
echo "z1 ist identisch (hier werden nicht nur die Werte sondern auch die Datentypen verglichen) z2"; }
?>
Zusammengesetzte Abfragen
Wieder ein konkretes Beispiel. Ein Kunde soll bei einem bestimmten Umsatz jeweils mit einer anderen Anrede angesprochen werden, also z.B. bei einem Umsatz unter 1000 Euro als Kunde, bei einem Umsatz von 1000 Euro bis zu einem Umsatz von 5000 Euro als *-Kunde usw.
Das Skript sähe so aus:
<?php
// Umsatzgrenze
$grenze1 = 1000;
$grenze2 = 5000;
$grenze3 = 10000;
// Kundenumsatz
$umsatz = 5000;
?>
Sehr geehrter
<?php
if ( $umsatz < $grenze1 )
{
echo "Kunde";
}
if ( ($umsatz >= $grenze1) && ($umsatz < $grenze2) )
{
echo "* Kunde";
}
if ( ( $umsatz >= $grenze2) && ( $umsatz < $grenze3) )
{
echo "** Kunde";
}
if ( $umsatz >= $grenze3 )
{
echo "*** Kunde";
}
?>
geführt.
Es werden also zwei Abfragen mit zwei && verknüpft. Sollen nur eine (oder beide Abfragen zutreffen, so wird dies mit zwei senkrechten Strichen "||" abgefragt. Soll entweder nur die eine oder die andere Abfrage, aber niemals beide Abfragen zutreffen, benutzt man den Befehl "xor".
while-Schleife
Mit der while-Schleife kann eine Ausgabe wiederholt werden, bis ein bestimmter Wert erreicht ist. Es müssen also wenigstens zwei Variablen definiert werden. Einmal die für die Anzahl der Durchläufe und die Variable für den Anfangswert. Diese sollte innerhalb der while-Schleife erhöht werden, da sonst die Bedingung für das Ende der Schleife niemals erfüllt wäre.
Beispiel:
<?php
$zaehler = 0;
$anzahl = 5;
while ( $zaehler <= $anzahl )
{
echo "Heute ist ein schöner Tag<br>";
// $zaehler = $zaehler +1;
$zaehler++;
}
?>
Hier wird also bei jedem Durchlauf die Variable $zaehler beginnend ab 0 um 1 erhöht bis der Wert 5 erreicht ist. Das bedeutet, die Ausgabe wird 6mal durchlaufen und dann beendet.
do-while-Schleife
Im Gegensatz zur while-Schleife, die ausgeführt wird, wenn eine Bedingung erfüllt ist, wird bei der do-while-Schleife zunächst eine Bedingung ausgeführt und diese dann solange wiederholt, bis sie nicht mehr erfüllt ist. Bei dieser Schleifenform ist also mindestens ein Durchlauf nötig bis geprüft wird, ob eine Bedingung erfüllt ist.
Ein Beispiel:
<?php
$zahl = 1234;
$teiler = $zahl;
$rest = 0;
do
{
$teiler--; // $teiler = $teiler - 1
// echo "Teiler: " . $teiler . "<br>";
$rest = $zahl % $teiler;
}
while ( $rest != 0 )
?>
Dieses Srkipt sucht den größten ganzzahligen Teiler der Zahl <?php echo $zahl; ?>. Diese heißt: <?php echo $teiler; ?>
Zunächst werden also die Variablen definiert. In diesem Fall soll also der größtmögliche ganzzahlige Teiler des Wertes 1234 gesucht werden. Um eine undefinierte Variable auszuschließen, wird noch $rest der Wert 0 zugeschrieben. Innerhalb der do-Schleife wird zunächst vom Teiler der Wert 1 abgezogen, weil eine Zahl, die durch selbst geteilt in jedem Falle immer der größtmögliche Teiler wäre. Bei jedem weiteren Druchlauf wird dann der Teiler um 1 verringert. Mithilfe des modulo-Befehls werden dann ausschließlich die ganzzahligen Restwerte bestimmt. Die Schleife wird solange ausgeführt, wie der Wert Rest ungleich 0 ist. Bei der Ausgabe wird dann die der Variable $teiler zuletzt zugewiesene Zahl angezeigt.
for-Schleife
Ein weiterer Schleifentyp ist die for-Schleife. Ihre Syntax ist:
for ( ; ; ) {
}
In den runden Klammern stehen die Parameter für die Schleife, in den geschweiften der Code, z.B. der Befehl
echo "Bin in der Schleife";
Dann würde in das aktuelle HTML-Dokument bei jedem Schleifendurchlauf Bin in der Schleife geschrieben werden.
Die for-Schleife benötigt drei Parameter, die mit Semikolons getrennt in der runden Klammer angegeben werden:
Nach jedem Schleifendurchlauf wird der nächste Schritt ausgeführt und geprüft, ob die Bedingung noch erfüllt ist. Wenn das der Fall ist, wird der Code erneut ausgeführt, sonst nicht.
Ist z.B. for( $zaehler = 1; $zaehler <= 25; $zaehler += 2 ) definiert, beginnt der Schleifendurchlauf mit dem Wert 1 der Variablen $zaehler.
Nach dem Durchlauf wird i um 2 erhöht, anschließend geprüft, ob die Bedingung $zaehler <= 25 erfüllt ist, und der Code ausgeführt, bis $zaehler den Wert 25 erreicht. Es gäbe also 13 Schleifendurchläufe ($zaehler=1,3,5,7,9,11,13,15,17,19,21,23,25).
break und continue
Sollen innerhalb einer Schleife bei einer bestimmten Bedingung (oder mehreren) andere Befehle ausgeführt werden, so bietet sich die Arbeit mit dem continue-Befehl an. Zum obigen Beispiel:
for( $zaehler = 1; $zaehler <= 25; $zaehler += 2 )
{
if ( $zaehler == 10 || $zaehler == 20 )
{
continue;
}
echo "Schleifendurchlauf: " . $zaehler . "<br />";
}
In diesem Falle wird die schleife ausgeführt, es erfolgt aber keine Ausgabe, wenn der $zaehler den Wert 10 und den Wert 20 hat. dies ist sozusagen eine verkürzte Schreibweise, da ja auch mit einem if-else-Konstrukt innerhalb der Schleife der Wert abgefragt werden könnte.
Würde statt des continue-Befehls der break-Befehl benutzt, würde in diesem Falle die Schleife ab dem Erreichen des Variablenwertes $zaehler == 10 beendet und nach dem letzten } fortgesetzt werden, wenn noch weitere Anweisungen folgen würden.
Um immer wiederkehrende Funktionalitäten in Skripten zur Verfügung zu stellen, bedient man sich der Funktionen. Einmal definiert, kann man auf diese immer wieder zugreifen ohne den benötigten Code mehrfach zu schreiben. Funktionen werden normalerweise zu Beginn einer Webseite oder in einem externen Skript hinterlegt.
Ein kleines Beispiel:
<?php
function gruss( $Geschlecht, $Familiennamen ) {
if ( $Geschlecht == "Frau" ) {
echo "Sehr geehrte Frau " . $Familiennamen . "<br>";
}
else {
echo "Sehr geehrter Herr " . $Familiennamen . "<br>"; }
}
?>
Auch Funktionen werden in geschweiften Klammern definiert. Die obige Funktion soll eine wiederkehrende Begrüßung auf einer Seite definieren. Der Funktion gruss werden dabei zwei Werte, sogenannte Argumente übergeben, nämlich das Geschlecht und der Familienname.
Im eigentlichen Dokument-Text würde dann zum Aufruf der Funktion folgendes stehen:
<?php
$anrede = "Frau";
$name = "Müller";
gruss( $anrede, $name ); // gruss ( "Frau", "Müller" ) - genau so kommen jetzt die Variablen-Werte bei der Funktion an
$anrede = "Herr";
$name = "Schneider"; // Begrüßung des Kunden
gruss( $anrede, $name );
?>
Wie beim Aufruf der Funktion ersichtlich, müssen nicht die identischen Variablen übergeben werden, wichtig ist nur der Aufruf der Funktion mit der gleichen Anzahl von Parametern/Argumenten.
Gültigkeitswerte der Variablen
Zu beachten ist, dass innerhalb von Funktionen definierte Variablen ausserhalb der Funktion ihre Gültigkeit verlieren. Auch die Variablen (siehe obiges Beispiel) $anrede und $name, die beim Aufruf an die Funktion geswchickt wurden, sind innerhalb der Funktion nicht gültig, weil nur die Inhalte/Werte der Variablen an die Funktion übergeben wurden. Es sind reine lokale Variablen, die ausserhalb des Aufrufs nicht mehr gültig sind.
Möchte man, dass die Variablen ihre Gültigkeit nicht verlieren, also "global" gültig sind, benutzt man den Befehl global $anrede, $name; (mit Komma getrennt).
Defaultwerte
Bei der Definition von Funktionen ist auch die Möglichkeit gegeben, die Parameter mit voreingestellten Werten anzulegen. Ein Beispiel wäre, dass wir eine Funktion schreiben, die verschiedne Kontostände von Kunden ausgibt. Ist zwar der Name des Kontoinhabers bekannt, aber nicht sein Kontostand, müsste der Funktion ein Wert übergeben werden. Es kann aber bereits innerhalb der Funktion ein bestimmter Wert, z.B. 0 als Defaultwert definiert werden, so dass beim Aufruf dieser Wert weggelassen werden kann:
<?php
function kontoAnlegen( $Besitzer, $stand = 0 ) // Defaultwert des Kontostandes = 0
{
echo "Dem Kontoinhaber " . $Besitzer . " wurde ein Konto mit dem Stand " . $stand . " € angelegt<br>" ;
}
?>
Aufruf der Funktion
<?php
// Konten anlegen
kontoAnlegen("Franz Liszt", 200 );
kontoAnlegen("Heinz Schneider",1000);
kontoAnlegen("Lieschen Müller"); // hier ist kein Kontostand definiert, das Konto wird mit dem Wert 0 belegt, wie in der Funktion definiert wurde.
?>
Rückgabewerte
Da wie oben beschrieben, Variablen nur innerhalb der Funktion gültig sind, muss man sich entweder der Möglichkeit von global definierten Variablen bedienen oder man nutzt einmalig den Befehl return. Einmalig bedeutet, dass innerhalb einer Funktion die Rückgabe von Variablen nur ein einziges Mal funktioniert.
<?php
// Vorgaben für Variablen
$seite_a = 10;
$seite_b = 11;
function umfangRechteck( $a, $b )
{
$umfang = 2 * $a + 2 * $b;
return $umfang; // mit return wird dafür gesorgt, dass die Werte einmalig ausserhalb der Funktion genutzt werden können
}
function flaecheRechteck( $a, $b) // eine weitere Funktion
{
return $a * $b; // Kurzschreibweise, ohne eine neue Variable zu definieren.
}
?>
Aufruf der Funktion
Folgende Seitenlängen für das Rechteck sind gegeben:<br>
Seite A: <?php echo $seite_a; ?> und Seite B: <?php echo $seite_b; ?>
Ergebnisse der Berechnungen
<p>Die Fläche beträgt: <?php echo flaecheRechteck( $seite_a, $seite_b); ?>, der Umfang beträgt
<?php
$u = umfangRechteck( $seite_a, $seite_b );
echo $u;
?>
So sieht es in der Ausgabe aus:
Folgende Seitenlängen für das Rechteck sind gegeben:
Seite A: 10 und Seite B: 11
Ergebnisse der Berechnungen
Die Fläche beträgt: 110, der Umfang beträgt
42
Referenzen
Um innerhalb einer Funktion den wert einer definierten Variablen zu nutzen, kann man diese entweder innerhalb oder beim Funktionsaufruf mit einer Referenz belegen. Das funktioniert mit einem kaufmännischen und - "&". So wird nicht der Variablenwert sondern der Speicherplatz der Variablen genutzt.
Beispiel
<?php
function doSomething( &$doVariable )
{
$doVariable .= " angehängt ";
}
$meineVariable = "Hallo Welt";
doSomething( $meineVariable );
echo "Meine Variable hat den Wert: " . $meineVariable;
? >
Das & kann entweder innerhalb der Funktion übergeben werden oder aber beim Funktionsaufruf &$meineVariable.
Das Schlüsselwort 'static'
Da nach Abarbeitung eines Funktionsaufrufs die definierten Variablen verfallen, können diese in der Regel nicht mehr verwendet werden.
Ein Beispiel:
<?php
function zaehler()
{
static $zaehler = 0;
$zaehler++;
echo "Ich wurde schon " . $zaehler . "-mal aufgerufen<br>";
}
?>
Aufruf der Funktion
<?php
zaehler();
zaehler();
?>
Das obige Skript soll mitteilen, wie oft eine Funktion bereits aufgerufen wurde. Ohne den Befehl static würde beim Aufruf die Zähler-Variable $zaehler um 1 erhöht werden und die Ausgabe 1-mal aufgerufen würde angezeigt werden. Bei einem erneuten Aufruf der Funktion wäre aber die Variable nicht mehr vorhanden, so dass wieder die gleiche Anzeige erscheinen würde. Mit dem static-Befehl wird aber der Inhalt der Variablen in den Speicher geschrieben (gemerkt) und wird bei einem zweiten Aufruf den Wert 1 haben und sich auf den Wert 2 addieren.