Funktionen

Geschätzte Lektüre: 13 Minuten 605 Ansichten

Was sind Funktionen in PHP?

Funktionen sind wiederverwendbare Code-Blöcke, die eine bestimmte Aufgabe erledigen. Stellen Sie sich eine Funktion wie eine Küchenmaschine vor: Sie geben Zutaten hinein (Eingabewerte), die Maschine verarbeitet sie und gibt Ihnen ein Ergebnis zurück (Ausgabewert).

Vorteile von Funktionen:

  • Wiederverwendbarkeit: Code muss nicht mehrmals geschrieben werden
  • Organisation: Code wird übersichtlicher und besser strukturiert
  • Wartbarkeit: Änderungen müssen nur an einer Stelle vorgenommen werden
  • Testbarkeit: Einzelne Funktionen können isoliert getestet werden

Grundlegende Syntax

function funktionsName($parameter1, $parameter2) {
    // Code, der ausgeführt wird
    return $ergebnis; // Optional
}

Einfaches Beispiel

function begruessung($name) {
    return "Hallo, " . $name . "!";
}

echo begruessung("Anna"); // Ausgabe: Hallo, Anna!

Arten von Funktionen

Benutzerdefinierte Funktionen

Das sind Funktionen, die Sie selbst erstellen, wie im obigen Beispiel.

Eingebaute PHP-Funktionen

PHP bietet viele vordefinierte Funktionen:
• strlen() – Länge eines Strings
• array_sum() – Summe eines Arrays
• date() – Aktuelles Datum

$text = "Hallo Welt";
echo strlen($text); // Ausgabe: 10

Parameter und Argumente

• Parameter: Variablen in der Funktionsdefinition
• Argumente: Tatsächliche Werte, die an die Funktion übergeben werden

// $a und $b sind Parameter
function addieren($a, $b) {
    return $a + $b;
}

// 5 und 3 sind Argumente
echo addieren(5, 3); // Ausgabe: 8

Optionale Parameter und Standardwerte

function multiplizieren($a, $b = 2) {
    return $a * $b;
}

echo multiplizieren(4);    // Ausgabe: 8 (weil $b=2)
echo multiplizieren(4, 3); // Ausgabe: 12

Rückgabewerte

Funktionen können mit return Werte zurückgeben. Ohne return gibt die Funktion NULL zurück.

function istErwachsen($alter) {
    if ($alter >= 18) {
        return true;
    } else {
        return false;
    }
}

if (istErwachsen(20)) {
    echo "Erwachsen";
} else {
    echo "Jugendlich";
}

Geltungsbereich von Variablen (Scope)

Variablen innerhalb einer Funktion sind nur dort sichtbar (lokaler Scope). Globale Variablen sind nicht automatisch verfügbar.

$globaleVariable = "Hallo";

function zeigeVariable() {
    // Das würde einen Fehler verursachen
    // echo $globaleVariable;
    
    $lokaleVariable = "Welt";
    return $lokaleVariable;
}

echo zeigeVariable(); // Ausgabe: Welt
// echo $lokaleVariable; // Fehler

Zugriff auf globale Variablen

$zahl = 10;

function erhoeheZahl() {
    global $zahl;
    $zahl += 5;
}

erhoeheZahl();
echo $zahl; // Ausgabe: 15

Typdeklarationen (Type Hinting)

Seit PHP 7 können Datentypen für Parameter und Rückgabewerte festgelegt werden.

function addiereZahlen(int $a, int $b): int {
    return $a + $b;
}

echo addiereZahlen(5, "10"); // Ausgabe: 15 (PHP versucht zu konvertieren)
// echo addiereZahlen(5, "zehn"); // Fehler

Rekursive Funktionen

Eine Funktion, die sich selbst aufruft. Vorsicht: Endlosschleifen vermeiden!

function fakultaet($n) {
    if ($n <= 1) {
        return 1;
    } else {
        return $n * fakultaet($n - 1);
    }
}

echo fakultaet(5); // Ausgabe: 120 (5*4*3*2*1)

Anonyme Funktionen (Closures)

Funktionen ohne Namen, die Variablen zugewiesen werden können.

$verdoppeln = function($zahl) {
    return $zahl * 2;
};

echo $verdoppeln(4); // Ausgabe: 8

Callbacks: Funktionen als Argumente

Callbacks sind Funktionen, die an andere Funktionen übergeben werden, um später ausgeführt zu werden – wie ein Rückruf bei einer Hotline. Sie werden oft für Array-Operationen oder Event-Handling genutzt.

Beispiel mit array_map:

$zahlen = [1, 2, 3];
$verdoppelt = array_map(function($x) { 
    return $x * 2; 
}, $zahlen);
// Ergebnis: [2, 4, 6]

Hier wird die anonyme Funktion für jedes Element in $zahlen ausgeführt.

Callback-Beispiel: Eigene Funktion als Argument übergeben

Hier wird eine benannte Funktion (begruesse) deklariert und später als Callback an eine andere Funktion (ausfuehrenMitNamen) übergeben. Das zeigt, wie Callbacks Funktionen flexibel wiederverwendbar machen.

// 1. Callback-Funktion definieren
function begruesse($name) {
    return "Hallo, $name! 👋";
}

// 2. Funktion, die einen Callback akzeptiert
function ausfuehrenMitNamen($callback, $name) {
    return $callback($name); // Führt den Callback aus
}

// 3. Die benannte Funktion als Callback übergeben
$ergebnis = ausfuehrenMitNamen('begruesse', 'Max');
echo $ergebnis; // Ausgabe: "Hallo, Max! 👋"

Was passiert hier?
01. begruesse ist eine ganz normale Funktion.
02. ausfuehrenMitNamen erwartet einen Funktionsnamen ($callback) und führt ihn mit $name aus.
03. Beim Aufruf wird ‚begruesse‚ (als String!) übergeben – PHP ruft dann die Funktion auf.

Praktischer Nutzen:
• Sie könnten stattdessen auch eine andere Funktion wie verabschiede übergeben, ohne ausfuehrenMitNamen ändern zu müssen.
• Typisch für Event-Handler oder Filter-Systeme (z. B. in WordPress).

Alternative mit anonymem Callback:

$ergebnis = ausfuehrenMitNamen(
    function($name) { return "Tschüss, $name! 👋"; },
    'Anna'
);
echo $ergebnis; // "Tschüss, Anna! 👋"

• Callbacks machen Code anpassbar, indem sie Logik von außen „injizieren„.

Arrow-Funktionen: Kurz und bündig

Arrow-Funktionen (ab PHP 7.4) sind eine kompakte Schreibweise für anonyme Funktionen. Sie erben automatisch Variablen aus dem umgebenden Scope – wie ein schneller Notizzettel.

Vergleich:

// Anonyme Funktion  
$f = function($x) { return $x * 2; };  

// Arrow-Funktion (kürzer)  
$f = fn($x) => $x * 2;  

echo $f(4); // Ausgabe: 8

Einschränkung: Arrow-Funktionen können nur einen Ausdruck zurückgeben (keine {}-Blöcke).

Referenzparameter: Original statt Kopie

Normale Parameter werden als Kopie übergeben. Mit & arbeitet die Funktion direkt auf dem Originalwert – wie ein Mechaniker, der ein Auto direkt repariert, statt es zu kopieren.

Beispiel:

function resetToZero(&$variable) {
    $variable = 0;
}

$wert = 5;
resetToZero($wert);
echo $wert; // Ausgabe: 0 (Original wurde geändert!)

Typische Anwendung: Modifikation von Arrays oder großen Objekten ohne Performance-Overhead.

Static-Variablen: Funktionen mit Gedächtnis

Static-Variablen behalten ihren Wert zwischen Funktionsaufrufen – wie ein Notizblock, der nicht weggeworfen wird.

Beispiel für einen Zähler:

function zaehleAuf() {
    static $count = 0; // Initialisierung nur beim 1. Aufruf
    $count++;
    return $count;
}

echo zaehleAuf(); // 1  
echo zaehleAuf(); // 2

Hinweis: Static-Variablen sind nur lokal in der Funktion sichtbar, aber persistent!

Praktische Beispiele

E-Mail Validierung

function istGueltigeEmail($email) {
    return filter_var($email, FILTER_VALIDATE_EMAIL) !== false;
}

if (istGueltigeEmail("test@example.com")) {
    echo "Gültige E-Mail";
} else {
    echo "Ungültige E-Mail";
}

Passwort-Generator

function generierePasswort($laenge = 8) {
    $zeichen = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*()";
    $passwort = "";
    for ($i = 0; $i < $laenge; $i++) {
        $passwort .= $zeichen[rand(0, strlen($zeichen) - 1)];
    }
    return $passwort;
}

echo generierePasswort(12);

Währungsumrechner

function konvertiereWaehrung($betrag, $von, $zu) {
    // Einfache Wechselkurse (in der Praxis würden Sie aktuelle Kurse verwenden)
    $kurse = [
        'USD' => ['EUR' => 0.85, 'GBP' => 0.73],
        'EUR' => ['USD' => 1.18, 'GBP' => 0.86],
        'GBP' => ['USD' => 1.37, 'EUR' => 1.16]
    ];
    
    if (isset($kurse[$von][$zu])) {
        return $betrag * $kurse[$von][$zu];
    } else {
        return null;
    }
}

echo konvertiereWaehrung(100, 'USD', 'EUR'); // Ausgabe: 85

Best Practices

  1. Klare Namen verwenden: berechneteUmsatzsteuer() ist besser als bu()
  2. Eine Aufgabe pro Funktion: Funktionen sollten nur eine Sache tun
  3. Dokumentation: Kommentare oder PHPDoc verwenden
  4. Reasonable Länge: Funktionen sollten nicht zu lang sein (max. 20-30 Zeilen)
  5. Vermeiden Sie globale Variablen: Nutzen Sie Parameter und Rückgabewerte

Funktionen als Bausteine

Stellen Sie sich Funktionen wie Legosteine vor. Jeder Stein (Funktion) hat eine bestimmte Form und Aufgabe. Indem Sie diese Steine kombinieren, können Sie komplexe Strukturen (Programme) bauen, ohne jedes Mal bei Null anfangen zu müssen.

// Bausteine
function holeBenutzerDaten($id) { /* ... */ }
function validiereEmail($email) { /* ... */ }
function sendeWillkommensEmail($email) { /* ... */ }

// Kombination
function registriereBenutzer($benutzerDaten) {
    if (!validiereEmail($benutzerDaten['email'])) {
        return false;
    }
    
    $benutzer = holeBenutzerDaten($benutzerDaten['id']);
    sendeWillkommensEmail($benutzer['email']);
    
    return true;
}

Überblick

ElementBeschreibungBeispiel
FunktionsdeklarationDefinition einer Funktion mit function gefolgt vom Namen.function sageHallo() { … }
FunktionsnameBezeichner der Funktion (case-insensitive). Sollte klar und beschreibend sein.function berechneUmsatz() { … }
ParameterVariablen, die in der Definition als Platzhalter dienen.function addiere($a, $b) { … } ($a und $b sind Parameter)
ArgumenteTatsächliche Werte, die beim Aufruf übergeben werden.addiere(5, 3); (5 und 3 sind Argumente)
Rückgabewert (return)Gibt ein Ergebnis zurück. Beendet die Funktion.return $a + $b;
StandardwerteFallback-Werte für Parameter, falls kein Argument übergeben wird.function multipliziere($a, $b = 2) { … }
TypdeklarationDefiniert erwartete Datentypen für Parameter/Rückgabewerte (ab PHP 7).function summe(int $a, int $b): int { … }
Lokale VariablenVariablen, die nur innerhalb der Funktion existieren.function test() { $x = 10; } ($x ist lokal)
Globale VariablenZugriff auf Variablen außerhalb der Funktion mit global.global $extern;
Anonyme FunktionenFunktionen ohne Namen, oft als Callback oder Closure genutzt.$quadrat = function($n) { return $n * $n; };
RekursionFunktion ruft sich selbst auf (mit Abbruchbedingung!).function fakultaet($n) { if ($n <= 1) return 1; else return $n * fakultaet($n-1); }
Variadische FunktionenAkzeptiert beliebig viele Argumente mit …function summe(…$zahlen) { return array_sum($zahlen); }
Dynamischer AufrufFunktionen mit Variablen als Namen aufrufen.$func = ‚addiere‘; $func(1, 2);

Zusätzliche Konzepte

KonzeptBeschreibungBeispiel
CallbacksFunktionen als Argumente an andere Funktionen übergeben.array_map(function($x) { return $x * 2; }, [1, 2, 3]);
Arrow-FunktionenKurzschreibweise für anonyme Funktionen (ab PHP 7.4).fn($x) => $x * 2
ReferenzparameterParameter werden als Referenz übergeben (Änderungen wirken außerhalb).function verdopple(&$zahl) { $zahl *= 2; }
Static-VariablenVariablen behalten ihren Wert zwischen Aufrufen.function zaehler() { static $count = 0; return ++$count; }

Visualisierung: Aufbau einer Funktion

         ┌── Funktionsname
         │      ┌── Parameter
         ▼      ▼
function summe(int $a, int $b = 0): int {
    $ergebnis = $a + $b; // ← Lokale Variable
    return $ergebnis;     // ← Rückgabewert
          ▲
          └── Beendet die Funktion und gibt Wert zurück

Wichtige Regeln:
• Namen: Beginnt mit Buchstabe/Unterstrich, keine Sonderzeichen.
• Parameter: Durch Kommas getrennt, optional mit Standardwerten.
• Rückgabe: Jede Funktion gibt etwas zurück – explizit per return oder implizit null.

Verbildlichung: Eine Funktion ist wie ein Kochrezept – Zutaten (Parameter) → Verarbeitung (Code) → Ergebnis (Rückgabewert).

Grundlegende Bausteine

Funktionen sind grundlegende Bausteine der PHP-Programmierung. Sie helfen dabei, Code zu organisieren, zu vereinfachen und wiederzuverwenden.
Je mehr Sie Ihre Programme in kleine, gut definierte Funktionen aufteilen, desto einfacher werden sie zu verstehen, zu testen und zu warten sein.

Dieses Dokument teilen

Funktionen

Oder Link kopieren

INHALT

Abonnieren

×
Cancel