Sortierte Ausgabe von Dateien
Sortierte Ausgabe von Dateien
Der Befehl readdir() von PHP listet den kompletten Inhalt eines Verzeichnisses auf. Auch wenn es in bestimmten Implementierungen von PHP so aussieht, als wäre die Ausgabe entsprechend der "mtime" (Zeit der letzten Modiffikation) sortiert, so gibt es hierbei laut Sprachbeschreibung keine Regel. Man sollte also keinesfalls eine möglicherweise in einer bestimmen Implementierung vorhandene Eigenschaft benutzen. Bei einem Serverwechsel wäre dann zum Beispiel die Sortierreihenfolge anders.
Die Funktion filenames_in_directory($dir, $criteria, &$res, $order="ascending"), die im folgenden aufgelistet ist, gibt ein Array mit den Dateinamen (also nur die Dateinamen und keine Unterverzeichnisse) zurück. Ist der Parameter $order auf ascending gesetzt, werden die Namen in aufsteigender Ordnung sortiert, ansonsten werden sie in absteigender (descending) Sortierung zurückgeliefert.
Mit dem Parameter $criteria kann man bestimmen, ob man eine zeitliche Sortierung, also $criteria="time", oder eine alphabetische Sortierung, also $criteria="alpha", wünscht.
| function filenames_in_directory($dir, $criteria, &$res, $order="ascending") { $count =0; $handle=opendir($dir); while (($file = readdir($handle))!==false) { /* possible return values for filetype(): fifo, char, dir, block, link, file, unknown */ if (filetype("$dir/$file")=="file") { // no subdirectories e.g. // "if" makes sure that no subdirectories // and the directory "." and ".." are listed if ($criteria == "time") { $file_time = filemtime("$dir/$file"); // time of last modification $tfilenames[$file] = $file_time; } else if ($criteria == "alpha") { // alphabetical listing. $filenames[$count] = $file; } $count++; } } closedir($handle); $i = 0; |
Ein Aufruf des obigen Skriptes sieht wie folgt aus:
| $number_of_filenames_in_dir = filenames_in_directory($path, "time", &$files, "ascending"); while(list($key, $file) = each($files)){ echo "$file\n"; } |
Dabei werden alle Dateinamen des Unterverzeichnisses $path in zeitlich aufsteigender Reihenfolge ausgedruckt.
Formulare verarbeiten
Formulare verarbeiten
Formulare
Formulare bieten Anwendern die Möglichkeit Text in ein oder mehrzeiligen Eingabefeldern (Textfeldern) einzugeben und Einträge aus einer Auswahlliste auszuwählen.
Außerdem bietet ein Formular die Möglichkeit die eingegebenen Daten an ein Programm zur Weiterverarbeitung zu schicken.
Webformulare dienen verschiedenen Anwendungszwecken:
- Kontaktformular
- Umfragen
- Anmeldeformulare
- Bestellformulare
- usw.
Mit den dem Tag <form> ... </form> werden Formulare definiert und alles was zwischen den beiden Tags steht gehört zum Formular. Im <form> gibt es ein Pflichtattribut action das angibt, was mit dem Webformular zu tun ist, nachdem der Benutzer das Formular abgeschickt hat. Das Attribut method gibt an, wie die Übergabe der Daten zu erfolgen hat. Wählt man als Methode "get" werden die Daten hinter der URL der aufgerufenen Seite angehängt. "post" verschickt die Daten des Formulars über den Standardeingabekanals des Web-Servers. Die Post-Methode ist zum einen sicherer, da die Daten nicht für die Nutzer der Webseite sichtbar sind, andererseits eignet sich diese Methode besonders dann, wenn viele Parameter zu übertragen sind.
Am besten lässte sich dies an einem konkreten Beispiel demonstrieren: Wir erstellen ein einfaches Formular das den Vornamen, Nachnamen, das Alter und das Geschlecht einer Person erfrägt und dann entsprechend dem Alter und dem Geschlecht eine passende Begrüßung schreibt. Der folgende HTML-Code stellt ein solches Formular dar:
<html> |
Ansicht des obigen HTML-Codes:
Anmeldeformular: |
Wenn man den "Absenden"-Knopf drückt, wird das Programm willkommen.php, oder genauer in unserem Fall die URL http://www.problem-hilfe.de/linux/beispiele/willkommen.php aufgerufen.
Das PHP-Skript willkommen.php haben wir auch bewusst einfach gehalten, damit das Prinzip besser ersichtlich wird:
<html> |
Auf die Variablen des Formulars kann man in willkommen.php nicht direkt zugreifen, aber sie stehen in einem Array $_post. Der Zugriff erfolgt assoziativ über den Variablennamen. Also die Variable "firstname" des Formulars kann mit $_post["firstname"] angesprochen werden.
In Datei schreiben
Will man den gesamten Inhalt des $_POST-Arrays in eine Datei schreiben, so ist dies auch kein Problem. Wir benutzen dazu die in Datei schreiben von vorgestellte Funktion write_data().
Obiges Skript sieht dann wie folgt aus:
<? |
Datei lesen
Datei lesen
Am bequemsten geht dies mit der Funktion file(), allerdings nur, wenn man den ganzen Inhalt der Datei zeilenweise in einem Array zur Weiterverarbeitung benötigt.
file() liest eine komplette Datei zeilenweise in ein Array.
Achtung: Der Zeilenumbruch "\n" am Ende einer Zeile wird als letztes Zeichen in das jeweilige Array-Element übernommen.
Um den Zeilenumbruch oder andere möglicherweise für die Weiterverarbeitung nicht benötigte oder störende Steuerzeichen und Leerzeichen am Anfang und Ende einer Zeile zu entfernen, kann man die Funktion trim(), wie im folgenden Beispiel, verwenden:
| <? $Dateiname = 'test.php'; $Inhalt = file($Dateiname); // Bestimmung der Zeilenanzahl der Datei // Zeilen bearbeiten // ab hier andere Befehle zur Bearbeitung der Zeile ... |
Datei schreiben
Datei schreiben
Im Folgenden sehen wir, wie man Daten in eine Datei (file) schreibt.
Das folgende PHP-Skript ist ein einfaches Beispiel dafür:
<?php
|
Auch wenn die einzelnen Kommandos in dem Skript bereits erklärt sind, wollen wir uns die darin verwendeten Funktionen im Detail anschauen:
fopen()
Mit fopen() öffnet man eine Datei und zwar je nach Parameter in verschiedenen Modi , wie zum Beispiel Lesen oder Schreiben.
int fopen(string filename, string modus) |
Als Dateiname "filename" kann sowohl ein Dateiname mit oder ohne Pfad verwendet werden oder auch eine Datei, die sich irgendwo im Internet befindet, also "http://www.problem-hilfe.de/linux/h/PHP/Datei_schreiben.html". Im Internet befindliche Dateien können natürlich in der Regel nur lesend und nicht schreibend geöffnet werden.
Für den Modus gibt es viele verschiedene Möglichkeiten, die in der folgenden Tabelle zusammengestellt sind:
| w | Die angegebene Datei wird zum Schreiben geöffnet und falls die Datei bereits existiert, wird der alte Inhalt überschrieben, d.h. gelöscht. Anders ausgedrückt: Mit der Option "w" wird der Dateizeiger auf den Anfang der Datei gesetzt und die Länge der Datei auf 0 (also 0 Bytes) gesetzt. Existiert die Datei nicht, wird sie angelegt. Letzteres allerdings nur, wenn das Skript Schreibberechtigung in dem Verzeichnis hat, in das die Datei geschrieben werden soll. |
| a | Es gilt das für die Option "w" gesagte. Einen Unterschied gibt es nur, falls die Datei bereits existiert. Dann werden die Daten ans Ende der Datei angehängt, d.h. der Dateizeiger wird ans Ende des Files gesetzt. |
| r | Die angegebene Datei wird zum Lesen geöffnet. Der Dateizeiger - anderes würde wohl keinen Sinn ergeben - wird an den Anfang des Files gesetzt. |
| r+ | Die angegebene Datei wird zum Lesen und Schreiben geöffnet. Der Dateizeiger wird an den Anfang des Files gesetzt. Existiert die Datei nicht, wird sie nicht angelegt! |
| w+ | Wie r+, allerdings wird versucht eine nicht existierende Datei anzulegen. |
| a+ | Wie w+, allerdings wird der Dateizeiger an das Ende des Files gesetzt. |
Beispiele für fopen():
$fp = fopen("beispiel_daten.txt", "r") // Dateiname ohne Pfad bzw. relativer Pfad
$fp = fopen("/home/tux/beispiel_daten.txt", "r") // Dateiname mit abslutem Pfad$fp = fopen("http://www.was-weiss-ich-domain.de/beispiel.txt", "r") // Datei befindet sich im Internet |
fwrite()
Mit dem Befehl fwrite() kann man Daten in eine Datei schreiben, die vorher mit fopen() geöffnet wurde.
int fwrite(int fp, string daten [,int laenge]) |
"fp" bezeichnet den Dateizeiger (file pointer) der als Rückgabewert von fopen() geliefert wird. In den obigen Beispielen wurde er der Variablen $fp zugewiesen.
"daten" ist ein String in dem die zu schreibenden Daten stehen. Man kann optional, d.h. wenn man will, eine Länge "laenge" angeben. Damit sagt man, dass der String "daten" nur bis maximal laenge-Bytes in die Datei geschrieben wird.
fclose()
Jede Datei, die zuvor mit fopen() geöffnet worden ist, muss vor dem Ende des Skriptes mit fclose() geschlossen werden.
int fclose(int fp) |
Einziger Parameter des fclose()-Befehls ist der Dateizeiger fp.
Funktion zum Schreiben eines Array-Inhaltes in eine Datei
Wir stellen nun eine Funktion vor, mit der man ein komplettes Array in eine Datei schreiben kann:
<?
|
Wichtig: Das Verzeichnis, in das "test.txt" geschrieben werden soll, muss die entsprechende Schreibberechtigung haben!
Funktionen
Funktionen
Eine höhere Programmiersprache ohne Funktionen ist nicht denkbar. Sobald man größere Programme erstellt, kommt es immer wieder vor, dass sich Code wiederholt, d.h. der Code ist gleich bis auf verschiedene Werte.
if ($a >= $b) { |
Wie man leicht sehen kann enthält $ergebnis nach Ausführung der if-Anweisung den Wert der Variablen mit dem höchsten Wert.
Stellen wir uns nun vor, dass an einer anderen Stelle eines größeren Programmes folgender Code steht:
if ($x >= $y*7) { |
Wenn $y * 7 größer als $x ist, enthält $Ergebnis nach der Ausführung der if-Anweisung den Wert $y * 7 ansonsten den Wert von $x.
Funktion:
Eine Funktion besteht aus einem Funktionskopf und einem Funktionsrumpf. Der Funktionskopf seinerseits besteht aus dem Schlüsselwort function, welches dem Interpreter sagt, dass eine Funtionsdefinition beginnt. Dann folgt der frei wählbare Name der Funktion. Gültige Funktionsnamen müssen mit einem Unterstrich "_" (underscore) oder einem Buchstaben beginnen, danach können weitere Buchstaben, Ziffern oder der Unterstrich in beliebiger Reihenfolge kommen.
Nach dem Namen folgt zwischen einem runden Klammernpaar eine mittels Kommata separierte Parameterliste, d.h. die Werte und Variablen, die an den Funktionsrumpf übergeben werden. Der Funktionskopf bestimmt, wie die Funktion aufgerufen wird, nämlich ähnlich wie in der Funktionsdefinition aber ohne das Schlüsselwort function.
Im Funktionsrumpf befindet sich der Code, der bei einem Aufruf ausgeführt wird. Eine Funktion muss sicherstellen, dass sie jeweils mit einer return-Anweisung endet. In der Return-Anweisung steht das Ergebnis der Funktions, was an die aufrufende Stelle zurückgegeben wird.
function funktionsname(parameter1,parameter2,...) { |
Für die beiden eingangs aufgeführten if-Anweisungen schreiben wir die Funktion maxn(), die wir in ein komplettes Programm einbetten, dass man die Berechnung nachvollziehen kann:
<?
|
Anmerkung: Der Name maxn statt max wurde benutzt, da es schon eine Funktion in PHP mit dem Namen max gibt.
Speichert man obiges Skript unter dem Namen maxn.php und ruft man das Programm mit "php5 maxn.php" auf erhält man folgende Ausgabe:
|
Parameterübergabe
Aufruf durch Wertübergabe (Call by Value)
Auf einen Aspekt sind wir bisher noch nicht eingegangen: In der obigen Funktion maxn gibt es Parameter mit den Variablennamen $x und $y, ebenso gibt es im aufrufenden Hauptprogramm zwei Variablen $x und $y. Es stellt sich die Frage, ob die Variable $x innerhalb der Funktion die gleiche ist, wie das $x des Hauptprogramms. In der Funktion maxn können wir allerdings dies nicht feststellen, da es prinzipiell egal ist, da $x und $y im Funktionsrumpf nicht verändert werden. Wir schauen uns deshalb eine andere Funktion an:
|
Führt man dieses Programm (in Datei g_var.php) aus, erhält man folgende Ausgabe:
> php5 function2.php |
Wäre die Variable $x innerhalb der Funktion die gleiche wie außerhalb, so hätte sie nach dem Aufruf den Wert 18 und nicht 3, wie obiger Aufruf zeigt.
Das heißt ganz allgemein, dass bei PHP beim Aufruf einer Funktion normalerweise eine Wertübergabe (call by value) erfolgt. Anders ausgedrückt: Falls ein gleicher Name innerhalb und außerhalb existiert, bezeichnen sie dennoch verschiedene Speicherstellen.
Referenzübergabe (Call by Reference)
Manchmal will man aber, dass innerhalb einer Funktion eine bestimmte Variable verwendet und auch mit wirkung nach außen hin verändert wird. Will man diesen Effekt, so setzt man nur ein Et-Zeichen "&" vor die entsprechende Variable. Betrachten wir folgendes veränderte Beispiel:
<?
|
Was wird jetzt wohl für $x und $y ausgegeben? Man kann es sich so vorstellen, als würde beim Aufruf der Funktion g_var jedes Vorkommen der Variablen $x durch die entsprechende Variable des Aufrufs ersetzt. Korrekter ist es, wenn man sich vorstellt, dass die Variable $x auf die gleiche Speicherstelle wie die Variable im Aufruf zeigt.
Man erhält deshalb folgende Ausgabe:
> php5 function3.php |
Rekursive Funktionen
Eine sehr elegante Methode zur Lösung bestimmter Probleme stellt die rekursive Programmierung dar. Man spricht von einer rekursiven Funktion, wenn in ihrem Rumpf wieder ein Aufruf "von sich selbst" erfolgt.
Als Paradebeispiel für solche Funktionen wird in der Informatik die Fakultätsfunktion verwendet. Die Fakultät stammt aus der Kombinatorik . Sie dient dazu die Anzahl von verschiedenen Permutationen zu berechnen.
Mathematische Definition einer Permutation: Unter einer Permutation (lateinisch permutare - vertauschen) versteht man eine Neuanordnung einer Anordnung einer Menge durch Vertauschung ihrer Elemente. Hat man zum Beispiel die Menge der Buchstaben a, b, c und d und die Anordnung abcd, dann handelt es sich bei acbd um eine Permutation von abcd.
Die Menge aller Permutationen von abcd findet man im nächsten Diagramm:
| a | b | c | d |
| d | c | ||
| c | b | d | |
| d | b | ||
| d | b | c | |
| c | b | ||
| b | a | c | d |
| d | c | ||
| c | a | d | |
| d | a | ||
| d | a | c | |
| c | a | ||
| c | a | b | d |
| d | b | ||
| b | a | d | |
| d | a | ||
| d | a | b | |
| b | a | ||
| d | a | b | c |
| c | b | ||
| b | a | c | |
| c | a | ||
| c | a | b | |
| b | a |
Wenn man sich obiges Diagramm anschaut, sieht man, dass mit jeder der 4 Buchstaben der ersten Spalte mit jeweils genau 3 Buchstaben kombiniert werden kann, also "a" z.B. mit "b", "c" und "d". Jedes Element (jeder Buchstabe) der zweiten Spalte kann mit jeweils zwei anderen Buchstaben kombiniert werden. Für die Buchstaben in der dritten Zeile bleibt nur noch genau eine Kombinationsmöglichkeit übrig. Wir sehen, dass wir 24 Zeilen in der vierten Spalte haben, was auch der Anzahl der Permutationen entspricht. Die Anzahl der Permutationen errechnet sich auch, wie wir eben gesehen haben, aus dem Produkt 4 * 3 * 2 * 1.
Hätten wir 5 Buchstaben genommen, hätten wir 5*4*3*2*1 = 120 verschiedene Permutationen.
Ganz allgemein gilt: n Objekte lassen sich n*(n-1)* ... * 2 * 1 Mal kombinieren. Für dieses Produkt hat man in der Mathematik die Schreibweise n! eingeführt, d.h. n! ist eine abkürzende Schreibweise für n*(n-1)* ... * 2 * 1.
Es gilt: n! = n * (n-1)! für n > 1
Damit hat man das Problem reduziert, d.h. wenn man das Ergebnis von (n-1)! kennt, kann man durch Multiplikation mit n das Ergbnis von n! berechnen.
0! ist als 1 definiert.
Die Fakultätsfunktion:
<?
|
Obige Funktion darf natürlich nur für ganze Zahlen die größer oder gleich Null sind aufgerufen werden. In diesem Fall ist sichergestellt, dass die Funktion terminiert, denn in jedem Schritt wird fac() mit einem um 1 verminderten Parameter aufgerufen, und zwar solange bis der Parameter 0 ist. Iterativ sieht ein Programm, welches die Fakultätsfunktion berechnet sofort komplizierte und vor allem weniger elegant aus:
<? |
Schleifen
Schleifen
Allgemeines
Eine Schleife im täglichen Leben: Nehmen wir an, jemand baut ein Haus und beschäftigt eine Hilfskraft. Vor dem Grundstück liegt eine Menge von Steinen, die an eine andere Stelle, z.B. der 1. Stock des Rohbaus, befördert werden wollen. Sie geben nun folgende Anweisung:
Solange Steine an der Straße liegen, nimm' einen und trage ihn in den ersten Stock.
Hier haben wir alle Eigenschaften, die wir auch in den Schleifen von Programmiersprachen finden. Einen Anfang, die Anweisung, was immer wieder zu tun ist, bis das Endekriterium - keine Steine mehr - erreicht ist.
Schleifen in PHP
In PHP gibt es drei verschiedene Arten von Schleifen, die sich in ähnlicher Form übrigens in fast allen Programmiersprachen finden:
- while
- do ... while
- for
while-Schleife
Eine while-Schleife hat den folgenden allgemeinen Aufbau:
while (Bedingung) {
|
Solange die Bedingung in dem runden Klammernpaar den Wert "true" ergibt, werden die Anweisungen zwischen den geschweiften Klammern ausgeführt. Nach jedem Durchlauf wird wieder die Bedingung geprüft. Das heißt, innerhalb der Schleife muss etwas mit den Variablen passieren, die in der Bedingung vorkommen, ansonsten würde die Schleife ewig laufen.
Betrachten wir zum Beispiel folgendes Beispiel:
# Ausgabe der Zahlen von 0 bis 99 |
Die Idee von obigem Programmteil ist eigentlich, alle Zahlen von 0 bis einschließlich 99 zu drucken, wie der Kommentar behauptet. Aber es fehlt eine entscheidende Anweisung innterhalb der Schleif, nämlich das Hochzählen der Schleifenvariablen $i.
# Ausgabe der Zahlen von 0 bis 99$i = 0; |
Da die Anweisung $i = $i + 1 sehr häufig Verwendung findet, hat man dafür eine verinfachte Schreibweise eingeführt, nämlich $i++.
for-Schleife
Für Schleifen der obigen Art (Zählschleifen) eignen sich übrigens die for-Schleifen besser, denn mit Ihnen lässt sich ein Fehler der obigen Art vermeiden. Ganz allgemein sieht die for-Schleife wie folgt aus:
for (Anfangswert; Bedingung; Schrittweite) {
|
Die Zahlen von 0 bis 99 schreibt man mit Hilfe von for wie folgt:
for ($i=0; $i < 100; $i++) {
|
do...while-Schleife
Die do-while-Schleife ist eigentlich völlig analog zur while-Schleife, allerdings wird der Body (Schleifenrumpf, d.h. die Anweisungen innerhalb der geschweiften Klammern) mindestens einmal ausgeführt und die Bedingung wird erst nach dieser Ausführung geprüft.
do {
while (Bedingung) |
So
Verzweigungen, oder: if-then-else
Verzweigungen
Als Verzweigungen (auch Kontrollstrukturen genannt) kennt PHP das "if-else"-Konstrukt und das "switch".
if
Verzweigungen kennen wir auch im täglichen Leben: Angenommen sie wollen von Dingelsstadt nach Hintertupfingen fahren, dann machen Sie zum Beispiel vorher folgenden Plan: Wenn bis Schönstadt wenig Verkehr ist, wollen Sie weiterhin über die Autobahn fahren, ansonsten würden Sie einen Schleichweg über Bundes- und Landstrßen nehmen.
Also
| if (nicht viel Verkehr bis Schönstadt) weiter über Autobahn bis Hintertupfingen else weiter über Bundes- und Landstraßen bis Hintertupfingen |
Beim Programmieren könnte man sich zum Beispiel folgende einfache Programmieraufgabe vorstellen. Ein Kunde erhält von einer Firma, wenn er für mindestens 10.000,- Euro im Jahr bestellt hat einen Sonderrabatt von 3%, wenn er unter 10.000,- bleibt nur von 2 %.
Nehmen wir an, dass der Umsatz in der Variablen $Umsatz gespeichert ist:
| if ($Umsatz >= 10000) { $Sonderrabatt = $Umsatz * 0.03; } else { $Sonderrabatt = $Umsatz * 0.02; } |
In der Variablen $Sonderrabatt steht nach der Ausführung der if-Anweisung der Betrag des Sonderrabattes.
Die geschweiften Klammern sind in obigem Beispiel (jeweils nur eine Anweisung) nicht notwendig, aber es gehört zu einem guten Stil, wenn man sie auch in solchen Fällen benutzt. Damit kann man möglichen Fehlern bei Erweiterungen eines Programmes vorbeugen.
Im folgenden, vielleicht etwas realistischeren, Beispiel lernen wir "elseif" kennen.
Ein Vertreter erhält in Abhängigkeit seines Umsatzes eine Provision und zwar:
| Umsatz | Provisionsbetrag bzw. Prozentsatz |
| kleiner 20000,- € | 2.000,- € (Fixum) |
| 20.000,- bis 50.000,- € | 12 % |
| 50.000,- bis 100.000,- € | 14 % |
| ab 100.000,- € | 15 % |
In PHP sieht das wie folgt aus:
| if ($Umsatz < 20000) { $Provision = 2000; } else if ($Umsatz < 50000) { $Provision = $Umsatz * 0.12; }else if ($Umsatz < 100000) { $Provision = $Umsatz * 0.14; }else { $Provision = $Umsatz * 0.15; } |
Statt dem obigen "else if" gibt es in PHP auch die Möglichkeit "elseif" zu schreiben, allerdings nicht in Fällen, wie dem obigen.
switch
Eine weitere Möglichkeit der Verzweigung in PHP bietet die switch-Anweisung. Sie ist gleichbedeutend mit einer Hintereinanderschaltung von if-Anweisungen mit gleichem Parameter.
Die switch-Anweisung ersetzt also if-Konstrukte der folgenden Art:
if ($Variable == "value1") { |
Obigen Programmteil kann man mit dem switch-statement etwas einfacher und übersichtlicher formulieren:
switch($Variable) { case "value1": case "value2": case "value3": |
Vergleichsoperatoren
Vergleichsoperatoren
Vergleichsoperatoren sind Operatoren, mit deren Hilfe man zwei Werte vergleichen kann.
Wiederholung: Bei dem Kapitel über Zuweisung habe wir bereits gelernt, dass ein Ausdruck der Form $a = $b nicht bedeutet, dass der Wert der Variablen $a gleich dem Wert der Variablen $b ist. Ein einfaches Gleichheitszeichen bedeutet, dass der Wert des Ausdrucks auf der rechten Seite unter dem Namen der Variablen auf der linken Seite gespeichert wird. In dem Beispiel "$a = $b" hat natürlich anschließend die Variable $a den gleichen Wert als $b.
Gleichheitsoperator (Ist-Gleich):
Um einen Vergleich auf Gleichheit durchzuführen benutzt man ein doppeltes Gleichheitszeichen, also
$a == $b Dabei können natürlich auch ganze Ausdrücke auf Gleichheit geprüft werden:
($a - 5*$c) == ($b * 3) -17
Ist der Vegleich zutreffend, d.h. die beiden Ausdrücke sind gleich, dann wird der Wert "true" (wahr) zurückgegeben ansonsten "false" (falsch).
Alle Vergleichs-Operatoren im Überblick:
== |
Gleich | Zwei Ausdrücke werden auf Gleichheit überprüft |
!= |
ungleich | Zwei Ausdrücke werden auf Ungleichheit überprüft. Wenn die beiden Ausdrücke verschieden sind, wird true zurückgegeben, ansonsten false. |
> |
größer | Es wird geprüft, ob der Ausdruck links vom ">"-Zeichen größer ist als der rechts davon. Wenn ja, wird true zurückgegeben ansosnten false. |
< |
kleiner | Es wird geprüft, ob der Ausdruck links vom "<"-Zeichen kleiner ist als der rechts davon. Wenn ja, wird true zurückgegeben ansosnten false. |
>= |
größer gleich | Es wird geprüft, ob der Ausdruck links vom ">="-Zeichen größer oder gleich ist als der rechts davon. Wenn ja, wird true zurückgegeben ansosnten false. |
<= |
kleiner gleich | Es wird geprüft, ob der Ausdruck links vom "<="-Zeichen kleiner oder gleich ist als der rechts davon. Wenn ja, wird true zurückgegeben ansosnten false. |
=== |
identisch | Zwei Ausdrücke werden wie bei "==" auf Gleichheit geprüft, aber zusätzlich wird noch geprüft, ob die Variablen auch noch den gleichen Typ haben. Hat man zum Beispiel folgende Anweisungen in einem Programm: $a = 0; $b = ""; // d.h. der leere String dann liefert $a == $b true zurück, während das dreifache Gleichheitszeichen false zurückliefert. |
!== |
nicht identisch | Wenn zwei Ausdrücke nicht vom gleichen Typ sind oder nicht im Sinne von "==" gleich sind, liefert dieser Operator true zurück ansosnten false. |
Was man mit diesen Vergleichsoperatoren anfangen kann, lernt man im Kapitel über Verzweigungen, insbesondere "if"-Konstruktor, kennen.
Arrays
Arrays
Einführung
Arrays bieten eine elegante Möglichkeit mehrere Variablen eines Types untern einem Namen zu speichern.
Im Abschnitt über Variablen hatten wir die Variablen im Vergleich mit einer Kommode eingeführt. Nun stellen wir uns vor, dass die Kommode nicht mehr dem ganzen Speicher des Rechners, sondern nur einer Sammlung von Variablen gleichen Typs entspricht. Die ganze Kommode entspricht also genau einem Array und jede Schublade entspricht einem Element dieses Arrays.
Wenn es nur eine Kommode in einer Wohnung gibt, ist es durchaus sinnvoll unser Array (unsere Kommode) einfach nur "Kommode" zu nennen, oder besser gesagt $Kommode, denn alle Variablen, also auch Arrays, beginnen in PHP mit einem Dollarzeichen.
Den Inhalt einer Schublade, also z.B. der dritten Schublade, sprechen wir nun mit $Kommode[3] an.
In allen Ausdrücken, in denen eine Variable des gleichen Typs stehen kann, kann auch ein Element eines Arrays stehen.
Beispiele:
Nehmen wir an in $Kommode stehen Zahlen (z.B. integer):
if ($Kommode[3] ==3) {
$a = $b +7 - $Kommode[4];
}
Bei unserem Kommodenbeispiel haben wir mit 1 angefangen zu zählen, weil dies mehr unserer natürlichen Vorstellung entspricht. Wir sprechen von der "1. Schublade" oder der "3. Schublade". Allerdings beginnen Arrays meistens mit 0. Daran muss man sich gewöhnen, wenn man noch nie programmiert hat. Informatiker beginnen halt mit 0 zu zählen, also 0, 1, 2, usw.
Man kann sich ein Array auch als zweispaltige Tabelle vorstellen. Stellen wir uns beispielsweise ein Array vor, dass die Wochentage (also Strings) enthält:
| Index (oder key) | Wert (oder value) |
| 0 | Montag |
| 1 | Dienstag |
| 2 | Mittwoch |
| 3 | Donnerstag |
| 4 | Freitag |
| 5 | Samstag |
| 6 | Sonntag |
Obige Tabelle wollen wir nun einem Array mit dem Namen $Woche zuordnen:
$Woche = array ("Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag", "Sonntag"); |
Die Anweisung echo $woche[0];gibt den String "Montag" aus.
Die Zuweisung der Wochentage zum Array hätte man auch wie folgt machen können:
$Woche[0] = "Montag";$Woche[1] = "Dienstag";$Woche[2] = "Mittwoch";$Woche[3] = "Donnerstag";$Woche[4] = "Freitag";$Woche[5] = "Samstag";$Woche[6] = "Sonntag"; |
Eine wichtige Funktion, die man bei der Behandlung von Arrays häufig braucht, ist count().
Will man alle Array-Elemente ausgeben, kann man dies mit einer for-Schleife machen:
for ($i = 0; $i < count($Woche); $i++) { |
Assoziative Arrays
In den bisherigen Beispielen hatten wir als Indizes nur ganze Zahlen verwendet. Was, wenn der Index selbst z.B. ein String ist, wie zum Beispiel in folgender Tabelle, in der einem jeweiligen englischen Wochentag sein deutsches Äquivalent gegenübersteht:
| Index (oder key) | Wert (oder value) |
| Monday | Montag |
| Tuesday | Dienstag |
| Wednesday | Mittwoch |
| Thursday | Donnerstag |
| Friday | Freitag |
| Saturday | Samstag |
| Sunday | Sonntag |
Auch dies lässt sich in PHP leicht realisieren, im Gegensatz zu einer Programmiersprache wie C oder C++. In PHP sind zu diesem Zweck sogenannte assoziative Arrays (manchmal auch Hashs genannt) implementiert.
Folgende Zeile erledigt obige Zuordnung der Wochentage:
$ED_Woche = array ("Monday"=>"Montag", "Tuesday"=>"Dienstag", "Wednesday"=>"Mittwoch", "Thursday"=>"Donnerstag", "Friday"=>"Freitag", "Saturday"=>"Samstag", "Sunday"=>"Sonntag"); |
Ein solches assoziatives Array lässt sich aber nicht mehr mit einer einfachen Zählschleife, wie der for-Schleife, ausgeben. Dazu bietet PHP das foreach-Konstrukt:
foreach ($ED_Woche as $en => $de) { |
Man kann auch mehrdimensionale assoziative Arrays (multidimensional associative arrays) bilden, wenn man als Elemente jeweils wieder assoziative Arrays wählt.
Beispiel: Mitarbeiter einer Firma:
| Herbert Meyer | Telefon | 23546 |
| Abteilung | K12 | |
| Eintrittsjahr | 1997 | |
| Marja McCoy | Telefon | 23634 |
| Abteilung | E34 | |
| Eintrittsjahr | 2002 | |
| Swen Fidelity | Telefon | 23301 |
| Abteilung | K07 | |
| Eintrittsjahr | 1990 |
Ein lauffähiges PHP-Programm, welches obige Tabelle als multidimensionales assoziatives Array implementiert, findet man im nächsten Diagramm:
<?
|
Wenn man obiges Skript in einer Datei multi_array.php speichert und mit "php5 multi_array.php" in einer Shell von Kommandozeile startet, sollte man folgende Ausgabe erhalten:
|
Variablen und Zuweisungen
PHP Syntax
Im folgenden führen wir die wichtigsten Sprachkonstrukte von PHP auf.
Kommentare:
Mit "//" oder "#" kann man einen einzeiligen Kommentar in PHP markieren. Ab dieser Zeichenfolge werden alle Zeichen bis zum Ende einer Zeile ignoriert.
| print $res; // Diese Ausgabeanweisung druckt das Ergebnis der Rechnung aus. |
Mehrzeilige Kommentare werden wir in der Programmiersprache C markiert:
| /* Dieser Text ist ein mehrzeiliger Kommentar, der vom PHP-Interpreter ignoriert. Ansonsten würde dieser Text zu einer Fehlermeldung führen. */ |
Variablen:
Alle Variablen beginnen in PHP mit einem Dollarzeichen ($). Der dem Dollarzeichen nachfolgende Name muss entweder mit einem Unterstrich (_) oder mit einem Buchstaben (egal ob groß oder klein) beginnen. Danach kann eine beliebige Kette von Buchstaben, Zahlen und Unterstrichen folgen. Achtung: Das heißt auf jeden Fall, dass insbesondere Leerzeichen und Bindestriche in Variablennamen verboten sind.
Beispiele für gültige Variablennamen:
| $a $_ende $B53ANFANG $Zeileninhalt |
So, nun haben wir gelernt, wie ein gültiger Variablenname aufgebaut ist. Aber was ist eigentlich eine Variable. Variablen kann man sich wie "Behälter" oder "Schubladen" in einem Computer vorstellen, in die er bestimmte "Dinge", d.h. z.B. Ziffern, Zahlen und Zeichenketten hineinlegen und wieder herausnehmen kann.
Den Speicher eines Computers könnte man sich so als einen Schrank mit vielen Schubladen vorstellen. Die Schubladen des Schrankes der Abbildung sind der Einfachheit halber in $Erste (1. Schublade), $Zweite (2. Schublade) usw. benannt.
Man kann nun einem Haushaltshelfer klare Anweisungen geben:
- Lege diese Socken in die erste Schublade oder "Lege sie in $Erste"
- Hol' alles aus Schublade $Drei heraus und schmeiß' es weg. Anschließend räum' den Inhalt von Schublade$Vier hinein.
- Nimm den Inhalt von $Erste heraus und lege ihn in $Zweite hinzu.
- usw.
Hat man statt Socken z.B. die Zahl 17, so sieht die 1. Anweisung in PHP wie folgt aus:
$Erste = 17;
Das obige Gleichheitszeichen ist also nicht mathematisch als Gleichheit zu interpretieren, sondern muss wie folgt verstanden werden:
"Tue das, was auf der rechten Seite des Gleichheitszeichen beschrieben steht und lege dann das Ergebnis als Inhalt der Variablen auf der linken ab."
In anderen Worten: Die Dinge rechts vom Gleichheitszeichen kommen in die auf der linken Seite bezeichneten Schublade. Falls in dieser Schublade schon vorher etwas gelegen hatte, so schmeiße es vorher (also bevor die neuen Dinge hereinkommen) weg.
Achtung: Hinter jeder Anweisung in PHP muss ein Strichpunkt stehen. Ansonsten erfolgt eine Fehlermeldung. Dies ist ein beliebter Fehler in PHP.
Die zweite Anweisung der obigen Liste in PHP lautet:
$Drei = $Vier;
Die dritte Anweisung der obigen Liste lässt sich wie folgt in PHP übersetzen:
$Zweite = $Zweite + $Erste;
Falls also zum Beispiel in $Zweite 3 Paar Socken lagen und in $Erste 4 Paar Socken, dann befinden sich anschließend 7 Paar Socken in $Zweite und die Schublade $Erste ist leer.