quakenet:#php Tutorial

1. Eigene Funktionen erstellen

Wir haben schon ein paar Funktionen wie nl2br und settype kennengelernt. Einer Funktion kann man bestimmte Parameter übergeben. Diese Funktion reagiert dann entsprechend darauf. Eine Funktion, wie nl2br, liefert einen Wert zurück mit dem man dann weiter arbeiten kann.

Es ist auch möglich eigene Funktionen zu erstellen. Diese Funktion arbeitet dann eine Menge von Befehlen ab, kann sich sogar selbst aufrufen (Rekursion). Alle eigene Funktionen sollte man in einen extra Datei schreiben, z.B. functions.php. Diese können wir dann in unserem Projekt includen. Wenn wir eine neue Funktion brauchen, brauchen wir nur die functions.php bearbeiten.

2. Eigene Funktionen definieren

Wenn man eine eigene Funktion definieren möchte, muss man folgenden Code benutzen.

<?php
    function name()
    {
        // ... Die Befehle
    }
?>

Eine Funktionsdefinition wird mit dem Schlüsselwort function eingeleitet. Danach kommt der Name der Funktion. Dieser darf nicht mit einer Zahl anfangen. Nach dem 1. Zeichen dürfen Alphanumerische Zeichen und Unterstriche benutzt werden. Danach kommen runde Klammern, in denen dann Variablen für Parameter stehen. Doch dazu kommen wir gleich. Oben im Beispiel haben wir angegeben, dass diese Funktion keine Parameter bekommt. Dann kommt ein Programmblock in geschweiften Klammern, in denen dann die Befehle drinstehen, die dann ausgeführt werden. Dies könnte dann so aussehen.

<?php
    error_reporting(E_ALL);

    function hello()
    {
        echo "Hallo, ich bin xy<br />\n";
    }
?>

Diese Funktion kann man dann mit hello() aufrufen.

<?php
    function hello()
    {
        echo "Hallo, ich bin xy<br />\n";
    }

    hello(); // Aufruf unserer Funktion
?>

Wenn wir die Funktion aufrufen werden die darin stehenden Befehle ausgeführt. In diesem Fall wird der echo-Befehl ausgeführt.

Wichtig ist auch, dass eine Funktion nur einmal definiert werden kann. Durch falsche Anordnung von Include-Befehlen kann es vorkommen, dass z.B. die functions.php 2 mal included wird. PHP versucht dann ein 2. Mal die Funktion hello zu definieren. Doch dies geht nicht und PHP wird ein Fatal-Error aussprucken.

3. Parameter einer Funktion

Viel wichtiger ist die Benutzung von Parametern. Mit Parametern können wir die Funktionsweise einer Funktion steuern bzw. die Funktion kann auf die Parameter reagieren und entsprechende Aktionen ausführen.

Um Parameter zu definieren schreibt man Variablen in den runden Klammern, getrennt mit einem Komma. Dies sieht dann so aus:

<?php
    error_reporting(E_ALL);

    function xyz($param1, $param2)
    {
        // tu was
    }
?>

Wenn jetzt diese Funktion mit 2 Parametern aufgerufen wird, so enthält die Variable $param1 den Wert des 1. Parameters und $param2 den Wert des 2. Parameters. Diese Variablen können dann im Funktionsteil verwendet werden.

<?php
    error_reporting(E_ALL);

    function xyz($param1, $param2)
    {
        echo "Der 1. Parameter ist ".$param1." und der 2. ist ".$param2."<br />\n";
    }
?>

In einem Beispiel würde das jetzt so aussehen.

<?php
    error_reporting(E_ALL);

    function xyz($param1, $param2)
    {
        echo "Der 1. Parameter ist ".$param1." und der 2. ist ".$param2."<br />\n";
    }
    
    xyz("bla", 200);
?>

Dies erzeugt folgende Ausgabe.

Der 1. Parameter ist bla und der 2. ist 200
        

Die gewählten Variablennamen $param1 und $param2 müssen nicht so heißen. Sie sollten aber eindeutige Namen haben.

Wenn man statt einem Konstanten Ausdruck, wie hier "bla" und 200, eine Variable übergibt, so enthält die Parametervariable in der Funktion eine Kopie des Wertes. Diese Parametervariable ist nicht mit dem Parameter aus dem "Hauptscript" gekoppelt. Eine Änderung in der Funktion ändert nicht die Variable im Hauptscript.

<?php      
    error_reporting(E_ALL);
    
    function tu_was($foo)
    {
        echo "--- In der Funktion ---<br />\n";
        echo "foo ist: ".$foo."<br />\n";
        $foo *= 2;
        echo "foo ist: ".$foo."<br />\n";
        echo "--- Ende der Funktion ---<br />\n";
    }

    $bla = 14;
    echo "bla ist: ".$bla."<br />\n";
    tu_was($bla);
    echo "bla ist immernoch: ".$bla."<br />\n";
?>

Dieses Script erzeugt folgende Ausgabe

bla ist: 14
--- In der Funktion ---
foo ist: 14
foo ist: 28
--- Ende der Funktion
bla ist immernoch: 14
        

Hier sieht man, dass die Variable außen $bla nicht mit der Funktionsvariable $foo gekoppelt ist. Die Änderung von $foo verändert nix an der Variable $bla. Mit Referenzen kann man aber Variablen koppeln, dazu aber in einem extra Kapitel über Referenzen.

4. Gültigkeit von Variablen

Wenn eine Funktion aufgerufen wird, so kennt sie nur ganz bestimmte Variablen. Einmal kennt sie die Variablen wo die Parameter drinstehen. Dann kennt sie die sogenannten Superglobals. Dies sind die Variablen $_GET, $_POST, $_REQUEST, $_SERVER, $_ENV, $_COOKIE und $_SESSION. Und dann kennt sie noch die Variable $GLOBALS. Alle anderen Variablen, z.B. aus dem Hauptscript, sind für die Funktion unbekannt.

<?php
    error_reporting(E_ALL);

    // Die Funktion definieren
    function xyz()
    {
        echo $foo;
    }                         
    
    $foo = "bla";
    xyz();
?>

Wenn man dieses Script startet wird PHP eine Notice ausgeben, dass er die Variable $foo nicht kennt. Diese Trennung gilt auch umgekehrt. Eine Variable in einer Funktion ist nicht im Hauptprogramm zu erreichen (es sei denn sie wird zurückgegeben, doch dazu kommen wir gleich).

<?php
    error_reporting(E_ALL);

    // Die Funktion definieren
    function xyz()
    {
        $foo = "bla";
    }
    
    xyz();
    echo $foo;
?>

Hier kommt auch wieder eine Notice, dass er die Variable nicht kennt. Dieses $foo gibt es nur in der Funktion xyz().

Diese Trennung ist nützlich damit man sich nicht die anderen Variablen aus dem Hauptprogramm zerstört. Manche Variablen sind überall vorhanden sollten jetzt aber nicht als Transportschiff von Funktion zu Funktion oder Funktion zu Hauptprogramm missbraucht werden. Sie haben schon eine ganz bestimmte Funktion wie z.B. das beinhalten der GET-Variablen und Formular-Variablen (POST).

Diese Einschränkung gilt nicht für Konstanten. Konstanten sind überall vorhanden, wie die Superglobal-Variablen.

5. Rückgabewert einer Funktion

Wir kennen die Funktion nl2br. Ihr wird ein Parameter übergeben und es wird ein Wert zurückgeliefert. Diesen speichern wir üblicherweise in eine Variable ab. Wir können also Funktionen schreiben die eine Funktion zurückliefert. Dabei ist es egal was die Funktion zurückliefert. Wenn wir einen Wert aus einer Funktion zurückgeben wollen müssen wir den Ausdruck return benutzen.

<?php
    error_reporting(E_ALL);
    
    function foobar()
    {
        $zahl = 5;
        return $zahl;
        // oder direkt "return 5;"
    }                             
    
    $bla = foobar();
    echo "Die Funktion hat das zurückgeliefert: ".$bla;
?>

Dies erzeugt folgende Ausgabe. (Man, wie oft ich diesen Satz schon geschrieben habe)

Die Funktion hat das zurückgeliefert: 5
        

Mit return $var; oder return Wert; können wir aus eine Funktion heraus einen Wert zurückgeben. Diesen Wert sollten wir dann in eine Variable speichern oder direkt verarbeiten, z.B. mit echo ausgeben oder mit if verarbeiten.

Wenn an einer Stelle ein return steht, so wird die Funktion an dieser Stelle beendet und der Wert (falls angegeben) wird zurückgegeben. Befehle die unter dem return-Befehl stehen werden nicht verarbeitet.

Hier ein Beispielfunktion mit return Anweisung.

<?php
    error_reporting(E_ALL);
    
    function login_right($User,$Pass)
    {                         
        if(empty($User) OR empty($Pass)) {
            return false;
        }

        /*
         Hier kommt dann die Abfrage, ob der Login
         richtig ist, z.B. mit einer Datenbank wo alle
         Logins gespeichert sind. Wir nehmen
         hier aber nur eine billige Abfrage
        */                                 
        if(($User=="admin") AND ($Pass=="login")) {
            return true;
        } else {
            return false;
        }
        echo "Ich werde nicht ausgeführt";
        return false;
    }
    
    if(isset($_POST['username']) AND
       isset($_POST['password']) AND
       login_right($_POST['username'], $_POST['password'])) {
        echo "Willkommen im Adminbereich";
    } else {
        echo "Login ungültig";
    }
?>

Dieses Script prüft einmal nach ob die Formularelemente $_POST['username'] und $_POST['password'] übergeben wurden. Danach werden dann mit der eigenen Funktion login_right die Logindaten geprüft. Wenn kein Username oder kein Passwort eingegeben wurde, sprich die Variablen sind leer (empty), brauchen wir erst garnicht den Login überprüfen, sondern können direkt den boolischen Wert false zurückgeben. Dann wird, hier durch ein billiger Vergleich, geprüft ob der Login gültig ist. Jenachdem wird dann true oder false zurückgeliefert. Der echo Befehl wird nie ausgeführt, da auf jedenfall vorher ein return-Befehl aufgerufen wird, entweder im if-Teil oder im else-Teil. Wenn die Funktion einen Wert zurückliefern soll, sollte sie auf jedenfall eine return-Anweisung am ende der Funktion haben. Somit wird sichergestellt, dass die Funktion einen Wert zurückliefert, falls man einen Programmierfehler in der Funktion hat.

6. Optionale Parameter

Wir kennen Funktionen die so aufgebaut sind.

void xyz(int param1 [, float param2])
        

Dies heißt ja das der 2. Parameter Optional ist, er muss nicht angegeben werden. So eine Funktion können wir auch schreiben.

<?php
    function xyz($var1, $var2 = "default-wert")
    {
        // ...
    }
?>

Wir haben jetzt hinter dem 2. Parameter eine Zuweisung geschrieben. Dies heißt, wenn der 2. Parameter nicht übergeben wurde, so wird die Variable des 2. Parameters mit diesem Wert gefüllt. Auf diesen Wert können wir dann auch reagieren.

<?php
    error_reporting(E_ALL);
    
    function message($msg, $farbe = "#FF0000")
    {
        echo "<span style=\"color: ".$farbe."\">".$msg."</span><br />\n";
    }      
    
    message("Hi all");
    message("Na wie gehts?", "#666666");
?>

Dies gibt einmal den Text Hi all in Rot aus, da der 2. Parameter nicht übergeben wurde und die Variable $farbe den Wert #FF0000 hat. Der Text Na wie gehts? wird in einem dunklen Grauton geschrieben.

Es ist egal wieviele Parameter optional sein durfen. Aber optionale Parameter müssen von rechts anfangen.

<?php
    function xyz($var1 = "foo", $var2)
    {
        // ...
    }
?>

Sowas wird nicht gehen, wie geplant, da wir die Funktion nicht mit xyz(, "foo"); aufrufen können. Und wenn wir das Komma weglassen, also xyz("foo"); aufrufen, so haben wir ja nicht den 1. Parameter weggelassen sondern haben den 2. Parameter weggelassen. Da der 2. Parameter in diesem Fall angegeben werden muss wird PHP dann hier meckern.

Fragen zum aktuellen Thema

1. Welche Variablen sind immer innerhalb von Funktionen vorhanden
2. Wie werden optionale Parameter definiert

Welche Variablen sind immer innerhalb von Funktionen vorhanden

Es gibt eine paar Variablen die innerhalb von Funktionen vorhanden sind.

• Die Superglobals-Variablen $_GET, $_POST, $_REQUEST, $_SERVER, $_ENV, $_COOKIE und $_SESSION.

• Die Variable $GLOBALS (ohne _ am Anfang).

• Die Parametervariablen, in denen die Werte der Parameter stehen.

Wie werden optionale Parameter definiert

Wenn man im Funktionskopf hinter den Parametervariablen eine Zuweisung schreibt, so wird dieser Wert in die Parametervariable geladen, wenn dieser Parameter nicht angegeben wurde.