SmileMan's Blogger

19Nov/110

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;
if ($criteria == "time") {
if ($order == "ascending") {
asort($tfilenames);
} else {
arsort($tfilenames);
}
while(list($key, $val) = each($tfilenames)){
$res[$i] = $key;
$i++;
}
}  else if ($criteria == "alpha") {
if ($order == "ascending") {
asort($filenames);
} else {
arsort($filenames);
}
while(list($key, $val) = each($filenames)){
$res[$i] = $val;
$i++;
}
}
return $i;
}

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.

veröffentlicht unter: PHP keine Kommentare
19Nov/110

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>
<head>
<meta content="text/html; charset=ISO-8859-1"
http-equiv="content-type">
<title>Werte aus Formularen</title>
</head>
<body>
<h2>Anmeldeformular:</h2>
<FORM action="willkommen.php" method="post">
<P>
Vorname:  <INPUT type="text" name="firstname"><BR>
Nachname: <INPUT type="text" name="lastname"><BR>
<LABEL for="email">Alter: </LABEL>
<INPUT type="text" name="age"><BR>
<INPUT type="radio" name="sex" value="male">männlich<BR>
<INPUT type="radio" name="sex" value="female">weiblich<BR>
<INPUT type="submit" value="Absenden"> <INPUT type="reset">
</P>
</FORM><br>
</body>
</html>

Ansicht des obigen HTML-Codes:

Anmeldeformular:

Vorname:
Nachname:

männlich

weiblich

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>
<head>
<meta content="text/html; charset=ISO-8859-1"
http-equiv="content-type">
<title>Willkommen</title>
</head>
<body>
<h1>Willkommen</h1>
<br>
Hallo
<?
/*
echo $_POST["firstname"];
echo $_POST['sex'];
echo $_POST['lastname'];
*/
if  ( $_POST['age'] < 16 ) {
echo $_POST['firstname'];
} elseif ( $_POST['sex'] == "male") {
echo " Herr " . $_POST['lastname'];
} else {
echo " Frau " . $_POST['lastname'];
}

?>
<br>

</body>
</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:

<?
function write_data($data, $fname) {
$fp = fopen($fname, "w");

foreach ($data as $key => $value) {
// echo "$key: $value\n";
fwrite($fp, "$key: $value\n");
}

fclose($fp);
}
?>
<html>
<head>
<meta content="text/html; charset=ISO-8859-1"
http-equiv="content-type">
<title>Willkommen</title>
</head>
<body>
<h1>Willkommen</h1>
<br>
Hallo
<?

if  ( $_POST['age'] < 16 ) {
echo $_POST['firstname'];
} elseif ( $_POST['sex'] == "male") {
echo " Herr " . $_POST['lastname'];
} else {
echo " Frau " . $_POST['lastname'];
}
$res = write_data($_POST,"post.txt");
if ($res) {
echo "<br>\nEs gab Probleme beim Speichern!";
} else {
echo "<br>\nDaten des Formulars wurden in post.txt gespeichert!";
}

?>
<br>

</body>
</html>

veröffentlicht unter: PHP keine Kommentare
19Nov/110

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
$AnzahlZeilen = count($Inhalt);

// Zeilen bearbeiten
for ($i = 0; $i < $AnzahlZeilen; $i++) {
// entfernen von "carriage return" und/oder "line feed character"
$Zeile = trim($Inhalt[$i]);

// ab hier andere Befehle zur Bearbeitung der Zeile ...
}
?>

veröffentlicht unter: PHP keine Kommentare
19Nov/110

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

$daten = "Dieser Text steht nachher in der Datei!";

// Festlegen des Dateinamens
$datei_name = "test_datei.txt";

/*
Die Datei wird zum schreiben geöffnet
und falls der Dateiname bereits vorhanden ist,
wird der komplette alte Inhalt vorher gelöscht!
*/
$fp = fopen($datei_name, "w");

/*
Daten in Datei schreiben.
Dieser Befehl kann widerholt aufgerufen werden.
*/
fwrite($fp, $daten);

// Die Datei wird geschlossen.
fclose($fp);

?>

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("../php-beispiele/beispiel.txt", "w")  // Dateiname mit relativem Pfad

$fp = fopen("http://www.was-weiss-ich-domain.de/beispiel.txt", "r")  // Datei befindet sich im Internet

$fp = fopen("ftp//benutzer/passwort@was-weiss-ich-domain.de/bsp.txt", "r")  // Zugriff mit FTP

 

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:

<?

function write_data($data, $fname) {

$fp = fopen($fname, "w");

foreach ($data as $key => $value) {
// echo "$key: $value\n";
fwrite($fp, "$key: $value\n");
}

fclose($fp);
}

$test["l"]= "Linux";
$test["i"] = "ist";
$test["s"] = "super";
write_data($test, "test.txt");

?>

Wichtig: Das Verzeichnis, in das "test.txt" geschrieben werden soll, muss die entsprechende Schreibberechtigung haben!

veröffentlicht unter: PHP keine Kommentare
19Nov/110

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) {
$ergebnis = $a;
} else {
$ergebnis = $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) {
$ergebnis = $x;
} else {
$ergebnis = $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,...) {
... Anweisungen inklusive einer return-Anweisung...
}

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:

<?

function maxn($x, $y) {
if ($x >= $y) {
$ergebnis = $x;
} else {
$ergebnis = $y;
}
return $ergebnis;
}

$a = 3;
$b = 4;
$x = 12;
$y = 2;
$ergebnis = maxn($a, $b);
echo "$ergebnis\n";
$ergebnis = maxn($x, $y*7);
echo "$ergebnis\n";

?>

 

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:


> php5 function.php
4
14
>

 

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:


<?

function g_var($x) {
$x = 18;
echo "Wert von x in gvar: $x\n";
return 0;
}

$x = 3;
echo "Wert von x vor Aufruf g_var: $x\n";
g_var($x);
echo "Wert von x nach Aufruf g_var: $x\n";

?>

Führt man dieses Programm (in Datei g_var.php) aus, erhält man folgende Ausgabe:

> php5 function2.php
Wert von x vor Aufruf g_var: 3
Wert von x in gvar: 18
Wert von x nach Aufruf g_var: 3
>

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:

<?

function g_var(&$x) {
$x = 18;
echo "Wert von x in gvar: $x\n";
return 0;
}

$x = 3;
echo "Wert von x vor Aufruf g_var: $x\n";
g_var($x);
echo "Wert von x nach Aufruf g_var: $x\n";
$y = 4;
echo "Wert von y vor Aufruf g_var: $y\n";
g_var($y);
echo "Wert von y nach Aufruf g_var: $y\n";

?>

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
Wert von x vor Aufruf g_var: 3
Wert von x in gvar: 18
Wert von x nach Aufruf g_var: 18
Wert von y vor Aufruf g_var: 4
Wert von x in gvar: 18
Wert von y nach Aufruf g_var: 18
>

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:

Permutation von abcd
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:

<?

# rekursive Version:
function fac ($n) {
if ($n == 0) {
return 1;
} else {
return fac($n - 1) * $n;
}
}

# einlsesn des Argumentes von der Shell
$in = fscanf(STDIN, "%d\n");

$res = fac($in[0]);
echo "fac($in[0]) = $res\n";

?>

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:

<?
# iterative Version:
function fac_iterativ($n) {
$fac=1;
for ($i=2; $i <= $n; $i++) {
$fac = $fac * $i;
}
return $fac;
}

$in = fscanf(STDIN, "%d\n");

$res = fac_iterativ($in[0]);
echo "fac_iterativ($in[0]) = $res\n";

?>

veröffentlicht unter: PHP keine Kommentare
19Nov/110

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) {

# Anweisungen
}

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
$i = 0;
while ($i < 100) {
echo "Wert von i: $i\n";
}

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;
while ($i < 100) {
echo "Wert von i: $i\n";
$i = $i + 1;
}

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) {

# Anweisungen
}

Die Zahlen von 0 bis 99 schreibt man mit Hilfe von for wie folgt:

for ($i=0; $i < 100; $i++) {

# Anweisungen
}

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 {

# Anweisungen
}
while (Bedingung)

So

veröffentlicht unter: PHP keine Kommentare
19Nov/110

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") {
# Anweisungen
} elseif ($Variable == "value2") {
# Anweisungen
} elseif ($Variable == "value3") {
# Anweisungen
} else {
# Anweisungen
}

Obigen Programmteil kann man mit dem switch-statement etwas einfacher und übersichtlicher formulieren:

switch($Variable) {
   case "value1":
# Anweisungen
break;
   case "value2":
# Anweisungen
break;

   case "value3":
# Anweisungen
break;
default:
# Anweisungen
break;
}
veröffentlicht unter: PHP keine Kommentare
19Nov/110

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.
 

veröffentlicht unter: PHP keine Kommentare
19Nov/110

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++) {
echo "$Woche[$i]\n";
}

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) {
echo "$en - $de\n";
}

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:

<?

$Firma = array (
"Meyer"=>array("Telefon"=>"23546", "Abteilung"=>"K12", "Beitritt"=>1997),
"McCoy"=>array("Telefon"=>"23634", "Abteilung"=>"E34", "Beitritt"=>2002),
"Fidelity"=>array("Telefon"=>"23422","Abteilung"=>"K07", "Beitritt"=>1990)
);

foreach ($Firma as $name=>$data) {
echo "$name:\n";
foreach ($data as $key=>$num) {
echo " - $key $num\n";
}
}

?>

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:


Meyer:
- Telefon 23546
- Abteilung K12
- Beitritt 1997
McCoy:
- Telefon 23634
- Abteilung E34
- Beitritt 2002
Fidelity:
- Telefon 23422
- Abteilung K07
- Beitritt 1990

 

veröffentlicht unter: PHP keine Kommentare
19Nov/110

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

Schrank mit SchubladenSo, 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:

  1. Lege diese Socken in die erste Schublade oder "Lege sie in $Erste"
  2. Hol' alles aus Schublade $Drei heraus und schmeiß' es weg. Anschließend räum' den Inhalt von Schublade$Vier hinein.
  3. Nimm den Inhalt von $Erste heraus und lege ihn in $Zweite hinzu.
  4. 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.

veröffentlicht unter: PHP keine Kommentare