Bini's Unterrichtsmaterial -

php-Einführung

Seite in Arbeit!!!

php ist eine serverseitig interpretierte Skriptsprache, dabei werden die php-Befehle vom Webserver (mit php-Erweiterung) interpretiert und in HTML-Codes umgewandelt. Diese werden, dann vom Webserver an den Client übermittelt. Auf diese Weise können dynamisch erzeugte Webseiten erstellt werden, d.h. erst beim Aufruf einer Internetseite (eigentlich php-Script) wird die Seite erzeugt. Dabei könnnen verschiedene Berechnungen oder Auswertungen durchgeführt, Grafiken erzeugt oder Daten aus Datenbanken oder Textdateien ausgelesen werden.

Voraussetzungen

Hier soll einen kurze Einführung in die php-Programmierung gegeben werden, dabei sollten einfache Grundlagen (Schleifen, Verzweigungen, ...) der Programmierung bereits bekannt sein und auch die Verwendung von HTML-Tags sollte keine Probleme bereiten. Kenntnisse von CCS können auch nicht schaden.
Aber keine Angst, vieles wird hier nochmals wiederholt werden :-)

Hilfsmittel

Die php-Quelltexte können mit jedem beliebigen Editor verfasst werden, jedoch bieten einige Editoren spezielle (optische) Hilfe bei der Eingabe von php bzw. html-Befehlen an (HTML-Kit, php-Coder, notepad++, ...).
Zum Anfertigen von Struktogrammen ist der structorizer ganz gut geeignet.
Außerdem sollte zum Ausprobieren der Programme ein Webserver mit php-Erweiterung zur Verfügung stehen. Dieser kann lokal installiert sein (z.B. WAMP, LAMP) oder durch Zugriffsberechtigungen im Internet realisert sein.

Los geht's

Die meisten php-Programme sind eingebettet in eine HTML-Datei, d.h. als erstes erstellen wir ein HTML-Grundgerüst:

<html>           Beginn der HTML-Datei
   <head>        Beginn des Kopfteil
      <title>Inhalt der Titelzeile</title>
   </head>       Ende des Kopfteil
   <body>        Beginn der sichtbaren Hauptteils          
                          hier steht alles was im Browserfenster sichtbar sein soll  
   </body>       Ende des Hauptteils
</html>          Ende der HTML-Datei

php-Block

In einer HTML-Datei können beliebig viele php-Blöcke enthalten sein. Diese werden stets in

 
<?php
   ....
   ....
?>

eingeschossen.

Jedoch wird der Quellcode durch ständiges Öffnen und Schließen von php sehr unlesbar, so dass es zweckmäßig erscheint durchgängige php-Blöcke zu erstellen.

Textausgabe

Nun geben wir mit dem Befehl echo einen einfachen Text aus, in dem wir den php-Code in die HTML-Grundstruktur einbauen:

   
<html>
  <head>
     <title>Meine erste php-Seite</title>
     </head>
     <body>
        <h1>Erste php-Seite</h1>
        <?php
           echo "Mein erstes php-Programm!“;
        ?>
     </body>
</html>

Speichern wir nun dieses Programm im Verzeichnis des Webservers ab und versehen den Dateinamen mit der Endung *.php, so wird der php-Code vom Webserver beim Aufruf in HTML-Code umgewandelt und an den Browser geschickt.
Rufen wir nun diese Datei textausgabe.php in unserem Browser über den Webserver auf, so sehen wir die Textausgabe am Schirm. Betrachten wir jedoch den Quellcode der Seite im Browser, so enthält diese nur mehr HTML-Tags und keine php-Befehle.

echo

Der Befehl echo gibt den Text zwischen den Anführungszeichen aus. Dieser kann auch HTML-Tags enthalten. Sollen innerhalb des Textes Anführungszeichen enthalten sein, so ist die einfachste Variante auf einfache Anführungszeichen '...' auszuweichen oder die doppelten mittels backslash zu maskieren.

echo "Mein Name ist 'Hase'!";
echo "Heute ist nicht \"Sonntag\".";

Strichpunkt

Jede vollständige php-Befehlszeile muss durch einen Strichpunkt abgeschlossen werden.

Kommentar

Einzeilige Kommentare werden stets durch zwei Backslashes eingeleitet.

 
// diese Zeile ist ein Kommentar

Der anschließende Text bis zum Ende der Zeile wird nicht interpretiert.

Mehrzeilige Kommentare werden in /* ....*/ eingeschlossen.

/* Hier ein mehrzeiliger
   Kommentar. Am Ende steht 
   immer Stern Slash */

Es ist zweckmäßig jedes Programm am Beginn mit dem Datum der letzten Änderung zu versehen und eine kurze Programmbeschreibung einzufügen.

date(Format, Zeit)

Diese Funktion gibt die aktuelle Systemzeit in verschiedenen Formaten am Schirm aus, wenn diese ohne Zeitangabe aufgerufen wird. Die Zeitangabe muss als UNIX-Zeit angegeben werden; dies entspricht der Anzahl an Sekunden, die seit dem 1.1.1970 vergangen sind.

echo "Die Systemzeit wird in verschiedenen Formaten ausgegeben: <br />\n" ; 
echo "d.m.Y H:i:s ... ". date("d.m.Y H:i:s")."<br />\n" ;
echo "d.m.y h:i:s ... ". date("d.m.y h:i:s")."<br />\n" ;
echo "j.M.y H:i:s ... ". date("j.M.y H:i:s")."<br />\n" ;

Weitere Formatierungscodes für diese Funktion sind unter http://at2.php.net/manual/de/function.date.php aufgelistet.

Punkt-Operator

Im obigen Beispiel wurde der Punkt-Operator verwendet, um Zeichenketten (Strings) miteinander zu verbinden. D.h. die Zeichenkette

"d.m.Y H:i:s ... "

wird mit dem Ergebnisstring der date-Funktion

date("d.m.Y H:i:s")

verbunden und anschließend auch noch

"<br />\n" ;

angehängt.

Diese neue Zeichenkette wird mittels echo am Schirm ausgegeben.

Zeilenumbruch

Damit die Ausgabe im Browser nicht in einer endlos langen Zeile erfolgt, wurde in die Ausgabe das HTML-TAG

<br />

eingefügt.

Dies hat aber leider keinen Einfluss auf den HTML-Quellcode, den der php-Interpreter am Webserver erzeugt. D.h. der Interpreter würde die HTML-Übersetzung in eine einzige Zeile schreiben.

Möchte man nun den HTML-Quellcode studieren, um ev. einen Programmfehler ausfindig zu machen, so kann dies recht mühsam werden. Daher ist es zweckmäßig an geeigneter Stelle ein

\n

einzufügen, um auch den HTML-Quellcode gut zu strukturieren.

Variablen

Während der Ausführung eines Programms können Daten in Speichern abgelegt werden. Diese Datenspeicher dienen auch als Platzhalter in Formeln oder Schleifen. Um eine Variable zu definieren wird ihr ein Wert zugewiesen (eine vorhergehende Deklaration ist nicht notwendig).

$name = "Helmut Bineder";
$zahl = 5;
$preis = 7.55;

Variablen werden in php stets mit einem $-Zeichen eingeleitet, dem dann der Name der Variablen folgt. Bei der Namensgebung sollten stets sprechende Namen verwendet werden. Dadurch wird das Programm lesbarer. Die Namen dürfen keine Leerzeichen enthalten und es wird GROSS/kleinschreibung berücksichtigt. $name und $Name stellen also zwei verschiedene Variablen dar!

Bei der Zuweisung von Dezimalzahlen ist darauf zu achten, dass der Punkt (.) als Dezimalzeichen verwendet wird (ein Beistrich würde zu einer Fehlermeldung führen. Zur Vermeidung von Fehlern sollten daher alle Variablennamen klein geschrieben werden.

Beim folgenden Beispiel werden zwei Variablen mit Werten belegt und anschließend mit den Additionsoperator die Summe gebildet. Die ganze Rechnung wird samt Ergebnis am Schirm dargestellt.

$a = 5;
$b = 7;
$erg = $a + $b;
echo "Meine Rechnung $a + $b = ";

Zufallszahl

Das obige Programm wird nun dahingehend erweitert, dass nicht zwei fixe Werte den Variablen zugewiesen werden, sondern jeweils eine Zufallszahl. Dies erledigt die Funktion

mt_rand(min, max);

wobei man einen ganzzahligen Wert in dem durch min und max angegebenen Intervall erhält. Das Programm muss wie folgt, abgeändert werden:

$a = mt_rand(11,19);
$b = mt_rand(1,9);
$erg = $a + $b;
echo "Meine Rechnung $a + $b = $erg";

for-Schleife

Ein oder mehrere Befehle können in einem Programm durch die Verwendung von Schleifen mehrfach wiederholt werden. Ist die Anzahl der Wiederholungen bereits bei der Programmentwicklung bekannt, so nutzt man die Möglichkeiten der for-Schleife. Dies ist eine kopfgesteuerte Schleife. Dies bedeutet, dass die Bedingung für den Schleifenabbruch vor den zu wiederholenden Befehlen überprüft wird.

for (laufindex, laufbedingung, zählmuster) {
   Befehle zur Wiederholung
   ...
}

In der Variablen des Laufindexes wird die Anzahl der Durchläufe mitgezählt. Solange die Laufbedingung erfüllt ist, werden die Befehle innerhalb der geschwungenen Klammern abgearbeitet. An Ende jedes Durchlaufs wird, nach Angabe des Zählmusters, der Laufindex berichtigt.

Im nächsten Programm soll eine Liste von fünf Zufallszahlen ausgegeben werden:

for ($i=0;$i<5;$i++){ 
    $zz=mt_rand(11,99);
    echo "$zz ";
}

Der Laufindex $i wird mit dem Startwert=0 belegt. Die Schleife soll so lange durchlaufen werden, solange der Laufindex $i kleiner als 5 ist. Nach jedem Durchlauf wird der Laufindex $i um 1 erhöht (incrementiert).

Verschachtelte Schleifen

Oft ist es notwenig mehrere Schleifen miteinander zu kombinieren. Dabei ist zu beachten, dass die Abarbeitung einer Schleife komplett innerhalb einer anderen Schleife erfolgen muss, d.h. dem Setzen der geschwungen Klammern ist größtes Augenmerk zu schenken. (Manche Editoren helfen dabei Klammernpaare leicht aufzuspüren z.B. Notepad++.

Bei der Programmentwicklung sollte man stets VOR dem Tippen des Codes, die genaue Struktur festlegen. Eine gute Methode dazu bietet das graphische Veranschaulichen des Ablaufes in einem Struktogramm. Außerdem sollte ein Programm stets schrittweise aufgebaut werden, d.h. ausgehend von einem Programmteil, der getestet werden kann, wird das Programm ergänzt, wieder getestet usw. Dies soll im folgenden Beispiel demonstriert werden.

Ausgehend vom vorigen Programm, soll die Ausgabe der Zufallszahlen nun in einer Tabelle erfolgen. Dazu werden die fünf Zahlen jeweils in Tabellenzellen geschrieben und in einer Zeile zusammengefasst:

echo"<table border=1>\n";      //Tabelle mit Umrandung wird geöffnet
echo"<tr>\n";                  //Zeile wird geöffnet 
for ($spalte=1;$spalte<=5;$spalte++){     //Schleife 5x durchlaufen 
    $zz=mt_rand(11,99);                   //Zufallszahl ermitteln
    echo "<td>$zz</td>\n";     //Zufallszahl in Tabellenzelle schreiben
}                              //Ende der Schleife
echo"</tr>\n";                 //Zeile wird geöffnet
echo"</table>\n";              //Tabelle wird geschlossen

Nun soll aus dieser einzeiligen Tabelle eine Tabelle mit drei Zeilen werden. Dazu muss jener Teil des Programms wiederholt werden, der die Zeile erzeugt. Daher wird das Programm um eine weitere for-Schleife erweitert, die den Block der Zeilenerzeugung umschließt.

echo"<table>\n";                        //Tabelle wird geöffnet
for ($zeile=1;$zeile<=3;$zeile++){      //Schleife zum Erzeugen von 3 Zeilen
    echo"<tr>\n";                             //Zeile wird geöffnet 
    for ($spalte=1;$spalte<=5;$spalte++){     //Schleife zum Erzeugen von 5 Zellen 
        $zz=mt_rand(11,99);                      //Zufallszahl ermitteln
        echo "<td>$zz</td>\n";                   //Zufallszahl in Tabellenzelle schreiben
    }                                         //Ende der Zellen-Schleife
    echo"</tr>\n";                            //Zeile wird geschlossen
}                                        //Ende der Zeilen-Schleife
echo"</table>\n";                        //Tabelle wird geschlossen

while-Schleife

Ist die Anzahl der Schleifendurchläufe bei der Programmerstellung nicht bekannt, weil diese vom Programmverlauf abhängig ist, so wird die while-Schleife verwendet. Auch diese Schleife ist eine kopfgesteuerte Schleife, denn auch hier wird zuerst geprüft, ob ein Schleifendurchlauf ausgeführt werden soll.

while (laufbedingung) {
      Befehle zur Wiederholung
      ...
}

Dabei ist zu beachten, dass innerhalb der Schleife die Laufbedingung variiert werden sollte, damit es nicht zu Endlosschleifen kommt.

Das nächste Programm soll so lange Zufallszahlen ausgeben, bis eine Zufallszahl größer als 75 errechnet wird.

$zz=mt_rand(11,99);
while ($zz < 75) {
      echo "$zz ";
      $zz=mt_rand(11,99);
} 
echo "<br />Die Abbruchszahl lautet: $zz";

Ist bereits die erste Zufallszahl größer als 75, so wird die Schleife überhaupt nicht durchlaufen.

do ... while-Schleife

Diese Schleife ist eine fußgesteuerte Schleife, dabei wird die Schleife mindestens einmal durchlaufen und am Ende der Schleife geprüft, ob ein weiterer Durchlauf erfolgen soll.

do {
   Befehle zur Wiederholung
   ...
} while (laufbedingung)

Auch hier muss die Laufbedingung innerhalb der Schleife variiert werden, damit es nicht zu einer Endlosschleife kommt.

Beim nächste Beispiel soll mindestens eine Zufallszahl ausgeben werden, ist diese größer als 50, sollen weiter ausgegeben werden, bis diese Bedingung nicht mehr erfüllt wird.

do {
   $zz=mt_rand(11,99);
   echo "$zz "; 
} 
while ($zz > 50); 
echo "<br />Die Abbruchszahl lautet: $zz";

Die Überprüfung erfolgt hier im Schleifenfuß.

Arrays

Soll in einem Programm mit sehr vielen Werten immer dieselbe Operation durchgeführt werden, so speichert man diese Werte am besten in einem Array (einer strukturierten Variablen). Ein Array ist eine Variable, die mehrere Werte aufnehmen kann. Dies kann man sich wie einen Schuhkarton vorstellen, der viele Unterteilungen enthält, so dass in jedem Fach ein Wert abgelegt werden kann. Diese Fächer sind durchnummeriert, so dass jedes Fach einzeln angesprochen werden kann. Die Nummerierung beginnt stets bei 0 (Null).

Die Wertzuweisung an ein Array kann auf verschiedene Arten erfolgen. Sollen gleich mehrere Werte eingetragen werden, verwendet man folgende Notation:

variablenname = array(Wert1, Wert2, Wert3, ....)

Erfolgt eine Zuweisung an eine bestimmte Position (an ein spezielles Fach), so lautet die Befehlszeile:

variablenname[fachnummer] = Wert

In einem Array werden nun die Namen von Bundesländern gespeichert, dabei werden beide Schreibweisen verwendet. Anschließend werden die Daten mittels Schleife ausgelesen.

$bundesland = array ("Wien", "Nieder&oumlsterreich", "Burgenland");
$bundesland[3]="Steiermark";
$i=0;
while ( [$i]) {
      echo "$bundesland[$i] <br />";
      $i++;
}

Zuerst werden die ersten drei Positionen mit Bundeslandnamen belegt, also Position 0, 1 und 2. Anschließend wird auch noch Fach 3 belegt. Der Schleifenindex $i wird auf 0 gestzt. Die Bedingung in der while-Schleife überprüft, ob an der aktuellen Indexposition ein Wert eingetragen ist. Ist dies der Fall, wird dieser Wert ausgegeben und der Index um 1 erhöht ($i++). Ist dies nicht der Fall, wird die Schleife beendet. Damit ist auch das Programm zu Ende.

Arrays bieten einen weiteren großen Vorteil: Die Werte können ganz leicht mit der Funktion sort(arrayname) alphabetisch/aufsteigend sortiert werden.

Analog sortiert die Funktion rsort(arrayname) absteigend.

Die Funktion shuffle(arrayname) durchmischt das Array. Die Elemente werden in einer zufälligen Rehenfolge angeordnet.

Mit der Funktion count(arrayname) kann die Anzahl der gespeicherten Werte in einem Array ermittelt werden.

Operatoren

Operatoren dienen der Bearbeitung/Verknüpfung/Berechnung von Werten und werden in verschiedene Gruppen zusammengefasst:

Zuweisungsoperator
$a = $b	Zuweisung	$a nimmt das Ergebnis des rechten Ausdruckes auf
Arithmetische Operatoren
$a + $b	Addition	Summe von $a und $b.
$a - $b	Subtraktion	Differenz von $a und $b.
$a * $b	Multiplikation	Produkt von $a und $b.
$a / $b	Division	Quotient von $a und $b.
$a % $b	Modulo	Rest der Ganzahldivision von $a geteilt durch $b.
$a++	Increment	$a wird um eins erhöht ($a=$a+1).
$a--	Decrement	$a wird um eins erniedrigt ($a=$a-1).
Zeichenketten Operator
$a . $b	Vereinigung	Verbindet den String $a und $b (hängt $b ans Ende von $a).
Logische Operatoren
$a and $b $a && $b	Und	true wenn sowohl $a als auch $b true ist.
$a or $b $a \|\| $b	Oder	true wenn $a oder $b true ist.
$a xor $b	Entweder Oder	true wenn entweder $a oder $b true ist, aber nicht beide.
! $a	Nicht	true wenn $a nicht true ist.
Vergleichsoperatoren
$a == $b	Gleich	Gibt true zurück, wenn $a gleich $b ist.
$a === $b	Identisch	Gibt true zurück wenn $a gleich $b ist und beide vom gleichen Typ sind (eingeführt in PHP 4).
$a != $b	Ungleich	Gibt true zurück, wenn $a nicht gleich $b ist.
$a <> $b	Ungleich	Gibt true zurück, wenn $a nicht gleich $b ist.
$a !== $b	Nicht identisch	Gibt true zurück, wenn $a nicht gleich $b ist, oder wenn beide nicht vom gleichen Typ sind (eingeführt in PHP 4).
$a < $b	Kleiner Als	Gibt true zurück, wenn $a kleiner als $b ist.
$a > $b	Größer Als	Gibt true zurück, wenn $a größer als $b ist.
$a <= $b	Kleiner Gleich	Gibt true zurück, wenn $a kleiner oder gleich $b ist.
$a >= $b	Größer Gleich	Gibt true zurück, wenn $a größer oder gleich $b ist.

if-Verzweigung

Soll ein Programmteil nur unter bestimmten Voraussetzungen ausgeführt werden, so kann dies durch eine Bedingung geprüft werden.

if (Bedingung) {
   erfüllt DANN wird dieser Programmblock ausgeführt
   ...
}
else {
   SONST wird dieser Programmblock ausgeführt
   ...
}

Liefert diese Abfrage den Wert true, dann wird der erste Programmblock ausgeführt. Es kann ein weiter Programmblock definiert werden, der im Falle von false ausgeführt wird. Dieser kann aber bei Bedarf entfallen.

Die Zufallszahlen kleiner als 50 sollen deutlich markiert werden:

for ($i=0;$i<8;$i++){
    $zz=mt_rand(11,99);
    echo "$zz ";
    if ($zz < 50){   // Bedingung erfüllt
       echo " <--- <br />";
    }
    else {              // Bedingung nicht erfüllt
         echo "<br />";
    }                   // Ende der Verzweigung
}                       // Ende der for-Schleife

Nur wenn die Bedingung erfüllt ist, wird ein kleiner Pfeil neben der Zahl ausgegeben, sonst wird nur ein Zeilenumbruch durchgeführt.

switch-Verzweigung

Sollen in einem Programm gleichzeitig mehrere Bedingungen geprüft werden bzw. der Programmablauf zwischen mehreren Wegen verzweigen, so bedient man sich der switch-Verzweigung.

Mathematische Funktionen (Auswahl)

Viele der gebräuchlichen Funktionen sind auch in PHP implimentiert. Hier soll nur eine ganz kleine Auswahl vorgestellt werden:

max($a,$b,$c,...)	Maximum	ermittelt den größten Wert der übergebenen Argumente
min($a,$b,$c,...)	Minimum	ermittelt den kleinsten Wert der übergebenen Argumente
pow($a,$b)	Potenz	ermittelt $a hoch $b ($a^$b)
sqrt($a)	Quadratwurzel	ermittelt die Quadratwurzel von $a (√$a)

Selbstverständlich ist die Übergabe der Argumentlisten mittels Array möglich.

Funktionen selbst definieren

Werden Programmteile oder Auswertungen in einem Programm oder größeren Projekt mehrfach verwendet, so ist es zweckmäßig diesen Teil als eigene Funktion zu definieren.

Dabei wird dieser Programmblock separiert und später im Programm, wie eine vordefinierte mathematische Funktion aufgerufen

function Funktionsname (Werteübergabe) {
   Definition der Funktion bzw.
   ausgelagerter Programmteil
   ...
}

Hier startet das eigentliche Hauptprogramm
...
....
...
}

An Hand eines sehr einfachen Beispiels soll die Arbeitsweise demonstiert werden:

   function summe($z1, $z2){         // Definition der Funktion
      $erg=$z1+$z2;                  // Berechnung
      return $erg;                   // Rückgabewert
   } //-------------------------------- Ende summe
//==================== HAUPTPROGRAMM ==========================
echo "Es wird die Funktion \"Summe\" mit den Zahlen 3 und 5 aufgerufen. <br />" ;
echo "Diese wurde in der selben php-Datei defniert. <br />";
echo "Das Ergebnis lautet: ";
echo summe(3,5);                     // Aufruf der Funktion

Die Definition der Funktion erfolgt vor den eigentlichen Hauptprogramm. Der Aufruf der Funktion in der gewohnten Form.

include()

Oft ist es zweckmäßig Funktionen oder Programmteile in eigene Dateien auszulagern und diese mittels include() ins Hauptprgramm einzubinden. Dadurch können diese ausgelagerten Teile in unterschiedlichen Programmen Verwendung finden.

Dies soll für das obige Beispiel durchgeführt werden. Dazu muss die Funktionsdefinition in einer eigenen Datei gespeichert werden, wobei diese nur den php-Teil aber keinen HTML-Block enthält.

<php
   function summe($z1, $z2){         // Definition der Funktion
      $erg=$z1+$z2;                  // Berechnung
      return $erg;                   // Rückgabewert
   } //-------------------------------- Ende summe
?>

Beachtet man bei der Namensgebung, dass die Extension php verwendet wird, so wird verhindert, dass der Quelltext im Browser angezeigt wird. Dies ist besonders wichtig, wenn die Datei Variablendefinitionen mit Zugangsdaten enthält. Das Ergänzen von inc oder fkt weist schon beim Dateinamen darauf hin, dass es sich um keine vollständige php-Datei, sondern nur um einen Programmteil handelt. Dies kann der Übersichtlichkeit bei Projekten dienen.

In der eigentlichen Programmdatei verbleibt nur das Hauptprorgamm, wobei der ausgelagerte Teil am Beginn mittels include(...) eingefügt wird.

include('summe2.inc.php');
echo "Es wird die Funktion \"Summe\" mit den Zahlen 3 und 5 aufgerufen. <br />" ;
echo "Diese wurde in der externen php-Datei summe2.inc.php defniert. <br />";
echo "Das Ergebnis lautet: ";
echo summe(3,5);                     // Aufruf der Funktion

Die Definition der Funktion erfolgt vor den eigentlichen Hauptprogramm. Der Aufruf der Funktion in der gewohnten Form.

Formulare

Interaktionen und Datenerfassung ist heute Bestandteil vieler Webanwendungen. Damit individuelle Daten an den Server übermittelt werden können, müssen diese in Formulare eingetragen werden, diese werden wie folgt aus folgenden (X)HTML-Tags aufgebaut:

<form action=Auswertungsdatei method=Übermittlungsmethode>
   ...
   Definition der Eingabefelder und
   des Absendebuttons
   ...
</form>

Die Auswertung soll bei den folgenden Beispielen stets in derselben Datei erfolgen, die auch das Formular enthält. Dies erhöht die Übersichtlichkeit, ist aber nicht zwingend vorgegeben. Die Formulardaten könnten auch an eine andere Auswertungsdatei übermittelt werden.

get & post

In (X)HTML gibt es zwei Methoden die Daten aus einem Formular zum Server zu übertragen. Bei der Methode GET werden die Eingabewerte mit der URL zum Server gesendet, d.h. an die URL werden die Feldnamen und Eingabedaten angehängt.

http://umat.bineder.at/inf/php/formular/form_01.php?txt1=Hans&txt2=Hugo&senden=absenden

Der Vorteil liegt hier in der leichten Überprüfbarkeit der an den Server gesendeten Daten. Fehler lassen sich sehr rasch feststellen. Der Nachteil ist aber, dass jedermann diese Daten zu Gesicht bekommt, sie verändern und so das Auswerteprogramm negativ beeinflussen kann. Außerdem können maximal Datenmengen bis 2 kByte übertragen werden.

Bei der POST-Methode werden die Daten nicht in der URL angezeigt, sondern im Körper der Nachricht verschickt. Hier können wesentlich größere Datenmengen bearbeitet, sogar ganze Dateien versendet werden. Versteckte Felder und Kennworte kommen so nicht zum Vorschein. Es ist zweckmäßig zur Prüfung und Entwicklung eines Formulars stets die Methode GET zu verwenden, wenn das Programm gut funktioniert, die Methode auf POST zu ändern.

Eingabefeld

Ein einzeiliges Eingabefeld wird mit folgendem (X)HTML-Tag (innerhalb eines Formulars erzeugt:

<input type="text" name="Feldname">

Der Typ text erzeugt das Eingabefeld und der Name dient als Variable zur Wertübergabe.

Absendeknopf

Nun fehlt noch der SUBMIT-Button zum Abschließen und Senden der eingegebenen Daten:

<input type="submit" name="senden" value="absenden">

Der Typ submit erzeugt die Schaltfläche, der Name dient als Variable zur Wertübergabe und Value legt hier die Beschriftung der Schaltfläche fest.

Das vollständige Formular kann also ausschließlich mit (X)HTML-Tags erzeugt werden. Um dies in einer php-Datei durchzuführen, müssen diese TAGs mittels echo ausgeben werden.

echo "<form action=\"$ps\" method=\"get\">";
echo "<p> Bitte Text eingeben: ";
echo "<input type=\"text\" name=\"txt1\"></p>";
echo "<p> Bitte Text eingeben: ";
echo "<input type=\"text\" name=\"txt2\"></p>";
echo "<p><input type=\"submit\" name=\"senden\" value=\"absenden\"></p>";
echo "</form>";

In der Variablen $ps ist der Dateiname der aktuellen php-Datei gespeichert. Dieser Dateiname kann aus folgender Servervariablen zugewiesen werden:

$ps=$_SERVER['PHP_SELF'];

Es ist zu beachten, dass dieses Programm nur ein Formular darstellt, aber noch keinerlei Auswertung der Daten vornimmt.

Formularauswertung

Damit die an den Server übermittelten Daten vom obigen Programm verarbeitet werden, muss ein entsprechender Programmteil in den Code eingefügt werden. Es ist zu prüfen, ob das Formular ausgefüllt und die Daten abgeschickt d.h. der Sende-Button betätigt wurde.

Wird das Programm zum ersten Mal aufgerufen, so soll das Formular präsentiert werden. Wurde die Eingabe mit Knopfdruck bestätigt, also die Daten an den Server geschickt und das Programm mit dem URL-Anhang aufgerufen, so sollen nur die Eingabedaten angezeigt werden. Dies kann mittels Verzweigung gelöst werden:

$ps=$_SERVER['PHP_SELF'];                             // Dateiname der aktuellen Datei
if (!isset($_GET['senden'])) { // senden wurde nicht gedrückt ------------> FORMULAR
   echo "<form action=\"$ps\" method=\"get\">";
   echo "<p> Bitte Text eingeben: ";
   echo "<input type=\"text\" name=\"txt1\"></p>";
   echo "<p> Bitte Text eingeben: ";
   echo "<input type=\"text\" name=\"txt2\"></p>";
   echo "<p><input type=\"submit\" name=\"senden\" value=\"absenden\"></p>";
   echo "</form>";
}
else { //  senden wurde  gedrückt --------------------------------------> AUSWERTUNG
     $txt1=$_GET['txt1'];        // Variablen werden mit Werten vom Formular belegt
     $txt2=$_GET['txt2'];
     echo "<em>txt1 hat den Wert:</em> $txt1 <br />";
     echo "<em>txt2 hat den Wert:</em> $txt2 <br />";
}

Es wird also das Formular oder die Auswertung angezeigt!

Drop Down Menü

Ein weiteres Formularfeld stellt das DropDownMenü dar. In einer Liste werden mehrere Werte zur Auswahl angeboten, so dass ein Wert ausgewählt werden kann. Erzeugt wir dieses Menü durch das <select>-Tag, wobei die Wahlmöglichkeiten in <option>-Tags aufgelistet werden:

echo "<select name='auswahl'>";
   echo "   <option value='1'>rot</option>";
   echo "   <option value='2'>grün</option>";
   echo "   <option value='3'>blau</option>";
echo "</select>";

Die getroffene Auswahl wird in der entsprechenden Variablen zurückgegeben. Im obigen Beispiel wird also der Wert 1, 2 oder 3 in der Variablen gespeichert, es können aber auch Texte zurückgegeben werden.

Der Vorteil von nummerischen Übergabewerten liegt darein, dass bei längeren Auswahllisten, diese mittels Array und Schleife erzeugt werden können.

Radio Buttons

Eine andere Möglichkeit eine einzelne Auswahl aus einer Auflistung zu treffen, stellen die runden Knöpfe dar. Hier springt die Markierung zu jenem Knopf, der angeklickt wird. Erzeugt werden diese mit dem <input type="radio" ..../>. Für jede Wahlmöglichkeit wird ein eigenes <input ..../> benötigt, jedoch müssen alle den gleichen Namen tragen.

echo "<input type='radio' name='radiobutton' value='Mathematik'>Mathematik<br />";
echo "<input type='radio' name='radiobutton' value='Physik' checked='checked'>Physik<br />";     
echo "<input type='radio' name='radiobutton' value='Informatik'>Informatik<br />";

Die getroffene Auswahl wird in der entsprechenden Variablen zurückgegeben, wobei in diesem Beispiel Texte zurückgegeben werden. Die Vorauswahl kann mittels Attribut checked='checked' getroffen werden.

Checkboxen

Eine weitere Auswahlmöglichkeit bieten Checkboxen. Diese eckigen Kästchen zum Anhaken bieten eine Mehrfachauswahl aus einer Liste. Erzeugt werden diese mit dem <input type="checkbox" ..../>. Für jede Wahlmöglichkeit wird ein eigenes <input ..../> benötigt. Jede Wahlmöglichkeit ist unabhängig von den anderen, so dass zur Auswertung, jedes Element einen anderen Namen tragen muss.

echo "<input type='checkbox' name='checkbox1' value='Suppe' />Suppe<br />";
echo "<input type='checkbox' name='checkbox2' value='Schnitzel' />Schnitzel<br />";
echo "<input type='checkbox' name='checkbox3' value='Kuchen' />Kuchen<br />";

Die getroffene Auswahl wird in der entsprechenden Variablen zurückgegeben. Eine Vorauswahl kann wieder mittels Attribut checked='checked' getroffen werden.

Die Umsetzung mittels Array und Schleife kann den Code erheblich vereinfachen.

Textarea

In ein mehrzeiliges Textfeld können größere Mengen Text eingegeben werden. Die Übermittlung der Daten muss in diesem Fall mit post vorgenommen werden. Begonnen wird diese Eingabefeld mit dem <textarea>, gefolgt von der Eingabaufforderung/Vorgabewert im Textfeld und dem Abschluss durch </textarea>.

echo "<textarea name='mehrzeiler' cols='30' rows='5'>";
echo "Hier Text eingeben ...";
echo "</textarea>";

Die Größe des Feldes kann mit cols und rows festgelegt werden, wobei eine Formatierung mittels CSS width und height vorzuziehen ist.

Weitere Formularfelder

Es gibt noch unzählige weitere Formularfelder, die den obigen ähnlich sind und auch ähnlich ausgewertet werden. Einige sind im folgenden Beispiel zusammengestellt. Diese Datei kann gut als Ausgangspunkt für eigene Formulardefinitionen dienen.

Zur einfacheren Schreibweise kann das HTML-Formular auch in einem einzelnen echo definiert werden. Allerdings beziehen sich in weiterer Folge php-Fehlermelungen auf den Beginn der echo-Zeile, auch wenn sich dieses echo über mehrere Zeilen erstreckt und der Fehler an ganz anderer Stelle verursacht wird.

...

Fortsetzung folgt...

Sessions

Bei der Erstellung von dynamische Webseiten ist es immer wieder notwendig Daten von einer Datei zur nächsten weiterzureichen. Dies wurde schon bei den Formularen ausführlich behandelt. Die Methoden POST und GET haben allerdings ihre Grenzen, wenn die übergebenen Daten zu umfangreich bzw. sensibler Art sind.

Bei der Verwendung von SESSIONs werden die Daten am Webserver gespeichert und über eine SESSION-ID identifiziert. D.h. sobald eine SESSION gestartet wird, erhält der User - also der Browser - eine SESSION-ID vom Webserver zugeteilt. Diese zufällige Kombination aus 32 Zahlen und Buchstaben wird meist in einem Cookie abgelegt und bei Bedarf vom Browser an den Webserver unsichtbar übermittelt. (Die Übertragung innerhalb der URL ist auch möglich, falls keine Cookies zugelassen werden. Aber dies birgt das Sicherheitsrisiko, dass auch andere User mittels dieser URL unsere SESSION missbrauchen könnten.)

SESSIONs werden häufig dazu benutzt die Bewegungen eines Users auf einer Webseite zu verfolgen oder Produkte in einem Warenkorb zu sammeln. Aber auch die Überpüfung des korrekten Logins wird häufig über SESSIONs realisiert. Im folgenden Beispiel soll ein geschützer Bereich nur mit den richtigen Zugangsdaten zur Verfügung stehen.

Der erste Schritt ist eine SESSION zu starten:

session_start()

Diese Funktion eröffnet eine vorhandene oder erzeugt eine neue SESSION. D.h. im Normalfall wird nun eine SESSIONID in einem Cookie abgelegt. Falls dies nicht möglich ist, entscheiden die Einstellungen des Webservers, welche Möglichkeiten alternativ zur Verfügung stehen.

Ganz wichtig: Da Cookies im HTTP-Header übermittelt werden, muss dies die erste Aktion sein, die beim Erzeugen der HTML-Seite ausgeführt wird. D.h. es dürfen davor keinerlei Seiteninhalte übertragen werden. Außerdem funktioniert dies nur, wenn die Datei die Endung php trägt. Also muss die Datei folgendermaßen aufgebaut sein:

<?php
  session_start(); ?>
  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
  <html xmlns="http://www.w3.org/1999/xhtml" lang="de" xml:lang="de"> 
  <head>
    <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1" /> 
    <link href="sessions.css" rel="stylesheet" type="text/css" />
    <title>PHP Sessions</title>
  </head>
  <body>  
  <h3>Session Login</h3>

Der nächste Schritt ist die Erstellung eines Formulars zur Eingabe der Zugangsdaten. Zur übersichtlichen Darstellung, wird dies in eine Tabelle verpackt:

$ps=$_SERVER['PHP_SELF'];
<form action="<?php $ps ?>" method="post">
   <table>
     <tr><td>Name:</td>
        <td><input type="text" name="name"></td></tr>
     <tr><td>Passwort:</td>
        <td><input type="password" name="passwort"></td></tr>
     <tr><td>&nbsp;</td>
        <td><input type="submit" name="einloggen" value="Einloggen"></td></tr>
   </table>
</form>

Nun müssen die Formulardaten noch ausgewertet werden. Dies soll in diesem Beispiel in der gleichen Datei erledigt werden, könnte aber auch in einer anderen Datei erfolgen, dann müssten die Eingabedaten an die andere Datei übermittelt werden.

if (isset($_POST['einloggen'])){
   $name=$_POST['name'];          // Daten aus dem Formular vom Server holen
   $passwort=$_POST['passwort'];
   if (!($name=='TestUser' and $passwort=='1234')){
      echo "<p class='fehler'>Anmeldung nur mit den festgelegten Benutzerkonten möglich!</p>";
   }
   else {                           // Daten in Session speichern
			
      $_SESSION['sname']=$name;			
      $_SESSION['spasswort']=$passwort;		
      $_SESSION['sseite']=basename($ps);		
         // ------------- Weiterleitungs-Skript -----------------
      echo "<script type='text/javascript'>";
      echo "function redirect_user() {";
      echo "window.location.replace('seite1.php')";
      echo "}";
      echo "Timer = setTimeout('redirect_user()' , 0)";
      echo "</script>";
        // -----------------------------------------------------
   }
}

Bei erfolgreichem Login wird eine Weiterleitung mittels Javascript ausgelöst. Erfolgt die Auswertung gleich in der Folgedatei, so kann der Javascript-Block entfallen.

Besteht der interne Bereich aus mehreren Seiten, so muss in jeder Datei geprüft werden, ob das Login korrekt durchgeführt wurde. Da die korrekten Zugangsdaten in SESSION-Variablen am Server gespeichert wurden, können diese leicht überprüft werden. Dazu müssen diese nicht übertragen werden, da die Auswertung des php-Skrips direkt am Webserver erfolgt.

Am Beginn jeder internen Seite wird jeweils die SESSION geöffnet und die gespeicherten Werte in Variablen abgelegt:

<?php	// seite1.php bi 2012.02
  // 		Session wird gestartet!
  // 		Dies muss erfolgen bevor irgend ein anderer Code kommt - Headerinformation
  session_start();
  $sname=$_SESSION['sname'];                            // Daten aus SESSION in Variablen schreiben
  $spasswort=$_SESSION['spasswort'];
  $alte_seite=$_SESSION['sseite'];
  $_SESSION['sseite']=basename($_SERVER['PHP_SELF']);   // aktuelle Seite in SESSION speichern
?>

Nun folgt der eigentliche Beginn der (X)HTML-Seite:

  <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
  <html xmlns="http://www.w3.org/1999/xhtml" lang="de" xml:lang="de"> 
  <head>
  <meta http-equiv="content-type" content="text/html; charset=ISO-8859-1" /> 
  <link href="sessions.css" rel="stylesheet" type="text/css" />
  <title>Bini's Unterrichtsmaterial - PHP Sessions</title>
  </head>
  <body>
  <h1>Bini's Unterrichtsmaterial - PHP Sessions</h1>
  <h3>Interner Bereich</h3>

Im nächsten Schritt werden die Zugangsdaten geprüft und nur im positiven Fall kann das Programm ausgeführt werden. Liegt keine gültige SESSION mit den passenden Daten vor, so wird ein Link zum Login präsentiert.

  <?php	// Überprüfung der korrekten Zugangsdaten
  if (!($sname=='TestUser' and $spasswort=='1234') and !($sname=='Anton' and $spasswort=='austirol')) {
  echo "<p class='fehler'>Der Zugriff auf diese Seite ohne gültige Session ist unzulässig.<br />
  Sie sind nicht angemeldet!</p>";
  echo "<p><a href='login.php'>Hier geht's zum Login</a></p>";
  }

Ist kein Fehler innerhalb der SESSION aufgetreten, so wird das Programm ausgeführt. Es bietet weitere Links zu internen Seiten, die analog aufgebaut sind.

  else {// ----------------------------------------------	Zugangsdaten sind ok
  echo "<h4>Seite 1 - Startseite</h4>";
  echo "<p>Von nun an kann man sich mit dem aktuell angemeldeten<br />
  Benutzeraccount frei im internen Bereich bewegen.</p>
  <p>Sie haben sich mit dem Namen <strong>$sname</strong> angemeldet 
  und kommen von der Seite <strong>$alte_seite</strong>.
  <p><a href='seite2.php'>Hier geht's zur zweiten Seite.</a></p>
  <p><a href='seite3.php'>Hier geht's zur dritten Seite.</a></p>";

Außerdem steht noch eine Schaltfläche Logout zur Verfügung, die uns zur Login-Seite führt:

  
  echo "<form action='login.php' method='post'>";		// Button führt zur Login/Logoutseite
  echo "<input type='submit' name='logout' value='Logout'>";
  echo "</form>";
  }

Zum Schluss wird noch php geschlossen und die (X)HTML-Seite beendet:

  
  ?>
  </body>
  </html>

Einige Musterdateien stehen zum Probieren zur Verfügung:

		login.php
		seite1.php
		seite2.php
		seite3.php
		sessions.css

Sessions für Fortgeschrittene

Bei größeren Projekten ist es oft zweckmäßig die Überprüfung der SESSION-Daten mittels Funktion durchzuführen und diese mittels include() in die Datei einzubinden. Dabei können auch gleich die benötigten SESSION-Werte ausgelesen und in Variablen gespeichert werden. D.h. die Überprüfung erfolgt an zentraler Stelle und kann somit leichter verändert werden.

Hier die Musterdateien dazu:

		login.php
		seite1.php
		seite2.php
		seite3.php
		sessions.css
		sessions.fkt.php

Literatur

Agular, Robert R.
HTML für Kids
4. Aufl. - Heidelberg : bhv 2009
ISBN 9783826686726

Bornträger, Axel
MySQL - echt einfach
das kinderleichte Computerbuch
Poing : Franzis 2002
ISBN 377236196

Ferner, Jens
PHP Referenz:
Programmierung
1. Aufl. - Düsseldorf : Data Becker 2002
ISBN 3815816661

Franke, Jochen
Dynamische Webseiten mit PHP 4
echt einfach
Poing : Francis 2002
ISBN 3772378420

Hanke, Johann-Christian
PHP und MySQL Praxisbuch für Kids
2. Aufl. - Heidelberg : bhv 2008
ISBN 9783826686498

Hanke, Johann-Christian
PHP und MySQL für Kids
6. Aufl. - Heidelberg : bhv 2010
ISBN 9783826686740

Lawson, Bruce; Sharp, Remy
HTML5
1. Aufl. - München : Addison-Wesley 2011
ISBN 9783827330734

Lerdorf, Rasmus; dt. Übers.: Eimann, Raimund; Schulten, Lars
PHP
kurz & gut
2. Aufl. - Köln : O'Reilly 2003
ISBN 389721251

Maurice, Florence
HTML & CSS
1. Aufl. - München : markt + technik 2010
ISBN 9783827245786

Münz, Stefan; Gull, Clemens
HTML5-Handbuch
Poing : Francis 2010
ISBN 9783645600798

Reimers, Stefan; Thies, Gunnar
PHP 5 und MySQL 5
von den Grundlagen zur professionellen Programmierung ; aktu
1. Aufl. - Bonn : Galileo Press 2006
ISBN 3898426939

Schmid, Egon
PHP 4
[dynamische Webauftritte professionell realisieren
München : Markt und Technik 2001
ISBN 3827258774

Seibert, Björn; Hoffmann, Manuela
Professionelles Webdesign mit (X)HTML und CSS
[modernes Webdesign mit Webstandards ; Farbe, Grafik und Typ
1. Aufl. - Bonn : Galileo Press 2008
ISBN 9783836211048

Staas, Dieter
PHP 5
Espresso!
Poing : Franzis 2004
ISBN 3772361390

Sven, Letzl; Betz, Friedhelm
Jetzt lerne ich PHP 5 & MySQL 4.1
der schnelle Einstieg in die objektorientierte Webprogrammierung
München : Markt und Technik 2005
ISBN 3827265347

Yves, Ernst
HTML
in 10 Minuten zur eigenen HomePage
1. Aufl. - Düsseldorf : Data Becker 1996
ISBN 3815815606

Links