Modul 295
Backend für Applikationen realisieren
05 - Funktionen
Code strukturieren und wiederverwenden
Lernziele dieser Lektion
- Eigene Funktionen in PHP definieren und aufrufen können
- Parameter (auch mit Default-Werten, Typen und Namen) einsetzen können
- Werte mit
return zurückgeben können
- Den Gültigkeitsbereich (Scope) von Variablen erklären können
- Referenzen, statische Variablen und Rekursion einsetzen können
- Anonyme Funktionen, Closures und Arrow Functions verwenden können
Rückblick: Schleifen und Arrays
-
Mit Schleifen haben wir Code-Wiederholung vermieden -
derselbe Codeblock lief mehrmals
-
Heute geht es um eine andere Art von Wiederholung: derselbe
Codeblock soll an verschiedenen Stellen im Programm
nutzbar sein
<?php
// Dieser Code taucht immer wieder auf...
echo "Rabatt für Anna: " . (100 * 0.9);
echo "Rabatt für Bruno: " . (250 * 0.9);
echo "Rabatt für Clara: " . (80 * 0.9);
Wozu Funktionen?
-
Das Konzept "Funktion" kennen Sie bereits aus anderen
Sprachen - in PHP gilt dasselbe Prinzip
-
Eine Funktion fasst einen Codeblock unter einem Namen
zusammen und macht ihn wiederverwendbar
-
Vorteile: weniger Wiederholung (DRY), bessere Lesbarkeit,
einfacheres Testen und Anpassen
<?php
function priceWithDiscount($price) {
echo "Preis: " . ($price * 0.9);
}
priceWithDiscount(100); // Preis: 90
priceWithDiscount(250); // Preis: 225
priceWithDiscount(80); // Preis: 72
Eine Funktion definieren
-
Mit dem Schlüsselwort
function,
gefolgt vom Namen, runden Klammern und einem Codeblock in
geschweiften Klammern
-
Funktionsnamen: keine Leerzeichen, meist
camelCase, dürfen nicht mit
einer Zahl beginnen
<?php
function greet() {
echo "Hallo zusammen!";
}
// Bis hierhin passiert noch nichts -
// die Funktion wurde nur definiert
Eine Funktion aufrufen
-
Der Codeblock wird erst ausgeführt, wenn die Funktion
aufgerufen wird - mit ihrem Namen und runden Klammern
-
Eine Funktion kann beliebig oft aufgerufen werden
<?php
function greet() {
echo "Hallo zusammen!";
}
greet(); // "Hallo zusammen!"
greet(); // "Hallo zusammen!" - nochmals
Parameter übergeben
-
Parameter sind Variablen in der Klammer der
Funktionsdefinition - sie machen eine Funktion flexibel
-
Beim Aufruf übergibt man konkrete Werte, die
Argumente genannt werden
<?php
function greet($name) {
echo "Hallo " . $name . "!";
}
greet("Anna"); // "Hallo Anna!"
greet("Bruno"); // "Hallo Bruno!"
Mehrere Parameter
-
Eine Funktion kann beliebig viele Parameter haben, getrennt
durch Kommas
-
Die Argumente beim Aufruf werden der Reihenfolge nach
den Parametern zugeordnet
<?php
function greet($firstname, $lastname) {
echo "Hallo " . $firstname . " " . $lastname . "!";
}
greet("Anna", "Muster"); // "Hallo Anna Muster!"
Werte zurückgeben mit return
-
echo gibt nur etwas auf dem
Bildschirm aus - der Wert steht danach nicht mehr zur
Verfügung
-
return gibt einen Wert an
die Aufrufstelle zurück, wo er weiterverwendet werden
kann
<?php
function add($a, $b) {
return $a + $b;
}
$result = add(3, 4);
echo $result; // 7
echo add(10, 5) * 2; // 30
return beendet die Funktion
-
Sobald
return ausgeführt
wird, endet die Funktion sofort - egal, was danach noch
folgen würde
-
Ideal, um z.B. bei einer ungültigen Eingabe frühzeitig
auszusteigen
<?php
function safeDivide($a, $b) {
if ($b === 0) {
return "Division durch 0 nicht möglich";
}
return $a / $b; // wird nur erreicht, wenn $b != 0
}
echo safeDivide(10, 0); // "Division durch 0 nicht möglich"
echo safeDivide(10, 2); // 5
Funktionen ohne return
-
Nicht jede Funktion muss einen Wert zurückgeben - manche
lösen nur eine Aktion aus (z.B. eine Ausgabe)
-
Ohne
return liefert eine
Funktion automatisch null
zurück
<?php
function logMessage($text) {
echo "[LOG] " . $text;
}
$result = logMessage("Server gestartet");
var_dump($result); // NULL
Default-Werte für Parameter
-
Einem Parameter kann ein Standardwert zugewiesen
werden - er wird verwendet, wenn beim Aufruf kein Argument
übergeben wird
-
Damit wird der Parameter optional
<?php
function greet($name = "Gast") {
echo "Hallo " . $name . "!";
}
greet("Anna"); // "Hallo Anna!"
greet(); // "Hallo Gast!"
Reihenfolge bei optionalen Parametern
-
Parameter mit Default-Wert müssen nach den
Pflichtparametern stehen
-
Sonst wäre beim Aufruf nicht eindeutig, welches Argument zu
welchem Parameter gehört
<?php
// Richtig: optionaler Parameter am Ende
function greet($name, $greeting = "Hallo") {
echo $greeting . " " . $name . "!";
}
greet("Anna"); // "Hallo Anna!"
greet("Anna", "Servus"); // "Servus Anna!"
Parameter- und Rückgabetypen
-
PHP erlaubt, den erwarteten Typ eines Parameters direkt
anzugeben (Type Hint) - z.B.
int,
string,
float,
bool,
array
-
Nach der Parameterliste kann mit
: Typ auch der
Rückgabetyp festgelegt werden
<?php
function add(int $a, int $b): int {
return $a + $b;
}
echo add(3, 4); // 7
echo add(3, "4a"); // Fehler bzw. Warnung
Typen werden standardmässig angepasst
-
Ohne weitere Einstellung wandelt PHP passende Werte
automatisch um (z.B.
"4" zu
4)
-
Mit
declare(strict_types=1);
ganz am Anfang der Datei wird das verhindert - falsche Typen
lösen dann einen Fehler aus
<?php
declare(strict_types=1);
function add(int $a, int $b): int {
return $a + $b;
}
echo add(3, "4"); // TypeError: "4" ist kein int
Benannte Argumente (Named Arguments)
-
Statt der Reihenfolge nach kann man Argumente auch über den
Parameternamen übergeben
-
Praktisch bei vielen (v.a. optionalen) Parametern - der
Aufruf bleibt lesbar
<?php
function greet($name, $greeting = "Hallo") {
echo $greeting . " " . $name . "!";
}
greet(name: "Anna", greeting: "Servus"); // "Servus Anna!"
greet(greeting: "Servus", name: "Anna"); // Reihenfolge egal
Variable Anzahl Argumente
-
Mit
...$args (drei Punkte)
nimmt ein Parameter beliebig viele Argumente als
Array entgegen
-
Nützlich, wenn die Anzahl Werte beim Schreiben der Funktion
noch nicht feststeht
<?php
function sum(...$numbers) {
$total = 0;
foreach ($numbers as $n) {
$total += $n;
}
return $total;
}
echo sum(1, 2, 3); // 6
echo sum(5, 10, 15, 20); // 50
Mehrere Werte zurückgeben
-
return kann nur einen
Wert zurückgeben - ist ein Array dieser Wert, lassen sich
trotzdem mehrere Werte transportieren
<?php
function minMax($numbers) {
return [min($numbers), max($numbers)];
}
$result = minMax([5, 3, 8, 1]);
echo $result[0]; // 1 (Minimum)
echo $result[1]; // 8 (Maximum)
// Praktisch: direkt in Variablen aufteilen
[$smallest, $largest] = minMax([5, 3, 8, 1]);
Gültigkeitsbereich (Scope)
-
Variablen, die innerhalb einer Funktion angelegt
werden, sind lokal - sie existieren nur dort
-
Ausserhalb der Funktion definierte Variablen sind innerhalb
der Funktion standardmässig nicht sichtbar
<?php
function calculate() {
$result = 42; // lokale Variable
echo $result; // 42
}
calculate();
echo $result; // Fehler: $result existiert hier nicht
Das global-Schlüsselwort
-
Mit
global kann eine
Funktion trotzdem auf eine globale Variable zugreifen
-
In der Praxis eher vermeiden - Werte besser als Parameter
übergeben und mit
return
zurückgeben
<?php
$counter = 0;
function increment() {
global $counter;
$counter++;
}
increment();
increment();
echo $counter; // 2
Statische Variablen
-
Eine mit
static deklarierte
Variable behält ihren Wert über mehrere Aufrufe der
Funktion hinweg
-
Sie wird nur beim ersten Aufruf initialisiert
<?php
function countCalls() {
static $count = 0;
$count++;
echo "Aufruf Nr. " . $count;
}
countCalls(); // "Aufruf Nr. 1"
countCalls(); // "Aufruf Nr. 2"
countCalls(); // "Aufruf Nr. 3"
Pass by Value vs. Pass by Reference
-
Standardmässig erhält eine Funktion eine Kopie des
Arguments (by value) - Änderungen wirken sich nicht
nach aussen aus
-
Mit
& vor dem Parameter
erhält die Funktion eine Referenz (by
reference) - Änderungen wirken sich direkt auf die
Original-Variable aus
<?php
function addOne($n) {
$n = $n + 1; // wirkt sich nicht nach aussen aus
}
function addOneByRef(&$n) {
$n = $n + 1; // verändert das Original
}
$x = 5;
addOne($x);
echo $x; // 5
addOneByRef($x);
echo $x; // 6
Rekursion
-
Eine rekursive Funktion ruft sich selbst auf - sie
braucht eine Abbruchbedingung, sonst läuft sie
endlos (wie bei einer Schleife ohne Ende)
-
Nützlich bei Problemen, die sich in gleichartige,
kleinere Teilprobleme zerlegen lassen
<?php
function factorial($n) {
if ($n <= 1) {
return 1; // Abbruchbedingung
}
return $n * factorial($n - 1); // Selbstaufruf
}
echo factorial(5); // 5*4*3*2*1 = 120
Anonyme Funktionen
-
Eine Funktion ohne Namen, die direkt einer Variable
zugewiesen wird - auch Closure genannt
-
Nützlich, wenn eine Funktion nur an einer Stelle gebraucht
wird, z.B. als Argument einer anderen Funktion
<?php
$square = function ($n) {
return $n * $n;
};
echo $square(5); // 25
// Häufig als Argument, z.B. bei array_map
$numbers = [1, 2, 3, 4];
$squares = array_map($square, $numbers);
print_r($squares); // [1, 4, 9, 16]
Äussere Variablen mit use
-
Eine anonyme Funktion sieht standardmässig keine Variablen
von "aussen" - mit
use
werden sie gezielt eingebunden
<?php
$discount = 0.1;
$applyDiscount = function ($price) use ($discount) {
return $price * (1 - $discount);
};
echo $applyDiscount(100); // 90
Arrow Functions
-
Kurzschreibweise für einfache anonyme Funktionen:
fn(...) => Ausdruck
-
Äussere Variablen sind automatisch verfügbar - kein
use nötig
-
Es gibt kein
return und
keine geschweiften Klammern - der Ausdruck wird automatisch
zurückgegeben
<?php
$discount = 0.1;
$applyDiscount = fn($price) => $price * (1 - $discount);
echo $applyDiscount(100); // 90
$numbers = [1, 2, 3, 4];
$squares = array_map(fn($n) => $n * $n, $numbers);
Eingebaute PHP-Funktionen
-
PHP bringt hunderte fertige Funktionen mit -
strlen(),
strtoupper(),
count(),
array_map() und viele mehr
kennen Sie bereits
-
Bevor Sie selbst eine Funktion schreiben: prüfen, ob PHP
nicht schon eine passende Funktion mitbringt -
php.net/manual
hilft weiter
TL;DR
-
Eine Funktion wird mit
function
definiert und über ihren Namen aufgerufen -
Parameter machen sie flexibel,
return liefert ein
Ergebnis zurück
-
Default-Werte, Type Hints und benannte Argumente machen
Funktionsaufrufe klarer und sicherer
-
Variablen innerhalb einer Funktion sind lokal -
global und
static sind gezielte
Ausnahmen
-
& übergibt eine
Referenz statt einer Kopie (by reference)
-
Anonyme Funktionen (
function()
mit use) und
Arrow Functions (fn() =>)
sind kompakte Funktionen ohne eigenen Namen