Funktionen

Funktionen sind sozusagen Subprogramme (Subroutinen), die bestimmte (meist zu wiederholende) Aufgaben erfüllen.

Man kann sich diese als "kleinere eigenständige Programme" im Hauptprogramm vorstellen, die ebenso
dem EVA (Eingabe=Parameter, Verarbeitung=Befehlsfolgen, Ausgabe=zB der Return Wert der Funktion) Prinzip folgen können.

Es gibt grundsätzlich zwei Arten von Funktionen, die die man selber schreibt und jene die in PHP schon vorhanden sind.

Aufgerufen werden Funktionen über Ihren Funktionsnamen gefolgt von runden Klammern,
die ev. Parameter (Argumente) enthalten (Parameterübergabe), die der Funktion übergeben werden:

meineFunktion();
// Nur der Funktionsaufruf über den Funktionsnamen.
// Die Funktion hat keinen Rückgabewert und keine Übergabe-Parameter

meineFunktion($myparameter1, $myparameter2); 
// Eine Funktion die mit 2 Parameter aufgerufen wird.
// Übergabeparameter werden durch Beistirche "," getrennt

$Rueckgabe = meineFunktion($myparameter1);
// Eine Funktion, die mit 1 Parameter
// aufgerufen wird und auch einen Wert zurückgibt (return value)

 

Funktionen könnte man sich als eine "Blackbox" vorstellen:
Es werden also beim Funktionsaufruf meist Werte “hineingeschickt” (durch die Parameterübergabe),
dann in der Funktion verarbeitet und später eventuell wieder “ausgespuckt” als der "Return-Wert",
also der Rückgabewert, den die Funktion liefert:

 

$myReturnValue = my_black_box_function ( $myparameter1, $myparameter2 );

 

Funktionen werden hauptsächlich verwendet und sich wiederkehrende “Aufgaben” zu ersparen. Jedes Mal wenn die gleiche Aufgabe erledigt werden soll, kann man die dafür vorgesehene Funktion aufrufen.

Eigene Funktionen müssen definiert werden und können dann bei Bedarf aufgerufen werden.
Also erst wenn der Funktionsaufruf in einem Skript erfolgt, wird die Funktion aufgerufen und
ihr Funktionscode abgearbeitet. Wird die Funktion nie aufgerufen, ist sie meist fehl
am Platz im jeweiligen Skript.

Es gibt in PHP natürlich schon eine (wirklich große) Menge an vorgefertigten
Funktionen/Methoden, wie zB die Sinus-Funktion: sin();

http://at.php.net/manual/en/function.sin.php

im Handbuch heißt es dazu:

"float sin ( float arg)
sin() returns the sine of the arg parameter. The arg parameter is in radians"

D.h. nun, die Funktion sin liefert einen Gleitkommawert zurück (float ist ja der
Datentyp für Gleitkommazahlen) und erwartet auch einen solchen als Übergabe-Parameter (Argument) .

zB.

$sin_rad = sin(6.4);

in $sin_rad befindet sich der Rückgabewert der Funktion mit dem Name "sin();",
der der Parameter in Form der Gleitkommazahl 6.4 übergeben wurde.
Die Funktion berechnet den Wert und liefert das Ergebnis wie gesagt
über den Zuweisungsoperator = an die Variable $sin_rad zurück.

 

 

Eigene Funktionen

Wir wollen die schon eingebaute PHP Funktion abs(); nachbilden.

Die Definition von php.net: http://at.php.net/abs

"Description: number abs ( number )
Returns the absolute value of number."

Der Absolut-Betrag bedeutet dabei mathematisch, dass immer ein positiver Wert
oder 0 zurückgegeben wird: (absolute Wert von |-a| = a)

zB.

$positiver_wert = abs(-1); //$positiver_wert wäre dann 1
$positiver_wert = abs(-3.14159); //$positiver_wert wäre dann 3.14159
$wert           = abs(0); // $wert wäre dann 0

Wir wollen diese Funktion jetzt selbst nachbilden:

Funktionsdefinitionen sehen im Allgemeinen folgend aus: Vor dem Funktionsnamen steht der Begriff function,
damit PHP weiß, dass es eine Funktion ist. Danach schreibt man den Funktionsnamen
(für ihn gelten die gleichen Regeln wie für Variablennamen). Nun folgt eine geöffnete runde Klammer (,
dann eventuell Parameter, wenn Werte an die Funktion übergeben werden sollen und am Ende
eine geschlossenen Runde Klammer ). Darauf folgt der Funktionsblock, der durch { und } begrenzt ist:

function derFunktionsname ( eventuell Argumente, die an die Funktion übergeben werden )
{ // Hier stehen die Anweisungen der Funktion.

return ( Rückgabewert );
// Funktionen müssen keinen Rückgabewert haben, dann lässt man das
// "return"-Statement einfach weg.
}

 

Zurück zum Beispiel: Wir wollen also die abs() Funktion nachbilden. Wir brauchen nun einen eigenen Funktionsnamen, da Namen, die gleichlautende Funktionsbezeichnungen wie die on PHP eingebauten Funktionsnamen besitzen nicht verwendet werden können: Wir nennen die Funktion einfach mein_abs und definieren den leeren „Funktionskörper“:

function mein_abs()
{
}

Diese Funktion macht noch gar nichts – aber sie ist definiert. Damit die Funktion weiß, mit welchen Daten sie zu arbeiten hat, müssen wir ihr die Daten übergeben, d.h., wir brauchen einen Übergabeparameter. Wir wollen die Funktion ja mit mein_abs (-1) zB aufrufen. Damit der Wert -1 in der Funktion “landet”, müssen wir ihr auch als Parameter (Parameterübergabe) angeben:

function mein_abs($derWert)
{
}
main_abs(-1); // Aufruf der obigen Funktion mit dem Parameter -1

 

Wird nun mein_abs (-1); aufgerufen, steht der Wert -1 der Funktion als Variable "$derWert" im Funktionsblock zur Verfügung. Wir speichern die Datei unter mein_abs1.php und testen sie am Webserver und rufen sie über den Webbroswer auf:

http://meinwebserver/mein_abs1.php

Man sieht, es kommt keine Fehlermeldung, aber es geschieht auch nicht wirklich etwas, außer, dass die Funktion aufgerufen wird und ihr der Wert -1 übergeben wurde - was fehlt ist die Ausgabe.

 

Wir testen nun, ob die Parameterübergabe funktioniert hat.
Das machen wir, indem der Parameter einfach wieder mit echo-Befehl innerhalb der Funktion ausgeben wird.
Folgene Funktion hat immer noch keinen Rückgabewert (return value), liefert aber zwischenzeitlich
ein visuelles feedback durch die Ausgabe.

 

Dazu ändern wir die Funktion wie folgt:

function mein_abs($derWert)
{
    echo $derWert;
}
main_abs(-1); // Funktionsaufruf

So folgt. Es wird "-1" im Browserfenster beim Aufruf der PHP-Datei angezeigt.

Die Parameterübergabe scheint also zu funktionieren. Wir wollen aber immer einen positiven Wert erhalten, d.h. zB -1 sollte 1 werden, -500 soll 500 werden etc. Wir müssen alle Möglichkeiten ausloten, die es zu berücksichtigen gibt ("Fallunterscheidungen"):

Ist der übergebene Wert 0 oder größer als 0, also somit nicht negativ, brauchen wir eigentlich gar nichts zu tun. Ist er kleiner als 0 also negativ, müssen wir ihn in einen positiven Wert wandeln. Das bedeutet, wir brauchen eine Abfrage, ob der Wert kleiner 0 ist, und müssen den Wert dann, falls dies der Fall ist „positiv machen“, sprich einfach mit -1 multiplizieren.

Wir testen also mit if ($derWert < 0) ob der Wert negativ ist. Ist dies der Fall, brauchen wir den Wert nur mit -1 zu multiplizieren$derWert = $derWert * -1; und erhalten so den positiven Wert, den wir gleich der Variablen $derWert zuweisen.

Anmerkung: $derWert = $derWert * -1; kann auch als $derWert *= -1; geschrieben werden.

function mein_abs($derWert)

{
    if ($derWert < 0) {
        $derWert = $derWert * -1; // eine negative Zahl mit -1 multipliziert
        // ergibt ja eine Positive: -1 * -1 = 1
        // -3.4 * -1 = 3.4 etc.
    }
    echo $derWert; // Ausgabe
    echo "
"; // Zeilenumbruch
}

Wir Testen dies jetzt mit verschiedenen Parametern beim Funktionsaufruf:
mein_abs(-3.14159);
mein_abs(0);
mein_abs(22);
mein_abs(-10000000000000000);

Prorgrammausagebe:
3.14159
0
22
1E+16

Da wir die positiv ausgegebenen Werte im weiteren Programmablauf verwenden wollen und nicht als Text im "Browserfenster" anzeigen möchten, müssen wir den positiven Wert, den die Funktion "errechnet" hat statt Ausgeben einfach zurückgeben. Dies geschieht wie schon kurz erwähnt über den "return"-Befehl in Funktionen:

return ($derWert);

So folgt:

function mein_abs($derWert)
{
    if ($derWert < 0) {
        $derWert = $derWert * -1; // eine negative Zahl mit -1 multipliziert
        // ergibt ja eine Positive: -1 * -1 = 1
        // -3.4 * -1 = 3.4 etc.
    }
    return ($derWert); // gibt den Wert an den “Aufrufer” der Funktion
    // zurück
}

$positiver_Wert1 = mein_abs(-3.14159);
$positiver_Wert2 = mein_abs(-1);
$positiver_Wert3 = mein_abs(11);
echo $positiver_Wert1;
echo "
";
echo $positiver_Wert2;
echo "
";
echo $positiver_Wert3;

Programmausgabe:

3.14159
1
11

Wir haben also nun unsere eigene Funktion fzur Errechnung des Absolutbetrages geschrieben. Die Berechnung wird von der Funktion per return zurückgegeben und per = an beliebige Variablen weitergegeben.

Die Variablen haben wir hier noch zur Überprüfung per "echo"-Statement zur Anzeige gebracht.