7) Weitere Befehle zur Ablaufkontrolle
In 6) (siehe Was ist PHP +1.Schritte) haben wir die erste Möglichkeit kennengelernt, eine Programm-Schleife zu erzeugen. Statt
$t = "Ich soll meine Uebungsaufgaben selbst erstellen!<BR>\n";
$i = 0;
while ($i<10) {
echo $t;
$i++;
}
kann man auch schreiben:
$t = "Ich soll meine Uebungsaufgaben selbst erstellen!<BR>\n";
$i = 0;
do {
echo $t;
$i++;
} while ($i<10);
Was ist der Unterschied?
Man bemerkt den Unterschied, wenn z.B. statt $i=0; zu Beginn $i=10; gesetzt wird. Im ersten Fall ist die Bedingung ($i<10) nicht wahr und die Befehle innerhalb der geschweiften Klammern werden nicht ausgeführt.
Im zweiten Fall werden zuerst die Befehle innerhalb der geschweiften Klammern ausgeführt, danach wird getestet, ob ($i<10). Dies ist nicht der Fall, also wird abgebrochen. D.h. aber, die Schleife wird mindestens einmal durchlaufen.
Eine weitere Möglichkeit, eine Schleife zu programmieren, ist der for-Befehl. Gleich ein Beispiel:
$t = "Ich soll meine Uebungsaufgaben selbst erstellen!<BR>\n";
for ($i=0;$i<10;$i++) {
echo $t;
}
Der for-Befehl besteht aus drei Ausdrücken.
for (ausdruck1;ausdruck2;ausdruck3) { ... }
Mit ausdruck1 wird die Schleife initialisiert, d.h. normalerweise wird die Variable, die die Schleifendurchläufe zählt, auf den Anfangswert gesetzt.
ausdruck2 gibt die Abbruchbedingung an.
In ausdruck3 wird die Variable, die die Schleifendurchläufe zählt, erhöht bzw. erniedrigt.
Der for-Befehl hat den Vorteil, daß alle zur Kontrolle der Schleife nötigen Befehle in einer Zeile stehen. Ein weiteres Beispiel, diesmal wird heruntergezählt.
$t = "Ich soll meine Uebungsaufgaben selbst erstellen!<BR>\n";
for ($i=10;$i>0;$i--) {
echo $t;
}
--------------------------------------------------------------------------------
8) Fallunterscheidungen
Zur Fallunterscheidung gibt es den if-Befehl:
if ($i<0) {
echo "$i ist kleiner als Null\n";
}
oder auch
if ($i<0) {
echo "$i ist kleiner als Null\n";
} else {
echo "$i ist nicht kleiner als Null\n";
}
Man kann diesen Befehl auch schachteln:
if ($i<0) {
echo "$i ist kleiner als Null\n";
} else if ($i>0) {
echo "$i ist groesser als Null\n";
} else {
echo "$i ist Null\n";
}
Hat man mehrere Tests der gleichen Variable, so kann man mit dem switch-Befehl evtl. Arbeit einsparen:
switch ($name) {
case "Heinrich":
echo "Ich bin der kluge Heinrich";
break;
case "Hans":
echo "Ich bin der dumme Hans";
break;
case "Agathe":
echo "Ich bin die Agathe und klüger als Heinrich und Hans";
break;
default:
echo "Wir sind der Rest";
}
Falls die Variable $name den Wert "Hans" hat, wird als nächster Befehl
echo "Ich bin der dumme Hans";
ausgeführt. Normalerweise würden dann alle nachfolgenden Befehle ausgeführt werden, u.a.
echo "Ich bin die Agathe und klüger als Heinrich und Hans";
Dies ist meist nicht erwünscht, man springt deshalb mit break aus dem switch-Befehl heraus.
--------------------------------------------------------------------------------
9) Weitere Vergleichsmöglichkeiten
Bisher konnten wir testen, ob $i<10 oder $i>10 gilt. Es gibt aber noch mehr Möglichkeiten:
$i==10: Ist $i gleich 10?
$i!=10: Ist $i ungleich 10?
$i>=10: Ist $i größer oder gleich 10?
$i<=10: Ist $i kleiner oder gleich 10?
Man kann auch kombinieren:
($i==10) && ($j>0): Ist $i gleich 10 und $j größer als 0?
($i==10) || ($j==0): Ist $i gleich 10 oder $j gleich 0?
--------------------------------------------------------------------------------
10) Nochmals vordefinierte Variablen
In 4) haben wir gelernt, daß in einer PHP-Datei, die aus einem Formular gestartet wird, die Namen der Formular-Elemente als Variablen zur Verfügung stehen. Dies kann man nützen, um Formular und Befehle, die das Formular behandeln, in eine einzige Datei zu schreiben:
Angenommen unsere Datei form.html enthält folgendes Formular:
<FORM ACTION="form.html" METHOD=POST>
<INPUT NAME="beliebigername">
<INPUT TYPE="submit">
</FORM>
Dann ruft sich beim Klicken auf submit die Datei selbst auf. Allerdings ist dann die Variable beliebigername beliebiger Name gesetzt. Dies können wir folgendermaßen ausnützen:
<?
if (isset($beliebigername)) {
echo "Sie haben $beliebigername eingegeben\n";
}
?>
<P>
<FORM ACTION="form.html" METHOD=POST>
<INPUT NAME="beliebigername">
<INPUT TYPE="submit">
</FORM>
Wird die Datei zum ersten Mal aufgerufen, d.h. ohne daß man auf den submit-Button klickt, so ist die Variable $beliebigername nicht gesetzt, der Ausdruck isset($beliebigername) ist also nicht wahr. Füllt man das Formular dann aus und klickt auf submit, so ist die Variable gesetzt, isset($beliebigername) ist wahr, und es wird "Sie haben $beliebigername eingegeben\n"; ausgegeben.
Will man danach abbrechen, so sollte der Befehl
exit;
verwendet werden.
--------------------------------------------------------------------------------
11) Dateien hinzuladen
Der Befehl
include("dateiname");
liest den Inhalt der Datei dateiname so, als ob er an dieser Stelle stehen würde. Damit kann z.B. einheitliches Layout bei einer größeren Anzahl von Dateien erreicht werden.
--------------------------------------------------------------------------------
12) Dateien lesen und schreiben
Wir wollen nun von Dateien, die auf dem Server liegen, lesen, bzw. in diese Dateien etwas hineinschreiben. Dies ist nützlich, um z.B. Zähler oder Gästebücher zu erzeugen.
Wichtig:
Aus Sicherheitsgründen ist der Webserver einem Benutzer auf dem Server-Computer zugeordnet, der sehr wenig Rechte hat. U.a. darf er nicht einfach in eine Datei in ihrem Verzeichnis schreiben. Genausowenig darf er eine Datei in Ihrem Verzeichnis erzeugen.
Leider ist es mit dem ftp-Programm, das mit dem ASS-Zugang der Uni Bayreuth zur Verfügung steht, nicht möglich die Zugriffsrechte zu ändern (jedenfalls weiß ich nicht wie).
Um z.B. eine Datei xxx zu erzeugen, in die der Webserver schreiben darf, müssen Sie telnet benutzen:
telnet starten
Rechner-Name btmdx1.mat.uni-bayreuth.de eingeben
Login: www
Danach das bekannte Password eingeben
Nun müssen folgende Befehle eingegeben werden, um in das Unterverzeichnis zu gelangen, indem Sie die Datei (sagen wir mit dem Namen xxx) abgelegt haben:
cd public_html
cd Name.Vorname (genau in der Schreibweise, wie es unter ftp zu sehen ist)
chmod a+r xxx
Verwenden Sie Windows 95 oder Windows NT, so kann man im ftp-Programm die Datei-Anwählen, auf die rechte Maustaste klicken und dann den Befehl chmod verwenden.
OK. Gehen wir davon aus, daß wir nun eine Datei mit dem Namen xxx haben, deren Inhalt wir lesen wollen.
Zuerst müssen wir die Datei öffnen, dabei muß angegeben werden, was mit der Datei geschehen soll: Wollen wir lesen, schreiben, anhängen,...
Der Befehl lautet
$datei = fopen("xxx","r");
Das heißt, wir öffnen die Datei mit dem Namen xxx und wollen darin lesen ("r"). Die technischen Details lassen wir dabei von der Variablen $datei regeln, d.h. wenn wir später aus der Datei lesen wollen, so benützen wir die Variable $datei.
Nun lesen wir zeilenweise den Inhalt der Datei, und zwar so lange, bis wir ans Ende der Datei gelangt sind:
while (!feof($datei)) {
$zeile = fgets($datei,1000);
echo $zeile;
}
feof($datei) ist wahr, sobald wir an das Datei-Ende gelangt sind. $zeile = fgets($datei,1000); liest maximal die nächsten 1000 Zeichen, hört aber auf, sobald eine neue Zeile beginnt, oder das Ende der Datei erreicht ist.
echo $zeile; gibt einfach das Gelesene wieder aus.
Schließlich muß die Datei noch geschlossen werden:
fclose($datei);
Folgende Möglichkeiten gibt es, eine Datei zu öffnen:
"r": nur lesen, begonnen wird am Dateianfang.
"r+": lesen und schreiben, begonnen wird am Dateianfang.
"w": nur schreiben. Existiert die Datei bereits, wird der bisherige Inhalt gelöscht. Existiert sie nicht, wird versucht. sie zu erzeugen.
"w+": lesen und schreiben. Ansonsten wie "w".
"a": nur schreiben. Begonnen wird am Ende der Datei (a wie append, anhängen). Existiert sie nicht, wird versucht. sie zu erzeugen.
"a+": lesen und schreiben. Ansonsten wie "a". Achtung: Es wird beim Lesen natürlich auch am Ende der Datei begonnen (dort steht natürlich nichts mehr...)
Mit dem Befehl
fwrite($datei, "Ein Text");
kann der String Ein Text in die Datei geschrieben werden
13) Bildbearbeitung
Achtung:
In PHP gibt es den Befehl ImageGif(). Dieser Befehl erzeugt ein GIF-Bild. Dazu werden Funktionen aus der frei erhältlichen Bibliothek gd verwendet. Die Firma Unisys hält die Rechte an einem Patent zur LZW-Komprimierung von Daten, die unter anderem auch bei der Erzeugung von GIF-Bilder eingesetzt wird. Da Unisys die unrechtmäßige Verwendung von LZW-Komprimierung momentan mit rechtlichen Schritten unterbindet, ist es in der neuen Version der Bibliothek gd nicht mehr möglich, GIF-Bilder zu erzeugen. Somit ist auch der PHP-Befehl ImageGif() wirkungslos.
Mit PHP können wir nicht nur HTML-Text erzeugen, wir können sogar Bilder dynamisch erzeugen. Zum Beispiel können wir eine Datei "bild.php3" erstellen, die ein Bild zurückliefern wird. In diese Datei schreiben wir keine HTML-Befehle, sondern ausschließlich PHP-Befehle. Ausschließlich heißt auch, daß vor dem ersten <?-Befehl nichts, auch kein Leerzeichen oder Leerzeile, stehen darf. Ansonsten ist der Browser sofort der Überzeugung, daß ein Textdokument ankommt.
Ein Beispiel:
<?
Header( "Content-type: image/gif");
$im = imagecreate(200,100);
$blue = ImageColorAllocate($im, 0x2c,0x6D,0xAF);
ImageFilledRectangle($im,0,0,200,100,$blue);
ImageGif($im);
ImageDestroy($im);
?>
Ruft man diese Datei auf, so erscheint ein blaues Rechteck. Natürlich kann diese Datei auch mit
<IMG SRC="bild.php3">
in eine HTML-Seite eingebunden werden.
Was bewirken obige Befehle? Der Befehl
Header( "Content-type: image/gif");
teilt dem Browser mit, daß nun ein GIF-Bild kommen wird. (Um Fehlermeldungen in unserer PHP-Datei angezeigt zu bekommen, können wir diesen Befehl auch zeitweise auskommentieren, indem wir davor ein #-Zeichen setzen.)
Der Befehl
$im = imagecreate(200,100);
erzeugt ein Bild, das 200 Pixel breit und 100 Pixel hoch ist.
Jede Farbe, die wir verwenden wollen, muß zuerst erzeugt werden. Dies geschieht mit dem Befehl
$blue = ImageColorAllocate($im, 0x2c,0x6D,0xAF);
Dabei bezeichnet $im das Bild, für das wir die Farbe erzeugen wollen, während die restlichen drei Parameter die hexadezimalen RGB-Werte sind. (Man beachte die Schreibweise: 0x2c ergibt den dezimalen Rot-Anteil 36.)
Mit
ImageFilledRectangle($im,0,0,200,100,$blue);
zeichnen wir ein ausgefülltes Rechteck, das bei 0,0 (links oben) beginnt und 200 Pixel nach rechts und 100 Pixel nach unten endet, und in der eben erzeugten Farbe $blue gefüllt ist.
Der Befehl
ImageGif($im);
erzeugen zuerst ein GIF-Bild aus der internen Darstellung und sendet es an den Betrachter, während
ImageDestroy($im);
den internen Speicherplatz für das Bild freigibt.
Es gibt nun eine Reihe von weiteren Möglichkeiten. Zum Beispiel kann noch ein Text in das Bild geschrieben werden:
$white = ImageColorAllocate($im, 255,255,255);
imagestring($im, 5, 20, 20, "Hallo", $white);
Der erste Befehl erzeugt weiße Farbe: Man sieht, die RGB-Werte können auch als Dezimal-Werte angegeben werden. Der zweite Befehl schreibt den Text "Hallo" in Schriftgröße 5 beginnend bei Position 20,20 (20 Pixel nach rechts, 20 Pixel nach unten). Die beiden Befehle sollten direkt vor ImageGif($im); stehen.
Wer Lust auf mehr Bildbearbeitung bekommen hat, findet weitere Information im PHP-Handbuch. Über Rechtecke hinaus können die üblichen Elemente wie Kreisbögen, Linien, Polygone, Punkte verwendet werden.
14) Zugriff auf Datenbanken
Eines der Haupteinsatzgebiete von PHP ist der Online-Zugriff auf Datenbanken.
Was ist eine Datenbank?
Vereinfacht gesagt: Eine Datenbank enthält Datensätze, die mit einer speziellen Sprache bearbeitet werden können. Zum Beispiel können bestimmte Datensätze ausgelesen werden, neue Datensätze hinzugefügt werden, Datensätze können aktualisiert oder gelöscht werden. All diese Vorgänge nennt man Abfragen.
Weit verbreitet sind sogenannte SQl-Datenbanken, d.h. Datenbanken, die mit der Sprache SQL (Abkürzung für Structured Query Language) bearbeitet werden können. PHP kann mit Datenbanken verschiedener Hersteller umgehen, besonders beliebt ist die Datenbank MySQL.
Vorteile von MySQL:
relativ schnell und kostenlos.
Um eine SQL-Abfrage mit PHP auszuführen, muß zuerst die Datenbank geöffnet werden (vergleichbar mit dem Zugriff auf eine Datei), dann wird die SQL-Befehlszeile an die Datenbank geschickt, die Antwort der Datenbank wird aufgenommen und schließlich wird die Datenbank-Verbindung wieder geschlossen.
Zuerst müssen wir uns etwas Hintergrundwissen über die SQL-Befehlszeile verschaffen:
--------------------------------------------------------------------------------
15) SQL-Grundlagen
SQL-Datenbanken bestehen aus 1 oder mehreren sogenannten Tabellen. Jeder Datensatz der Datenbank ist genau eine Zeile in einer Tabelle.
Beispiel: Ein Kneipenführer für Bayreuth.
Die Tabelle kneipen:
ID Name Art Note Kommentar
1 Herzogkeller Biergarten 1 Sehr schöner Baumbestand
2 Glenk Biergarten 1 Gute Bratwürste
3 ... ... ... ...
Man kann nun auf eine dieser Tabellen zugreifen, aber auch Tabellen verküpfen. Wir wollen uns hier der Einfachkeit halber auf eine einzige Tabelle beschränken.
Es gibt im wesentlichen vier Abfragemöglichkeiten:
Auslesen: SELECT
Einfügen: INSERT
Überschreiben: UPDATE
Löschen: DELETE
Will man z.B. alle kneipennamen, die sich in der Datenbank befinden, auslesen, so gibt man den SQL-Befehl
SELECT Name FROM kneipen;
ein. Will man Name und Art der Kneipe ausgeben, so lautet der Befehl
SELECT Name,Art FROM kneipen;
Soll schließlich die ganze Zeile ausgelesen werden, so genügt der Befehl
SELECT * FROM kneipen;
Die auszulesenden Datensätze können nun noch weiter spezifiziert werden:
SELECT * FROM kneipen WHERE NOTE=1;
gibt nur die Datensätze aus, die in der Spalte Note eine 1 enthalten. Sortiert können die Datensätze mit
SELECT * FROM kneipen WHERE NOTE=1 ORDER BY Name;
werden.
Neue Datensätze werden folgendermaßen hinzugefügt:
INSERT kneipen (Name,Art,Note,Kommentar) VALUES ('Glenk','Biergarten','1','Gute Bratwürste');
Vorhandene Datensätze können mit
UPDATE kneipen SET Note='2',Kommentar='Die Bratwürste lassen nach' WHERE ID=2;
überschrieben werden.
Das soll als erster Einblick genügen. SQL ist eine sehr mächtige Abfragesprache, insbesondere für Kombinationsabfragen aus mehreren Tabellen gleichzeitig (inner joins, outer joins,...) existiert eine eigene, beinahe mathematische Theorie.
--------------------------------------------------------------------------------
16) SQL-Befehle mit PHP
Die obigen SQL-Befehle verwenden wir nun mit PHP. Wir wollen als Beispiel alle Datensätz aus der Tabelle kneipen in der Datenbank www2 ausgeben.
Zuerst muß eine Verbindung von PHP zum Datenbank-Server (d.h. dem Computer, auf dem die Datenbank liegt) hergestellt werden:
$verbindung = @mysql_connect("localhost","nobody","");
localhost bedeutet, wir verbinden uns zum gleichen Computer, auf dem sich auch der Webserver befindet. Dies funktioniert, da in unserem Fall Webserver und Datenbank auf einem Rechner liegen. Wie man vielleicht erahnt, kann also auch auf eine Datenbank auf einem beliebigen anderen Rechner im Internet zugegriffen werden - vorausgesetzt man besitzt die entsprechende Berechtigung.
nobody ist ein gültiger Benutzername für diese Datenbank (dies wurde vom Datenbank-Verwalter so festgelegt).
"" bedeutet, dieser Benutzer benötigt kein Password.
Wir können überprüfen, ob die Verbindung klappt:
if (!$verbindung) {
echo "Keine Verbindung möglich!\n";
exit;
}
Steht die Verbindung, so können wir die Abfrage starten.
Zur besseren Übersicht schreiben wir die SQL-Abfrage in eine Variable:
$abfrage = "SELECT Name,Art from kneipen";
Diese Abfrage wird an den Datenbank-Server geschickt. Das Resultat fangen wir in der Variablen $erg auf.
$erg = mysql_db_query("www2",$abfrage,$verbindung);
Die erste Variable gibt die Datenbank an, die wir abfragen wollen. Die zweite Variable enthält den SQL-Befehl, die dritte Variable enthält die Verbindung, die mit mysql_connect geschaffen wurde.
Nun kommt eine etwas kniffliger Arbeit:
Wir müssen aus $erg die zurückgelieferten Datensätze auslesen. Hätten wir einen INSERT, UPDATE oder DELETE Befehl verschickt, bräuchten wir nur testen, ob $erg wahr oder falsch ist, d.h. ob die Abfrage geklappt hat oder nicht.
Da wir aber den SELECT-Befehl an die Datenbank geschickt haben, wollen wir die von der Datenbank zurückgelieferten Datensätze auslesen.
Wir haben pro Datensatz die beiden Spalten Name und Art angefordert. Diese lesen wir nun zeilenweise aus:
list($Name,$Art) = mysql_fetch_row($erg);
Die Variable $erg enthält nach der Abfrage Zeilen mit jeweils 2 Spalten (Name und Art). mysql_fetch_row($erg) gibt genau eine Zeile aus. Zu Beginn steht eine Art Zeiger auf der ersten Zeile, führt man den Befehl mysql_fetch_row($erg) aus, rutscht der Zeiger zur nächsten Zeile usw. Will man alle Zeilen ausgeben, empfiehlt sich eine Schleife:
while (list($Name,$Art) = mysql_fetch_row($erg)) {
echo "$Name ist ein(e) $Art<BR>\n";
}
Die Ergebnisse verarbeiten wir also zeilenweise zu HTML-Text.
Am Ende empfiehlt es sich, die Verbindung zur Datenbank zu kappen:
mysql_close($verbindung);
17) Ein weiterer SQL-Befehl
Nachdem wir nun ein wenig Erfahrung mit SQL-Befehlen sammeln konnten, trauen wir uns auch an den DELETE-Befehl heran. Wichtig ist für diesen Befehl, daß ganz genau (und vorsichtig) spezifiziert wird, welcher Datensatz oder welche Datensätze aus der Datenbank gelöscht werden sollen. In unserem Beispiel ist es am besten, wenn man über das Feld ID den zu löschenden Datensatz angibt, denn dieses Feld enthält für jeden Datensatz eine eindeutige Nummer. Wollen wir den Datensatz mit ID=120 löschen, so geben wir als Abfrage an:
$abfrage = "DELETE FROM kneipen WHERE ID=120";
Achtung: Vergißt man den WHERE-Teil, werden alle Datensätze der Tabelle gelöscht! Als Ersteller einer dynamischen Webseite mit PHP und einer Datenbank sollte man also immer genau darüber nachdenken, was den Betrachtern erlaubt werden soll und was nicht.
--------------------------------------------------------------------------------
18) Funktionen
Ein wichtiger Bestandteil einer jeden Programmiersprache ist die Fähigkeit, mehrere Befehle zu einem einzigen Befehl zusammenzufassen, d.h. neue Funktionen zu definieren. PHP hat diese Fähigkeit selbstverständlich auch.
Ein Beispiel:
Wir wollen für eine Anzahl von Tagen berechnen, wieviele Sekunden diese Tage zusammen haben:
function tag ($anzahl) {
$sekunden = 3600 * 24 * $anzahl;
return $sekunden;
}
$x = tag(7);
echo "7 Tage bestehen aus $x Sekunden !";
$anzahl nennt man auch Argument der Funktion. Eine Funktion kann mehrere Argumente, oder auch kein Argument besitzen:
function zinseszins ($prozent,$laufzeit) {
$kapital = 10000.0;
$x = 1.0 + ($proz/100.0);
$y = $kapital * exp( $laufzeit*log($prozent) );
return $y;
}
$proz = 6;
$zeit = 10;
$x = zinseszins($proz,$laufzeit);
echo "Das Kapital beträgt $x Euro";
Mehr zu den verwendeten mathematischen Funktionen kann man wiederum im Handbuch nachlesen.
Problematisch ist im obigen (zugegebenermaßen etwas konstruierten) Beispiel, daß die Variable $kapital in der Funktion selbst festgelegt wird. Natürlich wird man auch diesen Wert normalerweise als Argument der Funktion übergeben, also etwa:
function zinseszins ($prozent,$laufzeit,$kapital) { ...
Wir wollen aber jetzt den Fall betrachten, daß diese Variable bereits gesetzt ist, und wir sie nicht als Argument übergeben wollen. Dann müssen wir explizit angeben, daß die Variable "von außen" stammt. Dies geschieht durch den Befehl global:
$kapital = 10000.0;
function zinseszins ($prozent,$laufzeit) {
global $kapital;
$x = 1.0 + ($proz/100.0);
$y = $kapital * exp( $laufzeit*log($prozent) );
return $y;
}
$proz = 6;
$zeit = 10;
$x = zinseszins($proz,$laufzeit);
echo "Das Kapital beträgt $x Euro";
--------------------------------------------------------------------------------
19) String-Funktionen
Ein weiteres wichtiges Betätigungsfeld von PHP ist die Bearbeitung von Zeichenketten. Es gibt eine ganze Reihe von Befehlen um Zeichenketten zu manipulieren, wir stellen hier nur die wichtigsten vor, der Rest kann im Handbuch nachgeschlagen werden. trim entfernt Leerzeichen, Tabulatorzeichen etc. (sogannten "whitespace") vor dem ersten und nach dem letzten "echten" Zeichen in der Zeichenkette.
$x = " Ich bin eine Zeichenkette! ";
$y = trim($x);
Die Befehle ltrim() und chop() entfernen whitespace vor, bzw. nach der Zeichenkette
Für die verspielten PHP-Programmierer: strtoupper() und strtolower() wandeln alle Zeichen eines Strings in Großbuchstaben, bzw. Kleinbuchstaben um.
Achtung: Probleme kann es bei Umlauten geben.
Der Befehl ucfirst() wandelt das erste Zeichen eines Strings in Großbuchstaben um (wenn möglich).
Der Befehl ucwords() hingegen wandelt in jedem Wort eines Strings das erste Zeichen in Großbuchstaben um (wenn möglich).
Der folgende Befehl ist besonders wichtig, wenn man vorhandenen Text für das WWW aufbereiten will:
$x = nl2br($y);
ersetzt alle Zeilenumbruch-Zeichen ("\n") des Strings $y in die Zeichenfolge <BR>\n.
Daneben gibt es noch einige wichtige Funktionen, um Strings zu vergleichen, zu ersetzen und mit HTML-Sonderzeichen umzugehen.
--------------------------------------------------------------------------------
20) Cookies
Als Cookies werden kurze Informationen bezeichnet, die der WWW-Server beim Client (Betrachter) hinterlassen kann. Se sind vor allem beim elektronischen Einkaufen im WWW von Bedeutung, genauer gesagt sind sie immer dann von Bedeutung, wenn der Server weitergehende Information vom Betrachter haben muß, als nur die Internet-Adresse, die eine Seite anfordert.
Cookies bestehen aus folgender Information:
Name: Name
Value: Wert
expires: Verfallsdatum
domain: Adressraum der Server, die das Cookie wieder lesen dürfen.
path: Nur über Seiten, die in diesem Verzeichnis, oder Unterverzeichnissen davon liegen, darf das Cookie angefordert werden.
secure: Wenn gesetzt, darf das Cookie nur über verschlüsselte Informationskanäle übertragen werden.
Beispiel: Wir wollen feststellen, ob ein Betrachter eine Seite schon einmal aufgerufen hat. Dazu setzen wir beim ersten Aufruf der Seite ein Cookie. Dies muß allerdings vor dem HTML-Head geschehen, d.h. am Anfang der Datei. (Unbedingt auch die Ausgabe von Leerzeilen, -Zeichen vor diesem PHP-Teil vermeiden!)
<?
$t = time()+3600*24*10;
SetCookie("mycookie","Schon besucht",$t,"/test",".de");
?>
<HTML>
...
Dieser Befehl setzt ein Cookie mit dem Namen mycookie auf den Wert "schon besucht" mit einem Verfallsdatum von 10 Tagen. Lesen darf dieses Cookie jeder Server mit der Endung .de, allerdings nur aus Dateien, die in einem Verzeichnis /test, oder Unterverzeichnissen davon liegen.
Das Verfallsdatum des Cookie muß in Sekunden seit dem 1. Januar 1970 angegeben werden. Die Funktion time() gibt die Sekunden seit dem 1. Januar 1970 der momentanen Zeit an. Weitere Datums- und Zeitfunktionen sind im Handbuch nachzulesen. Da die Berechnung der Sekunden nicht immer ganz übersichtlich ist, empfiehlt sich die Verwendung einer Funktion:
function tage ($anzahl) {
$sekunden = time()+ 3600 * 24 * $anzahl;
return $sekunden;
}
SetCookie("mycookie","Schon besucht",tage(10),"/test",".de");
Cookies lesen ist mit PHP wieder sehr einfach realisiert: Der Inhalt des Cookies ist in einer Variablen mit dem Namen des Cookies enthalten:
echo "$mycookie";
gibt also den Wert des Cookies aus, in unserem Fall den Text "Schon besucht".
Ein Server kann mit PHP ein Cookie wieder entfernen, indem lediglich der Befehl setcookie mit dem Namen des Cookies als Argument angegeben wird:
SetCookie("mycookie");
--------------------------------------------------------------------------------
21) Variable Variable
Dies ist nun schon fortgeschrittene PHP-Programmierung: In manchen Fällen will man Schleifen über eine Menge von Variablen laufen lassen. Zum Beispiel wenn man viele Eingabefelder in einem Formular hat:
<INPUT NAME="feld0" >
<INPUT NAME="feld1" >
<INPUT NAME="feld2" >
...
<INPUT NAME="feld99" >
Nun ist es sehr mühsam, alle Felder einzeln zu behandeln. Will man z.B. einfach den Inhalt aller Eingabefelder ausgeben, so kann man statt der folgenden 100 Befehle
echo "feld0: $feld0 <BR>\n";
echo "feld1: $feld1 <BR>\n";
...
echo "feld99: $feld99 <BR>\n";
auch folgendermaßen vorgehen. Wir basteln uns den jeweiligen Variablennamen zusammen:
for ($i=0;$i<100;$i++) {
$v = "feld".$i;
echo "$v: ${$v} <BR>\n";
}
Mit einem $v erhalten wir den Variablennamen, mit ${$v} greifen wir auf den Inhalt der Variablen mit dem Namen $v zu.
--------------------------------------------------------------------------------
22) Arrays aus Formularen
Abschließend noch ein letzter Trick: Wenn wir in einem Formular aus einer Menge von HTML-Checkboxen mit PHP ermitteln wollen, welche Checkboxen angeklickt wurden, dann scheitert die bisherige Vorgehensweise:
<INPUT TYPE=CHECKBOX NAME="x" VALUE=1 > Option 1
<INPUT TYPE=CHECKBOX NAME="x" VALUE=2 > Option 2
...
Schickt man dieses Formular ab, so hat die PHP-Variable $x nur den Wert der ersten angeklickten Checkbox. Der Trick ist, in HTML die Checkbox zum Beispiel so zu benennen:
<INPUT TYPE=CHECKBOX NAME="x[]" VALUE=1 > Option 1
<INPUT TYPE=CHECKBOX NAME="x[]" VALUE=2 > Option 2
...
Dadurch wird in PHP ein Array mit dem Namen $x existieren. Die Werte können dann so ausgelesen werden:
for ($i=0;$i<sizeof($x);$i++) {
echo "$x[$i] ";
}
Soweit zur Einführung in PHP. Natürlich spiegelt dies nur einen geringen Teil der Möglichkeiten von PHP wider. Aber das bisher Gelernte sollte es dem Leser ermöglichen, sich selbst im PHP-Handbuch neue Befehle anzueignen. kikamagazin 2004 mit freundlicher Erlaubnis von: http://www.php-center.de