PHP-Lektionen – Lektion 7 – PHP-Funktionen und funktionale Programmierung
Ich denke, wir sind dem Moment schon ziemlich nahe, an dem es Zeit ist... Zeit, wirklich zu programmieren. Nach dieser Lektion können Sie sagen, dass Sie in PHP programmiert haben. Sehr oft schreibt man Code, der auf anderen Seiten, in anderen .php-Dateien wiederholt werden muss. Um diesen Code nicht zu duplizieren, gibt es in PHP Funktionen.
Eine Funktion ist ein unabhängiger Teil des Codes, der einige Berechnungen ausführt. Beispiele solcher Funktionen haben wir in früheren Lektionen gesehen:
time() – eine Funktion, die die Anzahl der Sekunden seit Beginn der Unix-Epoche ausgibt.
print(), echo() – Funktionen, die es erlauben, HTML auszugeben.
floor() – eine Funktion, die bei einer Dezimalzahl den ganzzahligen Anteil zurückgibt.
Sie haben sicher bemerkt, wie Funktionen bezeichnet werden – mit zwei Klammern (). Allgemein sieht die Schreibweise so aus: funktionsname(). Die Benennungsregeln sind dieselben wie für Variablen. Nur dass man bei Variablen ein Dollarzeichen schreibt, bei Funktionen jedoch nicht, sondern Klammern verwendet.
Woraus eine Funktion besteht, sehen wir am Beispiel:
<?php
function plus_one($x){ // Funktionsdefinition
$x = $x + 1; // Funktionskörper
return $x; // Rückgabewert
}
$y = 1;
$y = plus_one($y); // Funktionsaufruf
print $y;
?>
Der Funktionsname zeigt bereits, dass die Funktion der Variablen eins hinzufügt. Nun woraus die Funktion besteht:
Funktionsname
Der Funktionsname wird genauso wie ein Variablenname vergeben:
- Der Funktionsname muss mit einem Buchstaben oder dem Unterstrich "_" beginnen.
- Der Funktionsname darf nur alphanumerische Zeichen und Unterstriche enthalten (A-Z, a-z, 0-9 und _).
- Der Funktionsname darf keine Leerzeichen enthalten. Bei mehrteiligen Namen trennt man diese durch Unterstriche (my_function()) oder schreibt sie im CamelCase (myFunction()).
Zur Definition einer neuen Funktion verwenden wir das Wort function. Dieses Wort signalisiert, dass nun der Funktionsname folgt.
Funktionskörper
Das ist der Code, der in der Funktion ausgeführt wird. In unserem Beispiel ist es dieser Teil:
function plus_one($x){
$x = $x + 1; // Funktionskörper
return $x; // Funktionskörper
}
Der Funktionskörper wird in geschweifte Klammern {} eingeschlossen.
Rückgabewert
Ich schrieb schon „gibt einen Wert zurück“, „Rückgabewert“ – jetzt erkläre ich, was das bedeutet. Der Wert nach dem Wort return ist der Rückgabewert. Das ist das Ergebnis der Ausführung der Funktion. In unserem Beispiel geben wir den Wert der Variablen $x zurück.
Funktionsparameter
Parameter sind Variablen oder Werte, die man nach dem Funktionsnamen in runden Klammern schreibt. In unserem Beispiel übergeben wir einen Parameter $x, aber man kann auch mehrere Parameter durch Kommas trennen:
<?php
function myFunction($x1, $x2, $x3){
}
$y = myFunction($z, 34, 'Hallo, Welt!');
?>
Wenn bei der Definition der Funktion Parameter angegeben sind, zeigt das nur an, wie viele Parameter beim Aufruf der Funktion erforderlich sind. Wenn die Anzahl der Parameter nicht übereinstimmt, führt das zu einem Fehler:
<?php
function myFunction($x1, $x2, $x3){
}
$y = myFunction(34, 'Hallo, Welt!'); // falscher Funktionsaufruf, führt zu Fehler!!!
?>
Beachten Sie auch, dass in der Definition nur die lokalen Variablennamen stehen, die innerhalb der Funktion verwendet werden. Beim Aufruf der Funktion können beliebige Werte und Variablen übergeben werden.
Sehen wir uns das Funktionsprinzip an einem einfachen mathematischen Beispiel an, Entschuldigung für das Wortspiel. Angenommen, wir haben die Funktion y = -2x + 4. Finden wir die Funktionswerte für verschiedene Argumente x:
<?php
function myFunction($x){
$y = -2 * $x + 4;
return $y;
}
$z1 = myFunction(1);
$z2 = myFunction(2);
$z3 = myFunction(3);
print $z1 . '<br />' . $z2 . '<br />' . $z3;
?>
Das Ergebnis sind die Werte -2, 0, 2. Ich denke, nach diesem Beispiel ist Ihnen klar, wie Funktionen arbeiten.
Jetzt sprechen wir über funktionale Programmierung. Sie ahnen bestimmt, warum diese Programmierart so heißt – genau, weil sie auf Funktionen basiert, viele Funktionen, dutzende in jeder Datei. Wie geht man mit so vielen Funktionen um? Ganz einfach. Ich erkläre es an einem Beispiel.
<?php
function incr($x){
$x++;
return $x;
}
function decr($y){
$y--;
return $y;
}
$z = 0;
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = decr($z);
print $z;
?>
Wie beschrieben, erhöhen wir hier viermal um eins und einmal verringern wir um eins. Das Ergebnis ist 3. Nun verschieben wir die Funktionen nach unten, unter das Beispiel:
<?php
$z = 0;
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = incr($z);
$z = decr($z);
print $z;
function incr($x){
$x++;
return $x;
}
function decr($y){
$y--;
return $y;
}
?>
Wenn Sie diesen Code ausführen, ändert sich nichts, es bleibt 3. PHP findet die Funktionen, egal wo sie definiert sind, relativ zu dem aktuellen Befehl. Aber was, wenn man 50, 100 oder 1000 Funktionen hat? Die Antwort ist einfach: Man teilt die Funktionen nach ähnlichem Funktionsbereich und ordnet sie systematisch, also in Ordner und Dateien. Erstellen wir zwei Dateien:
decr.php:
<?php
function decr($y){
$y--;
return $y;
}
?>
incr.php:
<?php
function incr($x){
$x++;
return $x;
}
?>
Die Funktionsdefinitionen aus index.php sollte man löschen, da eine doppelte Definition einer Funktion mit gleichem Namen Fehler verursacht. Und wenn man eine Funktion ohne Definition aufruft, verursacht das ebenfalls Fehler. Seien Sie also vorsichtig.
Jetzt bleibt nur noch, die Dateien mit den Funktionen einzubinden. Das macht man mit include in index.php:
<?php include 'incr.php'; include 'decr.php'; $z = 0; $z = incr($z); $z = incr($z); $z = incr($z); $z = incr($z); $z = decr($z); print $z; ?>
Jetzt kann man den Code aus incr.php und decr.php nutzen, ohne den Code in index.php zu überladen. Wie Sie sehen, ändert sich das Ergebnis nicht, es bleibt 3.
Das sind noch nicht alle Möglichkeiten der funktionalen Programmierung in PHP, in den nächsten Lektionen werden wir diese Art der Programmierung noch ausführlicher untersuchen.