Inhalt
A Einführung
B HTML für PHP
C Strukturierte Programmierung mit PHP
D Bearbeitung von Formularen
E Datenbanken mit MySQL
F Programmierung von MySQL–Datenbanken mit PHP
G Text-Dateien
H Arrays
I Mathematische Funktionen
J Zeichenketten-Funktionen
K Neu in PHP 4
L HTML
M Anhang
N Lösungen
Index
Download (ca. 3,4 MB)
<< zurück | Galileo Computing / <openbook> / PHP 4 | vor >>
PHP 4 von Thomas Theis Webserver-Programmierung für Einsteiger
| Kapitel C Strukturierte Programmierung mit PHP
|  | C.1 Einbettung von PHP in HTML
|  | C.2 Variablen und Datentypen
|  | C.3 Verzweigungen
|  | C.4 Schleifen
|  | C.5 Funktionen
# Kapitel C Strukturierte Programmierung mit PHP In diesem Abschnitt werden die Elemente vorgestellt, die der strukturierten Programmierung mit PHP dienen. Dies sind u. a.: Datentypen, Variablen, Operatoren, Kontroll-Strukturen und Funktionen. ## C.1 Einbettung von PHP in HTML Es gibt mehrere Wege, PHP-Programme in HTML-Dateien einzubetten, u. a.: <?php ... ?>
| in Kurzform innerhalb einer Markierung:
<?php [PHP-Anweisungen] ?>
| in etwas längerer Form zwischen einer Anfangsmarkierung und einer Endmarkierung:
<script language = "php"> [PHP-Anweisungen] </script> Sequentielle Bearbeitung Falls man einen HTML-Editor benutzt, um das Grundgerüst der Web-Seite schneller erstellen zu können, läuft man in Einzelfällen Gefahr, dass die Kurzform nicht erkannt und vom Editor gelöscht wird. Unabhängig davon, welche Form man bevorzugt, werden die PHP-Anweisungen sequentiell abgearbeitet und durch ein Semikolon voneinander getrennt. PHP-Programme können sowohl vollständig innerhalb des Dokument-Kopfes (head) als auch vollständig innerhalb des Dokument-Rumpfes (body) einer HTML-Seite untergebracht werden. Sie dürfen allerdings nicht im head beginnen und erst im body enden. Die gesamte Datei wird von oben nach unten abgearbeitet, es kann mehrmals zwischen HTML und PHP gewechselt werden. Das nachfolgende Beispiel zeigt einige der genannten Möglichkeiten: Der Programmcode mit HTML- und PHP-Elementen: Listing C.1 Datei uc01.php
    <html>
    <head>
    <title> Titelzeile der Datei </title>
    </head>

    <body>
    Die erste Zeile in HTML <p>
    <?php echo "Die zweite Zeile in PHP<p>"; ?>
    Die dritte Zeile in HTML <p>

    <script language="php">
       echo "Die vierte Zeile in PHP<p>";
       echo "Die fünfte Zeile in PHP<p>";
    </script>

    Die sechste Zeile in HTML <p>

    <?php
       echo "Die siebte Zeile in PHP<p>";
       echo "Die achte Zeile in PHP<p>";
    ?>

    </body>
    </html>
Abbildung C.1 Die erste PHP-Seite
echo Die PHP-Anweisung echo gibt den angegebenen Text auf dem Bildschirm aus. Der Text muß in Anführungsstrichen geschrieben werden. Falls der Text HTML-Markierungen beinhaltet (hier <p> für einen Absatzumbruch), so gelangen diese zur Ausführung. ### C.1.1 Kommentare /* ... */ oder // Mit Hilfe von Kommentaren wird ein Programm lesbarer. Kommentare werden nicht ausgeführt, sondern dienen nur zur Information für den Entwickler, besonders bei umfangreichen Programmen. Man unterscheidet zwischen einzeiligen und mehrzeiligen Kommentaren, wie im folgenden Programm gezeigt. Listing C.2 Datei uc02.php
    <html>
    <body>

    <?php
       echo "Das ist der Anfang";    // Kommentar
                                     // bis zum Zeilenende
       /* Ein Kommentar über
          mehrere Zeilen hinweg */
       echo " und hier das Ende des Programmes";
    ?>

    </body>
    </html>
#### Übung UC03 Schreiben Sie ein PHP-Programm innerhalb einer Web-Seite (Datei uc03.php). Mit Hilfe des echo-Befehles soll ausgegeben werden: »Dieses Programm wurde geschrieben von Max Müller«. Schreiben Sie zu der PHP-Anweisung eine Kommentarzeile. Speichern Sie die Datei im Hauptverzeichnis Ihres Webservers, und testen Sie das Programm, indem Sie einen Browser aufrufen und die passende Adresse eingeben. Zur Erinnerung:
| Bei der Beispiel-Installation für Linux ist das Hauptverzeichnis des Webservers /usr/local/httpd/htdocs. Als Adresse ist http://localhost einzugeben.
| Bei der Beispiel-Installation für Windows 98 mit dem Apache Web Server ist das Hauptverzeichnis des Webservers c:\apache\htdocs. Als Adresse ist http://localhost einzugeben.
| Bei der Beispiel-Installation für Windows 98 mit dem MS Personal Web Server ist das Hauptverzeichnis des Webservers c:\pws. Als Adresse ist http://thomas einzugeben.
## C.2 Variablen und Datentypen Datentypen Innerhalb eines Programms können Informationen zur späteren Verwendung in Variablen gespeichert werden. Diese Variablen unterscheiden sich nach ihren Datentypen. PHP unterstützt Datentypen für:
| ganze Zahlen
| Zahlen mit Nachkommastellen
| Zeichenketten (Strings)
| Arrays (ein- und mehrdimensionale Felder von Variablen)
| Objekte
Keine Deklaration Der Datentyp für eine Variable wird nicht vom Programmierer festgelegt, sondern richtet sich nach dem Zusammenhang, in dem die Variable genutzt wird. Eine Variable kann ihren Datentyp innerhalb eines Programmes wechseln. Im Unterschied zu vielen anderen Programmiersprachen findet in PHP keine Variablen-Deklaration statt. Dies bedeutet, dass eine Variable bei ihrem ersten Erscheinen sofort benutzt werden kann und dem Programm nicht vorher bekannt gemacht werden muss. Zunächst geht es um die sogenannten »einfachen Datentypen« (Zahlen und Zeichenketten), mit denen viele Aufgaben im Zusammenhang mit der Programmierung bereits erledigt werden können. Im Vertiefungsteil kommen dann die Arrays und Objekte hinzu. ### C.2.1 Namen Regeln für Namen Für die Namen von Variablen (und später auch Funktionen) gelten einige Regeln:
| Sie müssen mit einem Dollar-Zeichen beginnen.
| Sie dürfen keine Leerzeichen enthalten.
| Sie dürfen nur aus Buchstaben und Ziffern bestehen, dabei sollte das erste Zeichen ein Buchstabe sein; es sind Groß- und Kleinbuchstaben erlaubt. Es wird zwischen Groß- und Kleinschreibung unterschieden ($HokusPokus ist nicht das gleiche wie $hokuspokus)
| Sie dürfen keine deutschen Umlaute oder scharfes ß enthalten.
| Sie dürfen als einziges Sonderzeichen den Unterstrich »_« enthalten.
| Sie dürfen nicht mit einem reservierten Wort identisch sein, also z. B. mit einem Befehl aus der Sprache PHP.
Man sollte selbsterklärende Namen vergeben. Das hat den Vorteil, dass sich jeder, der sich später mit dem Programm befasst, sofort zurechtfinden kann. Einige Beispiele: $Startmeldung, $Temperaturwert, $XKoordinate, $Ywert. ### C.2.2 Variablen und Operatoren für Zahlen Betrachten wir einmal das folgende Programm: Listing C.3 Datei uc04.php
    <html>
    <body>

    <?php
       $a = 14;
       $b = 8.3;
       $c = $a + $b;
       echo $c;
    ?>

    </body>
    </html>
Zahlen-Variablen Die Aufgabe dieses Programmes ist die Addition von zwei Zahlen und die Ausgabe der Summe dieser beiden Zahlen. Dies wird wie folgt durchgeführt:
| Die Variable $a wird eingeführt, und es wird ihr der Wert 14 zugewiesen, wodurch $a zu einer Variablen für eine ganze Zahl wird.
| Die Variable $b wird eingeführt, und es wird ihr der Wert 8.3 zugewiesen, also wird $b zu einer Variablen für eine Zahl mit Nachkommastellen (die Verwendung des Dezimalpunktes ist obligatorisch).
| Die Variable $c wird eingeführt, $a und $b werden addiert und das Ergebnis wird $c zugewiesen, damit wurde $c ebenfalls zu einer Variablen für eine Zahl mit Nachkommastellen.
| Der Wert von $c, also 22.3, wird ausgegeben.
Eine Zahl mit Nachkommastellen kann auch als sogenannte »Exponentialzahl« ausgedrückt werden. Im o. a. Programm hätte man eine der folgenden Schreibweisen verwenden können, dies hätte zum gleichen Ergebnis geführt: $b = 0.83e1; (dies bedeutet 0.83 mal 10 hoch 1, also 0.83 mal 10)
    $b = 83e-1;
(dies bedeutet 83 mal 10 hoch –1, also 83 mal 0.1) #### Arithmetische Operatoren Grundrechenarten Bei Zahlen können die folgenden Rechen-Operatoren (= arithmetischen Operatoren) verwendet werden:
Operator | Bedeutung
+ | Addition
- | Subtraktion
* | Multiplikation
/ | Division
% | Modulo, Rest bei einer ganzzahligen Division, z. B. ergibt 7%3 den Wert 1, denn 7 durch 3 ergibt 2 Rest 1
#### Ein weiteres Beispiel Ein Programm mit einer etwas umfangreicheren Berechnung: Listing C.4 Datei uc05.php
    <html>
    <body>

    <?php
       $a = 4;
       $b = 3.1;
       $c = 2e-1;
       $d = 2;
       $e = ($c + $a * $b) / $d + 15;
       echo $e;
    ?>

    </body>
    </html>
Es ist zu beachten, dass (wie in der Mathematik üblich) Multiplikation und Division eine höhere Priorität als Addition und Subtraktion haben, also zuerst ausgeführt werden. Außerdem findet bei Berechnungsausdrücken die Bearbeitung von links nach rechts statt. Mit dem Setzen von Klammern kann der Entwickler allerdings die Reihenfolge beeinflussen. Ausdrücke in Klammern werden zuerst vollständig ausgerechnet, das Ergebnis fließt später in die restliche Berechnung ein. Zum vorliegenden Programm: Die Variablen $a, $b, $c und $d werden eingeführt und mit Werten belegt, bei $c ist dies der Wert 0.2. Die Variable $e wird wie folgt errechnet:
| $a wird mit $b multipliziert (ergibt 12.4).
| $c wird zu diesem Ergebnis addiert (ergibt 12.6).
| Dieses Ergebnis, also das Ergebnis der Klammer, wird durch $d geteilt (ergibt 6.3).
| Dieses Ergebnis wird zu 15 addiert (ergibt 21.3).
#### Übung UC06 Berechnen Sie das Ergebnis des nachfolgenden Ausdruckes in einem PHP-Programm (Datei uc06.php). Dabei soll $a den Wert 4 und $c den Wert 2 haben. Speichern Sie die Datei im Hauptverzeichnis Ihres Webservers, und testen Sie das Programm, indem Sie einen Browser aufrufen und die Adresse http://localhost/uc06.php eingeben. Zur Kontrolle: Das Ergebnis hat den Wert -1.75. Der Ausdruck lautet :
    Ergebnis = 7 / $a + $c – 5.5 * (3 – $c)
### C.2.3 Variablen und Operatoren für Zeichenketten Strings Zeichenketten (Strings) müssen in doppelte Hochkommata (" ") oder in einfache Hochkommata (' ') eingeschlossen werden. Verkettung Das Zeichen . (Punkt) dient zur Verkettung mehrerer Zeichenketten miteinander bzw. mehrerer Zahlen und Zeichenketten. Dies wird z. B. für eine kommentierte Ergebnisausgabe genutzt. Der Operator .= (Punkt gleich) kann zur Vergrößerung einer Zeichenkette eingesetzt werden. Falls die Zeichenketten HTML-Code enthalten, so gelangt dieser HTML-Code zur Ausführung. Ein Beispiel-Programm: Listing C.5 Datei uc07.php
    <html>
    <body>
    <?php
       $a = 5;
       $b = 6;
       $c = $a + $b;
       $anrede = "Herrn";
       $vorname = "Hans";
       $ganzername = $anrede . " " . $vorname . " ";
       $nachname = 'Maier';
       $ganzername .= $nachname;
       echo "Dieses Programm ist von $ganzername<p>";
       echo "Das Ergebnis der Addition ist " . $c . "<p>";
       echo "Das geht auch so: $c <p>";
       echo 'Aber nicht so:  $c';
    ?>

    </body>
    </html>
Zur Erläuterung:
| Im ersten Teil des Programmes findet eine Addition statt (mit $a, $b und $c).
| Den Variablen $anrede, $vorname und $nachname werden an unterschiedlichen Stellen des Programmes als Werte drei Zeichenketten in einfachen Hochkommata bzw. in doppelten Hochkommata zugewiesen.
| Der Variablen $ganzername wird der Wert »Herrn Hans » zugewiesen.
| Dieser Wert wird später um die Zeichenkette »Maier« verlängert.
Die Ausgabe sieht wie folgt aus:
Abbildung C.2 Variablen-Namen in Zeichenketten
In den beiden ersten Ausgabezeilen werden Zeichenketten zusammen mit Zahlenvariablen bzw. Zeichenkettenvariablen und HTML-Code ausgegeben. Dabei werden die einzelnen Teile der ausgegebenen Zeile durch den Operator . (Punkt) miteinander verkettet. Der Wert einer Variablen wird auch dann ausgegeben, falls die Variable innerhalb einer Zeichenkette untergebracht wurde. Bei dieser Form ist allerdings darauf zu achten, daß die Zeichenkette in doppelte Hochkommata gesetzt wurde. Den Unterschied erkennt man an den beiden letzten Ausgabezeilen. #### Übung UC08 Schreiben Sie das Programm aus der vorherigen Übung um (Datei uc08.php). Es soll die nachfolgende Ausgabe erzeugen. Dabei sollen die unterstrichenen Zahlen vom Programm errechnet werden:
    $a hat den Wert 4

    $c hat den Wert 2

    Der Ausdruck lautet : 7 / $a + $c – 5.5 * (3 – $c)
    Das Ergebnis dieses Ausdruckes ist -1.75
Speichern Sie die Datei im Hauptverzeichnis Ihres Webservers, und testen Sie das Programm, indem Sie einen Browser aufrufen und die Adresse http://localhost/uc08.php eingeben. ### C.2.4 Umwandlung von Zeichenketten in Zahlen Umwandlung Bei der Umwandlung einer Zeichenkette (Konvertierung) ist der Beginn der Zeichenkette wichtig. Falls die Zeichenkette mit gültigen numerischen Zeichen beginnt, so werden diese numerischen Zeichen genutzt. Anderenfalls wird der Wert 0. Eine gültige Folge von numerischen Zeichen beinhaltet:
| ein Vorzeichen (optional)
| eine oder mehrere Ziffern
| einen Dezimalpunkt (optional)
| einen Exponent (optional), der Exponent ist ein kleines "e" oder ein großes "E", gefolgt von einer oder mehreren Ziffern
Die Zeichenkette wird interpretiert als:
| ganze Zahl, falls sie nur Ziffern beinhaltet
| Zahl mit Nachkommastellen, falls sie neben den Ziffern die Zeichen "." (Punkt), "e" oder "E" beinhaltet
Einige Beispiele:
Zeichenkette | Wert | Datentyp
"352" | 352 | ganze Zahl
"352xz" | 352 | ganze Zahl
"xz352" | 0 | Zeichenkette
"35.2" | 35.2 | Zahl mit Nachkommastellen
"35.2xz" | 35.2 | Zahl mit Nachkommastellen
"xz35.2" | 0 | Zeichenkette
"-352" | –352 | ganze Zahl
"35e2" | 3500 | Zahl mit (möglichen) Nachkommastellen
"35e-2" | 0.35 | Zahl mit Nachkommastellen
Falls man Zeichenketten-Variablen der Sicherheit halber explizit (also vom Programm-Entwickler gesteuert) in Zahlen umwandeln möchte, kann man die beiden Funktionen doubleval() bzw. intval() anwenden. Ein kleines Beispiel für zwei Umwandlungen:
       $a = "435";
       $a = intval($a);
       $b = "22.6";
       $b = doubleval($b);
Nach Bearbeitung dieses Programmteiles stehen die Variablen $a und $b auf jeden Fall als Zahlen-Variablen mit dem ganzzahligen Wert 435 bzw. dem Wert 22,6 für weitere Berechnungen zur Verfügung. ## C.3 Verzweigungen Bisher wurden die Dateien mit dem HTML-Code und dem PHP-Code rein sequentiell abgearbeitet, d. h., eine Anweisung nach der anderen wurde durchgeführt. Tatsächlich sind aber Programme auch in der Lage, auf unterschiedliche Bedingungen zu reagieren. Einzelne Anweisungen werden nur in bestimmten Situationen ausgeführt. Bedingung Die Ausführung dieser Anweisungen wird in solchen Fällen von einer oder mehreren Bedingungen abhängig gemacht. Je nachdem, ob die Bedingung zutrifft, werden die entsprechenden Anweisungen ausgeführt oder nicht. Darüber hinaus können bei Nichterfüllung der Bedingung alternative Anweisungen bearbeitet werden. Man nennt diese Stellen in Programmen »Verzweigungen«. Bedingungen werden mit Hilfe von Wahrheitswerten (wahr oder falsch bzw. true oder false) und Vergleichs-Operatoren erstellt. Eine Tabelle der Vergleichs-Operatoren schließt sich an. Vergleichs-Operatoren
Operator | Bedeutung | gilt
== | Gleichheit | für Zahlen und Zeichenketten
!= | Ungleichheit | für Zahlen und Zeichenketten
> | größer als | nur für Zahlen
< | kleiner als | nur für Zahlen
>= | größer oder gleich als | nur für Zahlen
<= | kleiner oder gleich als | nur für Zahlen
### C.3.1 Verzweigung mit if if Ein Beispiel für eine Verzweigung: Listing C.6 Datei uc09.php
    <html>
    <body>

    <?php
       $a = 7;
       $b = 12;
       if ($a < $b) echo "$a ist kleiner als $b";
    ?>

    </body>
    </html>
Falls $a kleiner als $b ist, wird der entsprechende Text in das Dokument geschrieben, ansonsten geschieht nichts. Die Bedingung selber ($a < $b) muss in Klammern stehen. Ein weiteres Beispiel: Listing C.7 Datei uc10.php
    <html>
    <body>

    <?php
       $a = 7;
       $b = 12;
       if ($a < $b)
       {
          echo "$a ist kleiner als $b <BR>";
          echo "$b ist größer als $a";
       }
    ?>

    </body>
    </html>
{ ... } Falls aufgrund einer Bedingung mehrere Anweisungen ausgeführt werden sollen, so müssen sie innerhalb von geschweiften Klammern stehen. In diesem Programm werden zwei Ausgaben erzeugt, da $a kleiner als $b ist. Die HTML-Markierung <BR> steht für einen einfachen Zeilenumbruch (ohne Abstand zur Vorgängerzeile wie beim <P>). ### C.3.2 Verzweigung mit if und else if-else Ein Beispiel für eine if-else-Verzweigung: Listing C.8 Datei uc11.php
    <html>
    <body>
    <?php
       $a = 5;
       $b = 12;

       if ($a < $b)
       {
          echo "$a ist kleiner als $b<BR>";
          echo "$b ist größer als $a";
       }

       else
       {
          echo "$a ist größer oder gleich $b<BR>";
          echo "$b ist kleiner oder gleich $a";
       }

    ?>
    </body>
    </html>
Falls die Bedingung hinter dem if nicht zutrifft, werden die Anweisungen hinter dem else ausgeführt. Auch hier gilt, dass bei mehreren Anweisungen geschweifte Klammern benutzt werden müssen. Die Ausgabe sieht wie folgt aus:
Abbildung C.3 Verzweigung mit if und else
#### Übung UC11 Testen Sie das Beispiel auf Ihrem Rechner für alle möglichen Zahlenkombinationen ($a größer $b, $a gleich $b, $a kleiner $b). #### Übung UC12 Schreiben Sie ein Programm (Datei uc12.php), in dem mit if-else-Verzweigungen:
| zwei Zeichenketten auf Gleichheit (Operator ==) hin verglichen werden
| zwei Zeichenketten auf Ungleichheit (Operator !=) hin verglichen werden
| zwei gegebene Zahlen-Variablen mit Hilfe der Operatoren für »kleiner oder gleich« (<=) bzw. »größer oder gleich« (>=) miteinander verglichen werden
Als Folge der Vergleiche soll jeweils ein entsprechender Kommentar ausgegeben werden. Führen Sie die Vergleiche mehrmals mit unterschiedlichen Kombinationen von Variablen durch. Dazu muss momentan noch jeweils der PHP-Quellcode verändert werden. Im nächsten Abschnitt (Bearbeitung von Formularen) werden Sie Möglichkeiten zur Eingabe von Daten durch den Benutzer kennenlernen. Dann kann das Programm unverändert bleiben und der Entwickler kann deutlich sehen, wie sein Programm auf unterschiedliche Eingabewerte reagiert. ### C.3.3 Logische Operatoren Operatoren &&, || und ! Mit Hilfe der logischen Operatoren && (logisches UND) und || (logisches ODER) kann man mehrere Bedingungen miteinander verknüpfen. Mit Hilfe des Operators ! (logisches NICHT) kann man den Wahrheitswert von Bedingungen umdrehen. Ein Beispiel: Listing C.9 Datei uc13.php
    <html>
    <body>
    <?php
       $a = 8;
       $b = 12;
       $c = 24;

       /* Bedingung 1 */
       if ($a < $b && $b < $c)
       {
          echo "$a ist kleiner als $b, $b kleiner als $c, ";
          echo "also ist $a kleiner als $c<BR>";
       }

       /* Bedingung 2 */
       if ($b < $a || $b < $c)
          echo "$b ist kleiner als $a oder als $c<BR>";
       else
       {
          echo "$b ist größer oder gleich $a";
          echo "und größer oder gleich $c<BR>";
       }

       /* Bedingung 3 */
       if (!($a > $b))
          echo "$a ist nicht größer als $b<BR>";
    ?>
    </body>
    </html>
Mehrere Bedingungen Bedingung 1 trifft nur zu, falls beide Einzelbedingungen zutreffen (Und-Verknüpfung mit &&). Bedingung 2 trifft zu, falls eine der beiden Einzelbedingungen zutrifft (Oder-Verknüpfung mit ||). In Bedingung 3 wird der Wahrheitswert der Bedingung umgedreht (mit !). Falls sie wahr ist, wird sie falsch und umgekehrt. #### Übung UC13 Testen Sie das Beispiel auf Ihrem Rechner für alle möglichen Zahlenkombinationen. ### C.3.4 Rangordnung der Operatoren Rangordnung Ausdrücke mit mehreren Operatoren werden von links nach rechts aufgelöst unter Beachtung der Rangordnung. Nachfolgend eine Tabelle mit der Rangordnung der bisher verwendeten Operatoren. Es wird mit der höchsten Stelle der Rangordnung begonnen:
Operator | Bedeutung
() | Klammern
! - | logisches NICHT, negatives Vorzeichen
* / % | Multiplikation, Division, Modulo
+ - | Addition, Subtraktion
< <= > >= | kleiner, kleiner oder gleich, größer, größer oder gleich
== != | gleich, ungleich
&& | logisches UND
|| | logisches ODER
= | Zuweisung
Klammern stehen an der höchsten Stelle der Rangordnung. Mit ihrer Hilfe kann man die Rangfolge bei den Operatoren beeinflussen und Ausdrücke so bewerten, wie man es wünscht. Zusätzlich kann man Klammern verwenden, falls man sich bei der Rangfolge nicht sicher ist. ### C.3.5 Verzweigungen schachteln Verschachtelung Verzweigungen mit if und else lassen sich auch verschachteln, so dass eine mehrfache Verzweigung für mehr als zwei Fälle möglich wird. Ein Beispiel: Listing C.10 Datei uc14.php
    <html>
    <body>
    <?php
       $a = 17;
       $b = 12;

       if ($a < $b)
          echo "$a ist kleiner als $b";

       else
       {
          if ($a == $b)
             echo "$a ist gleich $b";
          else
             echo "$a ist größer als $b";
       }
    ?>
    </body>
    </html>
Falls $a kleiner als $b ist, trifft die erste Bedingung zu. Die restlichen Bedingungen müssen dann nicht mehr geprüft werden. Falls nicht, kann $a nur noch größer oder gleich $b sein. Dies wird in der nächsten Bedingung ($a == $b) geprüft. Falls diese auch nicht zutrifft, kann $a nur noch größer als $b sein. Bei der Überprüfung auf Gleichheit hin ist besonders auf das doppelte Gleichheitszeichen zu achten. Es handelt sich um eine Bedingung und nicht um eine Zuweisung. ### C.3.6 Weitere Auswahl-Möglichkeiten Außer den genannten Anweisungen für Verzweigungen existieren in der Sprache PHP noch die nachfolgenden Möglichkeiten. Sie sind als Alternativen zu sehen und bieten in bestimmten Fällen Vorteile. Weitere Informationen finden sich im PHP-Manual auf der CD. #### elseif elseif Die elseif-Anweisung ist eine andere Schreibweise für die Anweisungen else und if. Sie kann bei mehrfachen Verzweigungen eingesetzt werden. #### if : endif if : endif Die Schreibweise mit Doppelpunkt und endif kann anstelle der geschweiften Klammern eingesetzt werden. Die Syntax lautet folgendermaßen:
    if (Bedingung):
    [Anweisungen]
    endif;
#### switch case switch case Ein switch-Block kann bei mehrfachen Verzweigungen eingesetzt werden. Es folgt die Syntax:
    switch (Variable)
    {
     case [Fall 1]: [Anweisungen 1];
     case [Fall 2]: [Anweisungen 2];
     case [Fall 3]: [Anweisungen 3];
     default: [Anweisungen 4];
    }
#### switch : endswitch switch : endswitch Eine andere Schreibweise für einen switch-Block mit Doppelpunkt und endswitch. Die Syntax:
    switch (Variable):
     case [Fall 1]: [Anweisungen 1];
     case [Fall 2]: [Anweisungen 2];
     case [Fall 3]: [Anweisungen 3];
     default: [Anweisungen 4];
    endswitch;
## C.4 Schleifen Anweisungen wiederholen Falls sich innerhalb eines Programmes einzelne Anweisungen oder Blöcke von Anweisungen wiederholen, werden Schleifen verwendet. In PHP (wie in jeder anderen Programmiersprache) gibt es grundsätzlich zwei Möglichkeiten dazu. Welche Variante bei der Lösung des vorliegenden Problems die richtige ist, kann man leicht entscheiden.
Man verwendet die ... | in folgendem Fall
for-Schleife | Falls die Anzahl der Wiederholungen dem Programmierer bekannt ist oder sie sich eindeutig im Verlauf des Programmes vor der Schleife ergibt (Zähl-Schleife)
while-Schleife | Falls die Anzahl der Wiederholungen dem Programmierer nicht bekannt ist, sondern die Schleife aufgrund einer Bedingung wiederholt bzw. abgebrochen wird (bedingungsgesteuerte Schleife)
### C.4.1 for-Schleife for Die for-Schleife wird dazu benutzt, eine bestimmte Anzahl an Wiederholungen zu erzeugen. Entweder ist die Anzahl vorher bekannt oder kann errechnet werden. Ein Beispiel: Listing C.11 Datei uc15.php
    <html>
    <body>
    <?php
       for ($i=1; $i<=5; $i++)
       {
          echo "Zeile $i <p>";
       }
    ?>
    </body>
    </html>
Mit Hilfe des Programmes werden 5 Zeilen in das Dokument geschrieben, jeweils mit dem Inhalt: Zeile: <Nummer>. Die Ausgabe sieht wie folgt aus:
Abbildung C.4 for-Schleife
Die for-Schleife besteht aus Kopf und Rumpf. Der Kopf der for-Schleife besteht aus drei Teilen:
| Startwert
| Bedingung zur Wiederholung
| Veränderung der Schleifenvariablen
Schleifen-Variable In diesem Beispiel wird die Variable $i als sogenannte »Schleifenvariable« verwendet, d. h., mit Hilfe von $i wird die Schleife gesteuert. $i bekommt zunächst den Wert 1. Es wird geprüft, ob die Bedingung zur Wiederholung erfüllt ist. Ist dies der Fall, wird mit dem Anfangswert der Rumpf der Schleife durchlaufen, es ergibt sich also die Ausgabe Zeile: 1. Anschließend wird die Variable durch die Veränderung der Schleifenvariablen erhöht (auf 2). Bedingung zur Wiederholung Es wird geprüft, ob die Bedingung zur Wiederholung noch erfüllt ist. Ist dies der Fall, wird der Rumpf der Schleife mit dem Wert $i (Ausgabe Zeile: 2) durchlaufen usw. Nach dem 5. Durchlauf wird $i auf 6 erhöht. Damit trifft die Bedingung zur Wiederholung nicht mehr zu, das Programm beendet die Schleife und läuft dahinter weiter. Im vorliegenden Programm ist dann das Ende erreicht. $i++ Anmerkung: $i++ ist eine Kurzform der Zuweisung $i=$i+1. Häufig verwendet wird auch $i--, dies ist eine Kurzform der Zuweisung $i=$i-1, also eine Verminderung von $i um 1. Auch bei Schleifen gilt: Falls sich die Schleife auf mehrere Anweisungen bezieht, müssen diese in geschweifte Klammern gesetzt werden. Streng genommen wäre dies also beim o. g. Beispiel nicht notwendig gewesen, aber es schadet auch nicht. ### C.4.2 Beispiele für for-Schleifen Einige Beispiele für Schleifensteuerungen: aufwärts, abwärts
Kopf der for-Schleife | $i bekommt nacheinander die Werte
for ($i=10; $i<=15; $i++) | 10, 11, 12, 13, 14, 15
for ($i=10; $i<15; $i++) | 10, 11, 12, 13, 14
for ($i=10; $i>=5; $i--) | 10, 9, 8, 7, 6, 5
for ($i=10; $i>5; $i--) | 10, 9, 8, 7, 6
for ($i=3; $i<=22; $i=$i+3) | 3, 6, 9, 12, 15, 18, 21
for ($i=32; $i>12; $i=$i-4) | 32, 28, 24, 20, 16
for ($i=12; $i<13; $i=$i+0.2) | 12.0, 12.2, 12.4, 12.6, 12.8
$a=6, $b=16, $c=2; for ($i=$a; $i<$b; $i=$i+$c) | 6, 8, 10, 12, 14
Endlos-Schleife Man sollte immer darauf achten, daß nicht aus Versehen eine Endlos-Schleife erzeugt wird. Dies könnte man z. B. mit dem folgenden Schleifenkopf erreichen: for ($i=3; $i>2; $i=$i+3) Die Bedingung $i>2 ist für alle Zahlen, die erzeugt werden, erfüllt. Demnach wird diese Schleife niemals beendet, und das Programm hängt sich auf. #### Übung UC16 Schreiben Sie ein Programm (Datei uc16.php), in dem mit Hilfe von mehreren for-Schleifen die nachfolgend angegebenen Zeilen ausgegeben werden. Ein Tip: Für die letzte Zahlenreihe wird zusätzlich eine if-Bedingung benötigt.
Abbildung C.5 Verschiedene for-Schleifen
### C.4.3 Geschachtelte for-Schleifen Verschachtelung Schleifen können geschachtelt werden. Dabei befindet sich eine Schleife innerhalb einer anderen Schleife (Schachtelung). Dadurch wird später die Bearbeitung einer zweidimensionalen Struktur wie z. B. einer Tabelle (siehe HTML) oder eines zweidimensionalen Feldes (siehe ein- und mehrdimensionale Arrays) möglich. Ein Beispiel: Listing C.12 Datei uc17.php
    <html>
    <body>

    <?php
       for ($z=1; $z<=5; $z=$z+1)
       {
          for ($s=1; $s<=3; $s=$s+1)
          {
             echo "Ze$z/Sp$s ";
          }
          echo "<p>";
       }
    ?>

    </body>
    </html>
innen, außen Die erste (äußere) Schleife wird fünfmal durchlaufen. Innerhalb dieser Schleife steht wiederum eine (innere) Schleife, die bei jedem Durchlauf der äußeren Schleife dreimal durchlaufen wird. Anschließend wird ein Umbruch erzeugt. Es gibt insgesamt 5 mal 3 = 15 Wiederholungen. Die Programmausgabe sieht wie folgt aus:
Abbildung C.6 Geschachtelte for-Schleife
### C.4.4 while-Schleife while Die while-Schleife wird dazu benutzt, eine unbestimmte Anzahl an Wiederholungen zu erzeugen. Das Ende der Wiederholungen wird bei einem der Schleifendurchläufe erreicht, es kann nicht vorher errechnet werden. while-Schleifen werden häufig bei Datenbank-Abfragen eingesetzt (siehe Datenbanken mit MySQL). Zufallsgenerator Im nachfolgenden Beispiel wird gewürfelt, solange die Summe der gewürfelten Zahlen kleiner als 30 ist. Zum Erzeugen der Würfel-Ergebnisse wird der Zufallsgenerator von PHP verwendet. Dieser Zufallsgenerator muss zunächst initialisiert werden, damit er »tatsächlich zufällige« Ergebnisse produziert. Innerhalb der Schleife wird jeweils ein Würfel-Ergebnis erzeugt. Die dazu notwendigen Funktionen srand und rand werden im Verlauf dieses Buches noch näher erläutert (siehe mathematische Funktionen). Die Anzahl der Würfe ist sowohl dem Entwickler als auch dem Benutzer unbekannt, daher kann keine for-Schleife verwendet werden. Das Programm sieht wie folgt aus: Listing C.13 Datei uc18.php
    <html>
    <body>
    <?php
       srand((double)microtime()*1000000);
       $summe = 0;

       while ($summe < 30)
       {
          $zufallszahl = rand(1,6);       // Würfel
          $summe = $summe + $zufallszahl;
          echo "Zahl $zufallszahl, Summe $summe<p>";
       }

    ?>
    </body>
    </html>
Bedingung zur Wiederholung Die Bedingung zur Wiederholung muss in Klammern stehen. Bei der ersten Prüfung der Bedingung hat $summe noch den Wert 0, deshalb darf die Schleife durchlaufen werden. Innerhalb der Schleife wird die gewürfelte Zufallszahl zur Variablen $summe addiert. Die gewürfelte Zahl und die aktuelle Zwischensumme werden ausgegeben. Es wird wiederum daraufhin überprüft, ob die Summe noch kleiner als 30 ist. Ist dies der Fall, so wird die Schleife erneut durchlaufen. Anderenfalls wird mit der Anweisung hinter dem Schleifenende fortgefahren. Falls dort keine Anweisung mehr steht, ist das Programm zu Ende. Es wird also so lange (englisch: while) eine Zahl addiert, bis die Bedingung für die Wiederholung nicht mehr gilt. Die Seite hat z. B. folgendes Aussehen, natürlich abhängig von den zufällig ermittelten Werten:
Abbildung C.7 while-Schleife
### C.4.5 Schleifenabbruch mit break Schleifen-Abbruch Mit Hilfe der Anweisung break, kann eine Schleife vorzeitig beendet werden. Damit wird eine zusätzliche Möglichkeit für eine Schleifensteuerung geschaffen, die ein Programm unter Umständen besser lesbar machen kann. Eine break-Anweisung wird immer gemeinsam mit einer if-Bedingung auftreten, da der vorzeitige Abbruch einer Schleife nur in einem »Sonderfall« erfolgen sollte. Im nachfolgenden Beispiel wird wiederum gewürfelt, solange die Summe kleiner als 30 ist. Es soll allerdings maximal neun Mal gewürfelt (Sonderfall) und dann abgebrochen werden. Listing C.14 Datei uc19.php
    <html>
    <body>
    <?php
       srand((double)microtime()*1000000);
       $summe = 0;
       $zaehler = 0;

       while ($summe < 30)
       {
          $zufallszahl = rand(1,6);
          $summe = $summe + $zufallszahl;
          $zaehler = $zaehler + 1;
          echo "Nr. $zaehler, Zahl $zufallszahl,";
          echo " Summe $summe<p>";
          if ($zaehler >= 9) break;       // Sonderfall
       }

    ?>
    </body>
    </html>
Es wird ein zusätzlicher Zähler verwendet (Variable $zaehler). Diese Variable wird zunächst auf 0 gesetzt. Innerhalb der Schleife wird ihr Wert immer um 1 erhöht. Sie zählt also die Anzahl der Schleifendurchläufe. Falls dabei die Zahl 9 erreicht bzw. überschritten wird, bricht die Schleife unmittelbar ab. Dies geschieht auch dann, wenn die Summe noch kleiner als 30 ist. Bereiche angeben Anmerkung: Der Vergleich if ($zaehler == 9) hätte auch zu einem Abbruch geführt, allerdings nur bei einer Erhöhung um 1. Falls man in einem anderen Programm mit Hilfe einer anderen Veränderung der Schleifen-Variablen nicht genau den Wert 9 erreichen würde, so würde die Schleife über die vorgesehene Abbruch-Stelle hinausgehen. Daher arbeitet man an diesen Stellen normalerweise mit Bereichsangaben (>= oder <=). ### C.4.6 Weitere Schleifen-Anweisungen Außer den genannten Anweisungen für Schleifen existieren in der Sprache PHP noch die nachfolgenden Möglichkeiten. Sie sind als Alternativen zu sehen und bieten für bestimmte Fälle Vorteile: #### do-while do-while Die do-while-Schleife verhält sich wie eine while-Schleife, zusätzlich aber gilt: Die Schleife wird mindestens einmal durchlaufen. Die Syntax:
    do
    {
    [Anweisungen]
    }
    while(Bedingung);
#### foreach foreach Die foreach-Schleife wird besonders im Zusammenhang mit Feldern verwendet. Die Syntax:
    foreach([Array-Ausdruck])
    {
    [Anweisungen]
    }
#### continue continue Die Anweisung continue wird verwendet, um aufgrund einer Bedingung den Rest einer Schleife zu überspringen und unmittelbar mit dem nächsten Schleifendurchlauf fortzusetzen. ## C.5 Funktionen Vordefinierte Funktionen Es gibt in PHP zahlreiche vordefinierte Funktionen, die vom Entwickler eingesetzt werden können. Diese werden u.a in den Abschnitten »Mathematische Funktionen«, »Zeichenketten-Funktionen«, »Array-Funktionen« beschrieben. Darüber hinaus hat der Entwickler die Möglichkeit, eigene Funktionen zu schreiben. Dies bringt folgende Vorteile:
| Gleiche oder ähnliche Vorgänge müssen nur einmal beschrieben und können beliebig oft ausgeführt werden.
Modularisierung
| Programme werden dadurch modularisiert, d. h., sie werden in kleinere Bestandteile zerlegt, die übersichtlicher sind und einfacher gewartet werden können.
Ein Beispiel: Listing C.15 Datei uc20.php
    <html>
    <head>
    <?php
       function trennstrich()
       {
          echo "<br>";

          for ($i=1; $i<=40; $i=$i+1)
          {
             echo "-";
          }
          echo "<br>";
       }
    ?>
    </head>
    <body>
    <?php
       trennstrich();
       echo "Dies ist ein Programm,";
       trennstrich();
       echo "in dem mehrmals";
       trennstrich();
       echo "eine Funktion verwendet wird,";
       trennstrich();
       echo "die zu Beginn definiert wurde";
       trennstrich();
    ?>
    </body>
    </html>
Funktionen im HEAD Eigene Funktionen werden mit Hilfe von function ... () { ... } definiert. Der Name der Funktion folgt nach dem Schlüsselwort function, in runden Klammern folgen die Parameter (s. unten). Anschließend folgt in geschweiften Klammern der eigentliche Funktions-Rumpf. Meist wird dies im Kopf (head) eines HTML-Dokumentes durchgeführt, wie hier bei der Funktion trennstrich(). Aufgabe der Funktion trennstrich() ist die Darstellung von einem Zeilenumbruch, 40 Bindestrichen und wiederum einem Zeilenumbruch. Jedes Mal, wenn sie vom eigentlichen Programm im Rumpf (body) des Dokumentes aufgerufen wird (mit trennstrich()), führt sie die genannte Aufgabe aus. Die Seite hat das folgende Aussehen:
Abbildung C.8 Funktion, mehrfach verwendet
### C.5.1 Definition und Aufruf einer Funktion Falls der Entwickler bestimmte, nützliche Funktionen geschrieben hat, die er in mehreren Programmen verwenden möchte, so können diese Funktionen auch in externen Dateien untergebracht werden. Diese externen Dateien können mit den Anweisungen require bzw. include in die jeweiligen Programme eingebunden werden. Funktions-Aufruf Der Aufruf einer eigenen oder einer vordefinierten Funktion erfolgt häufig
| entweder aus dem Rumpf des Dokumentes heraus, im o. a. Beispiel mit: trennstrich()
| oder aus anderen Funktionen heraus.
Funktions-Definition Dabei ist der Ort der Funktions-Definition wichtig. Man kann nur Funktionen aufrufen, die dem Programm bekannt sind. Sie müssen also
| entweder zu den vordefinierten Funktionen gehören
| oder im Dokument definiert worden sein, wie im o. a. Beispiel,
| oder aus eigenen, externen Dateien stammen, die mit require bzw. include bereits eingebunden worden sind.
### C.5.2 Funktions-Typen Man unterscheidet dabei zwischen folgenden Funktionstypen:
| Funktionen ohne Parameter: Diese Funktionen führen bei jedem Aufruf immer genau die gleiche Aufgabe aus, wie im o. a. Beispiel
| Funktionen mit einem oder mehreren Parametern: Diese Funktionen führen bei jedem Aufruf in Abhängigkeit von den Parametern ähnliche Aufgaben aus.
| Funktionen mit Rückgabewerten: Diese Funktionen führen gleiche oder ähnliche Aufgaben aus und liefern ein Ergebnis an die aufrufende Stelle zurück.
Namen für Funktionen Für den Namen einer Funktion gelten die gleichen Regeln wie für den Namen einer Variablen. Der einzige Unterschied besteht darin, dass Namen von Funktionen nicht mit einem Dollar-Zeichen beginnen dürfen. Die Regeln wurden bereits im Abschnitt Variablen/Namen erwähnt (siehe dort). ### C.5.3 Funktionen mit einem Parameter Ein Parameter Eine Funktion mit einem Parameter führt bei jedem Aufruf in Abhängigkeit vom Parameterwert ähnliche Aufgaben aus. Das vorherige Beispiel wurde etwas erweitert, die Funktion erzeugt nun unterschiedlich lange Trennstriche, wie nachfolgend zu erkennen ist: Listing C.16 Datei uc21.php
    <html>
    <head>
    <?php
       function trennstrich($anzahl)
       {
          echo "<br>";

          for ($i=1; $i<=$anzahl; $i=$i+1)
          {
             echo "-";
          }
          echo "<br>";
       }
    ?>
    </head>
    <body>
    <?php
       trennstrich(30);
       echo "In diesem Programm,";
       trennstrich(40);
       echo "sind die Trennstriche";
       $x = 20;
       trennstrich($x);
       echo "unterschiedlich lang";
       trennstrich($x * 3);
    ?>
    </body>
    </html>
Abbildung C.9 Funktion mit einem Parameter
Die Funktion trennstrich() wird insgesamt vier Mal aufgerufen, jedes Mal mit einem anderen Wert in den Klammern hinter dem Funktionsnamen. Dies ist der Parameter; er kann eine Zahl, eine Variable oder das Ergebnis einer Berechnung sein. Er wird an die Funktion übergeben, dort wird dieser Wert in der Variablen $anzahl gespeichert. Der Wert von $anzahl steuert die Ausführung der for-Schleife mit dem Ergebnis, daß die Trennstriche unterschiedlich lang sind. Es wird also bei jedem Aufruf fast die gleiche Aktion durchgeführt, beeinflusst durch den Wert des Parameters. ### C.5.4 Funktionen mit mehreren Parametern Mehrere Parameter Falls einer Funktion mehrere Parameter übergeben werden, sind Anzahl und Reihenfolge der Parameter wichtig. Der erste Wert wird an den ersten Parameter, der zweite Wert an den zweiten Parameter übergeben usw. Ein Beispiel für eine eigene Funktion mit mehreren Parametern: Listing C.17 Datei uc22.php
    <html>
    <head>
    <?php
       function flexloop($von, $bis, $schritt)
       {
          echo "<br>Es folgt eine Schleife von $von";
          echo " bis $bis mit der Schrittweite $schritt<br>";

          for ($i = $von; $i <= $bis; $i = $i + $schritt)
          {
             echo "$i ";
          }
       }
    ?>
    </head>
    <body>
    <?php
       echo "<p>Nummer 1";
       flexloop(5,27,3);

       echo "<p>Nummer 2";
       flexloop(-10,10,4);

       echo "<p>Nummer 3";
       $x = 100;
       $y = 200;
       $z = 10;
       flexloop($x,$y,$z);

       echo "<p>Nummer 4";
       flexloop($x,$y,($y-$x)/20);
    ?>
    </body>
    </html>
Beim Aufruf der Funktion flexloop() müssen jeweils drei Parameter übergeben werden, und zwar durch Kommata voneinander getrennt. Diese werden in der vorliegenden Reihenfolge den Variablen $von, $bis und $schritt zugeordnet. Diese Variablen werden zur Steuerung der for-Schleife in der Funktion verwendet. Es wird also bei jedem Aufruf eine ähnliche Aktion durchgeführt, beeinflusst durch den Wert der Parameter. Die Ausgabe sieht folgendermaßen aus:
Abbildung C.10 Funktion mit mehreren Parametern
#### Übung UC23 Schreiben Sie ein Programm (Datei uc23.php), in dem eine Funktion av() definiert und benutzt wird, die den arithmetischen Mittelwert von drei Zahlen berechnet und ausgibt. Die drei Zahlen werden der Funktion als Parameter übergeben. Testen Sie die Funktion mit mehreren verschiedenen Aufrufen innerhalb des Programmes. Anmerkung: Der arithmetische Mittelwert von drei Zahlen wird berechnet, indem man die Summe der drei Zahlen durch drei teilt. #### Übung UC24 Schreiben Sie ein Programm (Datei uc24.php), in dem eine Funktion dev() definiert und aufgerufen wird, die vier Zeichenketten zu einem Satz zusammensetzt und ausgibt. Die vier Zeichenketten werden der Funktion als Parameter übergeben und beinhalten einen Vornamen, einen Nachnamen, einen Firmennamen und den Namen einer Stadt. Falls die Funktion wie folgt aufgerufen wird
    dev("Hans", "Maier", "Siemens", "Düsseldorf");
soll ausgegeben werden:
    Dieses Programm ist von Hans Maier, Firma Siemens in Düsseldorf
Testen Sie die Funktion mit mehreren verschiedenen Aufrufen innerhalb des Programmes. #### Übung UC25 Erweitern Sie das vorige Programm um einen fünften Parameter, in dem zusätzlich das Geschlecht übergeben wird (Datei uc25.php). Falls dieser Parameter den Wert 1 hat, so soll der Satz lauten: "Dieses Programm wurde entwickelt von Frau ....... " Falls dieser Parameter den Wert 2 hat, so soll der Satz lauten: "Dieses Programm wurde entwickelt von Herrn ...... " Ein Beispiel für einen Aufruf könnte lauten: dev("Julia", "Maier", "Siemens", "Düsseldorf", 1); Sie müssen dazu innerhalb der Funktion eine if-else-Abfrage durchführen. Die Ausgabe könnte wie folgt aussehen:
Abbildung C.11 Funktion mit mehreren Zeichenketten als Parameter
### C.5.5 Rückgabewert Ergebnisse zurückliefern Funktionen mit Rückgabewert dienen dazu, ein Ergebnis zu ermitteln und dieses an die aufrufende Stelle zurückzuliefern. Der zurückgelieferte Wert muss entweder in einer Variablen gespeichert oder direkt ausgegeben oder anderweitig festgehalten werden, ansonsten geht er verloren. Ein Beispiel für eine eigene Funktion mit Rückgabewert: Listing C.18 Datei uc26.php
    <html>
    <head>
    <?php
       function add($z1, $z2)
       {
          $summe = $z1 + $z2;
          return $summe;
       }
    ?>
    </head>
    <body>
    <?php
       $c = add(3,4);     // aufrufende Stelle
       echo "Summe: $c<p>";

       $x = 5;
       $c= add($x,12);    // aufrufende Stelle
       echo "Summe: $c<p>";

       // aufrufende Stelle innerhalb der Ausgabe
       echo "Summe: " . add(13,2) . "<p>";
    ?>
    </body>
    </html>
Die Funktion add() hat die beiden Parameter $z1 und $z2. Innerhalb der Funktion werden diese beiden Parameter addiert und in der Variablen $summe gespeichert. Wohin zurückliefern? Mit Hilfe der Anweisung return wird dieser Wert an die aufrufende Stelle zurückgeliefert und kann dort weiter verarbeitet werden. In den ersten beiden Fällen wird der Wert in der Variablen $c gespeichert, im letzten Fall ohne Zwischenspeicherung direkt ausgegeben. #### Übung UC27 Schreiben Sie ein Programm (Datei uc27.php), in dem eine Funktion bigger() definiert und aufgerufen wird. Dieser Funktion ermittelt die größere von zwei übergebenen Zahlen und liefert diese Zahl zurück. Testen Sie die Funktion mit mehreren verschiedenen Aufrufen innerhalb des Programmes und geben Sie das Ergebnis zur Kontrolle aus. Ein Aufruf der Funktion könnte lauten:
    $c = bigger(3,4);
Die Ausgabe des Programmes wäre in diesem Falle: Die größere Zahl ist 4 #### Übung UC28 Schreiben Sie ein Programm (Datei uc28.php), in dem eine Funktion etikett() definiert und benutzt wird. Diese setzt mehrere Zeichenketten zu einem Adressetikett zusammen und liefert dieses zurück an die aufrufende Stelle. Ein möglicher Aufruf:
    $text = etikett("Hans", "Maier", 52756, "Oberwolfach");
Die Ausgabe sieht wie folgt aus:
    An
    Hans Maier
    52756 Oberwolfach
Beachten Sie die Zeilenumbrüche. Testen Sie die Funktion mit mehreren verschiedenen Aufrufen innerhalb des Programmes, und geben Sie das Ergebnis zur Kontrolle aus. Es könnte wie folgt aussehen:
Abbildung C.12 Funktion mit Rückgabewert
### C.5.6 Verhalten bei Parameter-Übergabe Bei der Übergabe von Parametern an eine Funktion muss man sich noch die Frage stellen: Was passiert, falls ich in der Funktion einen der Parameter verändere? PHP bietet hier mehrere Möglichkeiten an: call-by-value
| Übergabe der Parameter als Kopie (call-by-value), eine Veränderung der Kopien hat keine Rückwirkung auf das Original: Diese Methode wird angewendet, falls man nur Werte in die Funktion hineinliefern möchte, denn ein möglicher Fehler in der Funktion hat keinen Fehler im aufrufenden Hauptprogramm zur Folge. Sie wurde bei den bisherigen Programmen angewendet.
call-by-reference 1
| Übergabe der Parameter als Verweis (call-by-reference) auf das Original, eine Veränderung hat Rückwirkung auf das Original: Diese Methode wird angewendet, wenn mehr als ein Wert aus einer Funktion zurückgeliefert werden soll. Über einen Rückgabewert (siehe vorigen Abschnitt) könnte nur ein einziger Wert zurückgeliefert werden.
call-by-reference 2
| Übergabe von Verweisen auf die Original-Parameter (ebenfalls: call-by-reference), eine Veränderung hat Rückwirkung auf das Original: Möchte man die Änderungsmöglichkeiten der zweiten Methode mit der Sicherheit der ersten Methode verbinden, so kann man diese Vorgehensweise anwenden. Dabei kann der Entwickler von Fall zu Fall entscheiden, ob er beim Aufruf einer Funktion den Wert oder einen Verweis übergibt.
Alle drei Methoden sollen zum Vergleich an einem Beispiel dargestellt werden. Den beiden Funktionen rtauschen() bzw. vtauschen() werden zwei Parameter übergeben. Innerhalb der Funktionen sollen die beiden übergebenen Parameter miteinander vertauscht werden. In Abhängigkeit der verschiedenen angewendeten Methoden wird dieses Tauschen Rückwirkungen auf die Original-Variablen im Hauptprogramm haben. Die Werte werden jeweils vor und nach dem Tauschen angezeigt. Listing C.19 Datei uc29.php
    <html>
    <head>
    <?php

       function vtauschen($a, $b)
       {
          $temp = $a;
          $a = $b;
          $b = $temp;
       }

       function rtauschen(&$a, &$b)
       {
          $temp = $a;
          $a = $b;
          $b = $temp;
       }

    ?>
    </head>
    <body>
    <?php
       $x = 12;   $y = 18;
       echo "Methode 1, vorher: $x, $y <p>";
       vtauschen($x,$y);
       echo "Methode 1, nachher: $x, $y <p>";

       $x = 12;   $y = 18;
       echo "Methode 2, vorher: $x, $y <p>";
       rtauschen($x,$y);
       echo "Methode 2, nachher: $x, $y <p>";

       $x = 12;   $y = 18;
       echo "Methode 3, vorher: $x, $y <p>";
       vtauschen(&$x,&$y);
       echo "Methode 3, nachher: $x, $y <p>";
    ?>
    </body>
    </html>
1. | Der Wert der Variablen $x wird bei Aufruf der Funktion vtauschen() an die Variable $a übergeben. Der Wert der Variablen $y wird an die Variable $b übergeben. Innerhalb der Funktion vtauschen() werden $a und $b getauscht. Da aber nur die Kopien getauscht wurden, hat dies auf die Originale $x und $y keine Auswirkungen.
2. | Den Unterschied sieht man im Funktionskopf function rtauschen(&$a, &$b). Die Variable $x wird bei Aufruf der Funktion rtauschen() per Verweis (Zeichen &) an die Variable $a übergeben. Die Variable $y wird per Verweis an die Variable $b übergeben. Innerhalb der Funktion werden $a und $b vertauscht. Dadurch werden auch die Originale $x und $y vertauscht.
3. | Den Unterschied sieht man beim Aufruf der Funktion: vtauschen (&$x, &$y); Die Variable $x wird beim Aufruf der Funktion vtauschen() per Verweis (Zeichen &) an die Variable $a übergeben. Die Variable $y wird beim Aufruf per Verweis an die Variable $b übergeben. Innerhalb der Funktion werden $a und $b vertauscht. Dadurch werden auch die Originale $x und $y vertauscht.
Die Ausgabe der Seite, jeweils mit den Werten vor und nach der (erfolgreichen) Vertauschung:
Abbildung C.13 call-by-value, call-by-reference
#### Übung UC30 Schreiben sie ein PHP-Programm (Datei uc30.php) mit einer Funktion rechne. Dieser Funktion werden zwei Zahlen übergeben. Sie soll zwei Ergebnisse über die Parameterliste zurückliefern, zum einen die Summe der beiden übergebenen Zahlen, zum anderen das Produkt der übergebenen ersten Zahlen. Alle beteiligten Zahlen sollen im Hauptteil des Programmes, also außerhalb der Funktion, ausgegeben werden. Verwenden Sie zur Übergabe die dritte Methode (Übergabe von Verweisen auf die Original-Parameter). ### C.5.7 Globale und lokale Variablen Variablen werden auch nach ihrem Gültigkeitsbereich unterschieden. Dies ist der Bereich, in dem die betreffende Variable mit ihrem Wert bekannt ist. Es gibt Variablen mit globalem Gültigkeitsbereich und Variablen mit lokalem Gültigkeitsbereich. Diese scheinbare Einschränkung auf einen lokalen Gültigkeitsbereich bietet bei längeren Programmen den Vorteil, dass Variablen nicht so leicht aus Versehen an weit voneinander entfernten Stellen verändert werden können. Globale Variable Eine globale Variable wird außerhalb von Funktionen definiert und steht nur außerhalb derselben zur Verfügung. Dies ist ein Unterschied zu vielen anderen Programmiersprachen. Falls man eine globale Variable innerhalb einer Funktion benutzen möchte, so muss sie dort entweder mit dem Schlüsselwort global bekannt gemacht oder als Parameter übergeben werden. Variablen, die ihren Ursprung außerhalb des Programmes haben wie z. B. Werte aus Formularfeldern sind immer global. Lokale Variable Eine lokale Variable wird in einer Funktion definiert und steht nur innerhalb dieser Funktion zur Verfügung. Lokale Variablen gleichen Namens in unterschiedlichen Funktionen oder globale Variablen gleichen Namens haben nichts miteinander zu tun. Ein Parameter, der als Kopie an eine Funktion übergeben wird, ist dort lokal. Ein Beispiel: Listing C.20 Datei uc31.php
    <html>
    <head>
    <?php
       function summiere()
       {
          echo "Variable z: $z<p>";
          global $x;
          $y = 35;
          $z = $x + $y;
          echo "Variable z: $z<p>";
       }
    ?>
    </head>
    <body>
    <?php
          $x = 6;
          $y = 52;
          $z = $x + $y;
          summiere();
          echo "Variable z: $z<p>";
    ?>
    </body>
    </html>
In diesem Programm existieren insgesamt fünf unterschiedliche Variablen. Die beiden Variablen $y und $z in der Funktion summiere() sind nur dort lokal bekannt. Zum Zeitpunkt des ersten Ausgabebefehles in der Funktion existiert $z noch nicht, daher wird kein Wert ausgegeben. Nach Verlassen der Funktion summiere() sind beide Werte nicht mehr verfügbar. Schlüsselwort global Im Hauptprogramm gibt es insgesamt drei Variablen: $x, $y und $z. Das Schlüsselwort global sorgt dafür, dass $x auch in der Funktion summiere() mit seinem Wert bekannt ist. $y und $z sind nur außerhalb von Funktionen bekannt. Die Ausgabe des Programmes sieht aus wie folgt:
    Variable z:
    Variable z: 41
    Variable z: 58
<< zurück | <top> | vor >>
Zum Katalog
PHP 4 bestellen
Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen? Ihre Meinung

Noch Fragen?
Tauschen Sie sich mit anderen Lesern aus Zum Forum

Empfehlung
| PHP 4-Workshop

Neue Bücher
Einstieg in Python JavaScript (4. Aufl.) CSS Praxis Einstieg in XML

Empfehlung
| MySQL 4

Shopping
Versandkostenfrei bestellen in Deutschland und Österreich Info

MyGalileo
Der Service für registrierte Leser: Info

Copyright © Galileo Press GmbH 2001 - 2002
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken und speichern. Ansonsten unterliegt das <openbook> denselben Bestimmungen wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.
Die Veröffentlichung der Inhalte oder Teilen davon bedarf der ausdrücklichen schriftlichen Genehmigung von Galileo Press. Falls Sie Interesse daran haben sollten, die Inhalte auf Ihrer Website oder einer CD anzubieten, melden Sie sich bitte bei: stefan.krumbiegel@galileo-press.de

[Galileo Computing]
Galileo Press GmbH, Gartenstraße 24, 53229 Bonn, fon: 0228.42150.0, fax 0228.42150.77, info@galileo-press.de