Kapitel 8: Funktionen

8.1 Syntax benutzerdefinierter Funktionen

Grundlegende Funktionsdefinition

<?php
    // Einfache Funktion definieren
    function begruesse() {
        echo "Hallo Welt!";
    }
    
    // Funktion aufrufen
    begruesse();  // Ausgabe: Hallo Welt!
    
    // Funktion mit Code-Block
    function ausgabeName() {
        $name = "Max";
        echo "Mein Name ist " . $name;
    }
    
    ausgabeName();  // Ausgabe: Mein Name ist Max
?>

Funktionsbenennung (Best Practices)

Regel	Beispiel	Gültig?
Muss mit Buchstaben oder _ beginnen	funktion1(), _geheim()	✅
Darf Zahlen enthalten (nicht am Anfang)	berechne1(), summe2()	✅
Unterscheidet Gross-/Kleinschreibung	meineFunktion() vs meinefunktion()	Verschiedene Funktionen
Sollte aussagekräftig sein	berechneFlaeche()	✅ (gut)
Kann reservierte Wörter sein (nicht empfohlen)	if(), echo()	⚠️ Möglich, aber verwirrend

Namenskonventionen:

• LowerCamelCase: berechneFlaeche() (empfohlen für Funktionen)
• Snake_Case: berechne_flaeche() (ebenfalls akzeptabel)
• Klar und aussagekräftig: getUserName(), calculateTotal()

8.2 Formalparameter, tatsächliche Parameter, Standardparameter

Parameter übergabe

<?php
    // Funktion mit Parameter(n)
    function begruesse($name) {
        echo "Hallo " . $name . "!";
    }
    
    begruesse("Max");    // Ausgabe: Hallo Max!
    begruesse("Anna");   // Ausgabe: Hallo Anna!
    
    // Mehrere Parameter
    function addiere($a, $b) {
        $summe = $a + $b;
        echo "Summe: " . $summe;
    }
    
    addiere(5, 3);  // Ausgabe: Summe: 8
    
    // Parameterreihenfolge ist wichtig!
    function begruessePerson($vorname, $nachname) {
        echo "Hallo " . $vorname . " " . $nachname;
    }
    
    begruessePerson("Max", "Müller");  // Richtig
    // begruessePerson("Müller", "Max");  // Falsch (Reihenfolge vertauscht)
?>

Standardparameter (Default-Werte)

<?php
    // Funktion mit Standardparametern
    function begruesse($name = "Gast") {
        echo "Hallo " . $name . "!";
    }
    
    begruesse("Max");   // Ausgabe: Hallo Max!
    begruesse();         // Ausgabe: Hallo Gast! (Standardwert wird verwendet)
    
    // Mehrere Parameter, Standardparameter am Ende
    function erstelleProfil($name, $alter = 25, $stadt = "Berlin") {
        echo "Name: $name, Alter: $alter, Stadt: $stadt<br>";
    }
    
    erstelleProfil("Max");              // Name: Max, Alter: 25, Stadt: Berlin
    erstelleProfil("Max", 30);        // Name: Max, Alter: 30, Stadt: Berlin
    erstelleProfil("Max", 30, "München"); // Name: Max, Alter: 30, Stadt: München
    
    // Achtung: Standardparameter mussen am Ende stehen!
    // function fehler($name = "Gast", $alter) { ... }  // FEHLER!
    function korrekt($name, $alter = 25) { ... }  // RICHTIG
?>

Variable Anzahl von Parametern (func_get_args())

<?php
    // Variable Anzahl von Parametern
    function summe() {
        $argumente = func_get_args();
        $gesamt = 0;
        
        foreach ($argumente as $arg) {
            $gesamt += $arg;
        }
        
        return $gesamt;
    }
    
    echo summe(1, 2, 3);       // 6
    echo summe(1, 2, 3, 4, 5); // 15
    
    // Ab PHP 5.6: ... (Spread-Operator)
    function summeNeu(...$zahlen) {
        return array_sum($zahlen);
    }
    
    echo summeNeu(1, 2, 3);  // 6
?>

8.3 Rückgabewert return

Grundlegende Verwendung von return

<?php
    // Funktion mit Rückgabewert
    function addiere($a, $b) {
        $summe = $a + $b;
        return $summe;  // Gibt das Ergebnis zurück
    }
    
    $ergebnis = addiere(5, 3);
    echo $ergebnis;  // 8
    
    // Direkt in Berechnungen verwenden
    $doppelt = addiere(5, 3) * 2;
    echo $doppelt;  // 16
    
    // Mehrere Rückgabewerte (als Array)
    function berechneQuadrat($seite) {
        $umfang = 4 * $seite;
        $flaeche = $seite * $seite;
        return [$umfang, $flaeche];  // Array zurückgeben
    }
    
    list($u, $f) = berechneQuadrat(5);
    echo "Umfang: $u, Fläche: $f";  // Umfang: 20, Fläche: 25
?>

Rückgabewert-Typen (Type Declarations - PHP 7+)

<?php
    // Rückgabewert-Typ festlegen (PHP 7+)
    function addiere(int $a, int $b): int {
        return $a + $b;
    }
    
    echo addiere(5, 3);   // 8
    echo addiere(5.5, 3.2); // 8 (Typumwandlung zu int)
    
    // Strenge Typüberprüfung (declare(strict_types=1))
    declare(strict_types=1);
    
    function multipliziere(int $a, int $b): int {
        return $a * $b;
    }
    
    // multipliziere(5.5, 3);  // FEHLER! (TypeError)
    multipliziere(5, 3);      // 15 (OK)
    
    // Verschiedene Rückgabetypen
    function gibText(): string {
        return "Hallo";
    }
    
    function gibArray(): array {
        return [1, 2, 3];
    }
    
    function gibBool(): bool {
        return true;
    }
?>

Funktion vorzeitig beenden (return)

<?php
    // Funktion vorzeitig beenden
    function pruefeAlter($alter) {
        if ($alter < 0) {
            echo "Ungültiges Alter!";
            return;  // Funktion hier beenden
        }
        
        if ($alter < 18) {
            echo "Minderjährig";
        } else {
            echo "Volljährig";
        }
    }
    
    pruefeAlter(-5);   // Ungültiges Alter!
    pruefeAlter(20);   // Volljährig
    
    // Rückgabewert kann auch null sein
    function findeBenutzer($id) {
        if ($id <= 0) {
            return null;  // Kein Benutzer gefunden
        }
        // ... Benutzer suchen ...
        return $benutzer;
    }
    
    $benutzer = findeBenutzer(-1);
    if ($benutzer === null) {
        echo "Benutzer nicht gefunden!";
    }
?>

8.4 Variablen-Gültigkeitsbereich (global/lokal)

Lokalen Variablen

<?php
    // Lokalen Variablen (nur innerhalb der Funktion sichtbar)
    function meineFunktion() {
        $lokal = "Ich bin lokal";
        echo $lokal;
    }
    
    meineFunktion();  // Ausgabe: Ich bin lokal
    // echo $lokal;  // FEHLER! $lokal ist ausserhalb nicht definiert
    
    // Gleichnamige Variablen in und ausserhalb von Funktionen
    $variable = "Global";
    
    function test() {
        $variable = "Lokal";  // Das ist eine ANDERE Variable!
        echo $variable;  // Lokal
    }
    
    test();            // Ausgabe: Lokal
    echo $variable;   // Ausgabe: Global (unverändert)
?>

Globalen Variablen

<?php
    // Globale Variable innerhalb einer Funktion verwenden
    $zaehler = 0;
    
    function inkrementiere() {
        global $zaehler;  // Auf globale Variable zugreifen
        $zaehler++;
        echo $zaehler . " ";
    }
    
    inkrementiere();  // 1
    inkrementiere();  // 2
    inkrementiere();  // 3
    
    echo $zaehler;  // 3 (globale Variable wurde geändert)
    
    // Alternative: $GLOBALS-Array verwenden
    $zaehler2 = 0;
    
    function inkrementiere2() {
        $GLOBALS['zaehler2']++;
        echo $GLOBALS['zaehler2'] . " ";
    }
    
    inkrementiere2();  // 1
    inkrementiere2();  // 2
    echo $zaehler2;    // 2
?>

Statische Variablen (static)

<?php
    // Statische Variablen (Wert bleibt erhalten)
    function zaehle() {
        static $zaehler = 0;  // Wird nur einmal initialisiert!
        $zaehler++;
        echo $zaehler . " ";
    }
    
    zaehle();  // 1
    zaehle();  // 2
    zaehle();  // 3
    zaehle();  // 4
    
    // Ohne static würde es immer 1 sein
    function zaehleNormal() {
        $zaehler = 0;  // Wird bei jedem Aufruf neu initialisiert
        $zaehler++;
        echo $zaehler . " ";
    }
    
    zaehleNormal();  // 1
    zaehleNormal();  // 1 (wieder 0!)
    zaehleNormal();  // 1
?>

8.5 Systemeigene Funktionen (String, Array, Zeit)

Wichtige String-Funktionen

<?php
    // String-Funktionen
    $text = "  Hallo Welt!  ";
    
    echo strlen($text);           // 16 (Länge inkl. Leerzeichen)
    echo strtolower($text);      // "  hallo welt!  "
    echo strtoupper($text);      // "  HALLO WELT!  "
    echo ucfirst("hallo");       // "Hallo" (erster Buchstabe gross)
    echo ucwords("hallo welt"); // "Hallo Welt" (jedes Wort gross)
    
    // Leerzeichen entfernen
    echo trim($text);           // "Hallo Welt!" (Leerzeichen entfernen)
    echo ltrim($text);          // "Hallo Welt!  " (nur links)
    echo rtrim($text);          // "  Hallo Welt!" (nur rechts)
    
    // Teilstring extrahieren
    $name = "Max Müller";
    echo substr($name, 0, 3);  // "Max" (ab Position 0, 3 Zeichen)
    echo substr($name, 4);     // "Müller" (ab Position 4 bis Ende)
    
    // Suchen und Ersetzen
    $email = "max@example.com";
    echo strpos($email, "@");   // 3 (Position von "@")
    echo str_replace("example", "test", $email);  // "max@test.com"
    
    // String zerlegen und zusammenfügen
    $saetze = "Apfel,Banane,Kirsche";
    $fruechte = explode(",", $saetze);  // In Array umwandeln
    print_r($fruechte);  // ["Apfel", "Banane", "Kirsche"]
    
    $wieder_zusammen = implode(", ", $fruechte);  // In String umwandeln
    echo $wieder_zusammen;  // "Apfel, Banane, Kirsche"
?>

Wichtige Array-Funktionen

<?php
    // Array-Funktionen (schon in Kapitel 7 behandelt)
    $zahlen = [5, 2, 8, 1, 9];
    
    echo count($zahlen);        // 5 (Anzahl Elemente)
    sort($zahlen);            // Aufsteigend sortieren
    print_r($zahlen);        // [1, 2, 5, 8, 9]
    
    $person = ["name" => "Max", "alter" => 25];
    echo array_key_exists("name", $person);  // true
    echo in_array(25, $person);             // true
    
    // Weitere nützliche Funktionen
    $arr1 = [1, 2, 3];
    $arr2 = [4, 5, 6];
    $zusammengefuegt = array_merge($arr1, $arr2);
    print_r($zusammengefuegt);  // [1, 2, 3, 4, 5, 6]
    
    $umgekehrt = array_reverse($arr1);
    print_r($umgekehrt);  // [3, 2, 1]
?>

Zeit- und Datum-Funktionen

<?php
    // Zeit- und Datum-Funktionen
    echo time();              // Aktueller Unix-Timestamp (Sekunden seit 1970)
    echo date("d.m.Y");      // Aktuelles Datum: 26.05.2024
    echo date("H:i:s");      // Aktuelle Uhrzeit: 14:30:45
    echo date("d.m.Y H:i:s"); // 26.05.2024 14:30:45
    
    // Datumsformate
    echo date("l");          // Wochentag (voll): Sunday
    echo date("D");          // Wochentag (kurz): Sun
    echo date("F");          // Monat (voll): May
    echo date("M");          // Monat (kurz): May
    echo date("Y");          // Jahr (4-stellig): 2024
    echo date("y");          // Jahr (2-stellig): 24
    
    // Benutzerdefiniertes Datum erstellen
    $benutzerdatum = mktime(14, 30, 0, 5, 26, 2024);  // 26.05.2024 14:30:00
    echo date("d.m.Y H:i:s", $benutzerdatum);
    
    // Datum aus String parsen
    $datum = strtotime("2024-05-26 14:30:00");
    echo date("d.m.Y H:i:s", $datum);
    
    echo strtotime("next Monday");    // Nächster Montag
    echo strtotime("+1 week");       // In einer Woche
    echo strtotime("-1 day");        // Vor einem Tag
?>

8.6 Rekursive Funktionen (einfach kennenlernen)

Was ist Rekursion?

Eine rekursive Funktion ist eine Funktion, die sich selbst aufruft.

<?php
    // Einfache Rekursion: Fakultät berechnen
    function fakultaet($n) {
        if ($n <= 1) {
            return 1;  // Basisfall (Rekursionsende)
        } else {
            return $n * fakultaet($n - 1);  // Rekursiver Aufruf
        }
    }
    
    echo fakultaet(5);  // 120 (5! = 5 × 4 × 3 × 2 × 1 = 120)
    
    // Ablauf von fakultaet(5):
    // fakultaet(5) = 5 * fakultaet(4)
    // fakultaet(4) = 4 * fakultaet(3)
    // fakultaet(3) = 3 * fakultaet(2)
    // fakultaet(2) = 2 * fakultaet(1)
    // fakultaet(1) = 1 (Basisfall)
    // Dann Rückwärts: 1 → 2 → 6 → 24 → 120
?>

Fibonaccifolge (rekursiv)

<?php
    // Fibonaccifolge (rekursiv)
    function fibonacci($n) {
        if ($n <= 1) {
            return $n;  // Basisfall
        } else {
            return fibonacci($n - 1) + fibonacci($n - 2);
        }
    }
    
    // Erste 10 Fibonaccizahlen ausgeben
    for ($i = 0; $i < 10; $i++) {
        echo fibonacci($i) . " ";
    }
    // Ausgabe: 0 1 1 2 3 5 8 13 21 34
    
    // Achtung: Rekursion kann langsam sein und zu Speicherüberlauf führen!
    // Für grössere n ist eine iterative Lösung besser.
?>

Potenzberechnung (rekursiv)

<?php
    // Potenzberechnung (rekursiv)
    function potenz($basis, $exponent) {
        if ($exponent == 0) {
            return 1;  // Alles hoch 0 = 1
        } else {
            return $basis * potenz($basis, $exponent - 1);
        }
    }
    
    echo potenz(2, 3);  // 8 (2³ = 2 × 2 × 2 = 8)
    echo potenz(5, 2);  // 25 (5² = 5 × 5 = 25)
    
    // Achtung: Endlosschleife vermeiden!
    // Immer einen Basisfall definieren, der die Rekursion beendet.
?>

8.7 Praxis: Häufig verwendete Tool-Funktionen kapseln

Aufgabe: Schreiben Sie nützliche Tool-Funktionen für die Webentwicklung.

<?php
    // Tool-Funktionen kapseln
    
    // 1. Funktion: String kürzen (für Vorschau)
    function kuerzeText($text, $laenge = 50) {
        if (strlen($text) <= $laenge) {
            return $text;
        } else {
            return substr($text, 0, $laenge) . "...";
        }
    }
    
    // 2. Funktion: Datum formatieren
    function formatiereDatum($datum_string) {
        $datum = strtotime($datum_string);
        return date("d.m.Y", $datum);
    }
    
    // 3. Funktion: Preis formatieren
    function formatierePreis($preis) {
        return number_format($preis, 2, ',', '.') . " €";
    }
    
    // 4. Funktion: Array nach Wert sortieren (assoziatives Array)
    function sortiereArrayNachWert($array, $aufsteigend = true) {
        if ($aufsteigend) {
            asort($array);
        } else {
            arsort($array);
        }
        return $array;
    }
    
    // 5. Funktion: Passwort-Hash erstellen
    function erstellePasswortHash($passwort) {
        return password_hash($passwort, PASSWORD_DEFAULT);
    }
    
    // 6. Funktion: Passwort verifizieren
    function verifizierePasswort($passwort, $hash) {
        return password_verify($passwort, $hash);
    }
    
    // Test der Funktionen
    $text = "Dies ist ein sehr langer Text, der gekürzt werden soll.";
    echo kuerzeText($text, 20) . "<br>";  // "Dies ist ein sehr l..."
    
    echo formatiereDatum("2024-05-26") . "<br>";  // "26.05.2024"
    
    echo formatierePreis(1234.56) . "<br>";  // "1.234,56 €"
    
    $noten = ["Max" => 1.0, "Anna" => 1.3, "Tim" => 2.0];
    $sortiert = sortiereArrayNachWert($noten);
    print_r($sortiert);  // Tim=2.0, Anna=1.3, Max=1.0
    
    $hash = erstellePasswortHash("meinPasswort");
    echo $hash . "<br>";
    
    if (verifizierePasswort("meinPasswort", $hash)) {
        echo "Passwort korrekt!";
    } else {
        echo "Passwort falsch!";
    }
?>

Zusammenfassung

In diesem Kapitel haben Sie:

• ✅ Benutzerdefinierte Funktionen definiert und aufgerufen
• ✅ Parameter (Formalparameter, tatsächliche Parameter) verstanden
• ✅ Standardparameter (Default-Werte) verwendet
• ✅ Rückgabewerte mit return verwendet
• ✅ Variablen-Gültigkeitsbereich (global/lokal/static) verstanden
• ✅ Wichtige systemeigene Funktionen (String, Array, Zeit) kennengelernt
• ✅ Rekursive Funktionen (einfach) kennengelernt
• ✅ Praxisbeispiele (Tool-Funktionen) erstellt

Nächstes Kapitel: Wir werden Formulare und Benutzerinteraktion lernen (GET/POST).

---

Übungsaufgaben:

1. Schreiben Sie eine Funktion, die prüft, ob eine Zahl prim ist
2. Erstellen Sie eine Funktion, die den Flächeninhalt eines Kreises berechnet
3. Schreiben Sie eine rekursive Funktion für die Summe von 1 bis n
4. Erstellen Sie eine Funktion, die ein Array nach einem Schlüssel sortiert

Häufige Fehler:

• ❌ Funktion aufrufen vor ihrer Definition → In PHP ist das erlaubt, aber schlechte Praxis
• ❌ $this-> in normalen Funktionen verwenden → $this ist nur in Klassen verfügbar
• ❌ global zu häufig verwenden → Besser: Parameter und Rückgabewerte verwenden
• ❌ Rekursion ohne Basisfall → Führt zu Endlosschleife und Speicherüberlauf