Eigene Funktionen in PHP definieren

Inhaltsverzeichnis

Erste Schritte: Eigene Funktionen in PHP definieren

Mit Funktionen in PHP kannst du deinen Code modularisieren und wiederverwendbar machen.
Eine Funktion ist ein in sich geschlossener Codeblock, der bestimmte Aufgaben erfüllt.
In diesem Tutorial erfährst du, wie du eigene Funktionen in PHP definierst,
wie du ihnen Parameter übergibst und ggf. einen Rückgabewert erhältst.

1. Warum Funktionen?

Die wichtigsten Vorteile von Funktionen:

Wiederverwendbarkeit: Statt denselben Code mehrfach zu schreiben, legst du ihn in einer Funktion ab und rufst diese einfach auf.
Struktur & Übersicht: Du teilst dein Skript in logische Blöcke. So ist der Code besser wartbar.
Wartbarkeit & Erweiterbarkeit: Ändert sich die Funktionalität, passt du nur den Code in der Funktion an, anstatt überall.

2. Grundsyntax einer Funktion

Eine Funktion definierst du üblicherweise mit dem Schlüsselwort function:

function funktionsName() {
    // Codeblock
}

Der Name der Funktion kann Buchstaben, Zahlen und Unterstriche enthalten,
darf jedoch nicht mit einer Zahl beginnen.
Zudem ist er – im Gegensatz zu Variablen – nicht case-sensitive,
aber gute Praxis ist konsistente Schreibweise (z. B. camelCase).

Einfaches Beispiel

<?php
function sagHallo() {
    echo "Hallo Welt!<br>";
}

// Aufruf der Funktion
sagHallo();  // Gibt "Hallo Welt!" aus
sagHallo();  // Nochmal
?>

Hier wird die Funktion sagHallo() definiert und anschließend
mehrfach aufgerufen. So sparst du Codezeilen und gehst sicher,
dass immer derselbe Text ausgegeben wird.

3. Parameter übergeben

Funktionen werden oft mit Parametern oder Argumenten aufgerufen,
damit sie flexibel auf Daten reagieren können.
Der Parameter wird in runden Klammern definiert.

function sagHalloZu($name) {
    echo "Hallo, $name!<br>";
}

sagHalloZu("Lisa");
sagHalloZu("Max");

$name ist der Parameter, den du beim Funktionsaufruf übergibst.
Im Aufruf (sagHalloZu(„Lisa“)) wird „Lisa“ an $name gebunden.

3.1 Mehrere Parameter

function addiere($a, $b) {
    echo $a + $b;
}

addiere(3, 4);   // 7
addiere(10, 5);  // 15

Wenn du mehr als einen Parameter hast, trennst du sie mit Komma.

3.2 Default-Parameter (Standardwerte)

Du kannst Parameter mit einem Standardwert versehen. Wenn du beim Funktionsaufruf keinen Wert übergibst,
verwendet PHP den Standard.

function begruessen($name = "Gast") {
    echo "Willkommen, $name!<br>";
}

begruessen();          // Gibt "Willkommen, Gast!" aus
begruessen("Anna");    // "Willkommen, Anna!"

4. Rückgabewerte

Oft soll eine Funktion nicht nur etwas ausgeben, sondern ein Ergebnis zurückliefern.
Dazu nutzt du return.

function multiplikation($x, $y) {
    return $x * $y;
}

$ergebnis = multiplikation(5, 6);
echo $ergebnis; // 30

return beendet die Funktion sofort und liefert den Wert zurück.
Nach return geschriebener Code wird nicht mehr ausgeführt.

4.1 Mehrere Rückgabepfade

function checkAlter($alter) {
    if ($alter >= 18) {
        return "Volljährig";
    } else {
        return "Minderjährig";
    }
}

echo checkAlter(20); // Volljährig
echo checkAlter(16); // Minderjährig

5. Typdeklaration für Parameter & Rückgaben

Ab PHP 7 kannst du Parameter und Rückgaben typisieren, um sicherzustellen,
dass die Funktion nur bestimmte Datentypen annimmt bzw. zurückgibt:

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

echo addiereZahlen(10, 5); // 15
// echo addiereZahlen("3", "4"); // Implizites Casting oder Fehlverhalten je nach declare(strict_types=1)

Mit declare(strict_types=1) (am Anfang der Datei) kann man strikte Typprüfungen aktivieren,
sonst versucht PHP automatische Konvertierungen.

6. Variable Anzahl von Parametern

Manchmal kennst du die Anzahl der Argumente erst zur Laufzeit.
Dafür kannst du den „Splat-Operator“ … nutzen:

function summe(...$werte) {
    $ergebnis = 0;
    foreach ($werte as $wert) {
        $ergebnis += $wert;
    }
    return $ergebnis;
}

echo summe(1, 2, 3); // 6
echo summe(5, 10);   // 15

Hier nimmt summe beliebig viele Werte entgegen und fasst sie zu einem Array $werte zusammen.

7. Scope (Gültigkeitsbereich) von Variablen

Variablen, die du innerhalb einer Funktion definierst, gelten nur in dieser Funktion.
Sie sind „lokale“ Variablen. Um auf globale Variablen zuzugreifen, musst du global $variable nutzen
oder besser Parameter übergeben.

$name = "Lisa";

function test() {
    // echo $name; // Fehler, da $name nicht definiert ist in diesem Scope
}

function testGlobal() {
    global $name;
    echo $name; // Jetzt zugreifbar
}

Am besten übergibst du Werte als Parameter, damit dein Code modular bleibt und keine Nebenwirkungen hat.

Fazit

Mit selbst definierten Funktionen in PHP kannst du deinen Code aufteilen,
wiederverwendbar machen und viel Zeit sparen.
Ob du kleine Helfer-Funktionen (z. B. addiere, checkAlter) oder komplexe Routinen schreibst,
Funktionen steigern die Lesbarkeit und Wartbarkeit deines Projekts.
Indem du Parameter, Rückgabewerte und ggf. Typdeklarationen nutzt,
wird dein Code sauber strukturiert und leicht erweiterbar.
Probier unterschiedliche Varianten (Default-Parameter, variadische Funktionen) aus,
um ein Gespür für die Flexibilität von PHP-Funktionen zu bekommen!