PHP Parameter und Rückgabewerte

Inhaltsverzeichnis

PHP Parameter und Rückgabewerte

Beim Schreiben von Funktionen in PHP geht es nicht nur darum,
einen wiederverwendbaren Codeblock zu definieren. Wirklich spannend werden Funktionen,
wenn sie Parameter (Input) entgegennehmen und Rückgabewerte liefern können.
Dieses Tutorial zeigt dir, wie du in PHP Funktionen parametrisierst und
durch return ein Ergebnis zurückgibst.

1. Parameter übergeben

Parameter (oder Argumente beim Aufruf) ermöglichen es, dass deine Funktion
mit verschiedenen Eingabewerten arbeiten kann, ohne den Code selbst anpassen zu müssen.

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

begruessen("Max");  // Gibt "Hallo, Max!" aus
begruessen("Lisa"); // Gibt "Hallo, Lisa!" aus

$name ist ein Parameter, der beim Funktionsaufruf mit einem Wert belegt wird.
In obigem Beispiel wird „Max“ oder „Lisa“ an $name gebunden.

Mehrere Parameter

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

addieren(5, 7); // 12
addieren(2, 10); // 12

Trenne Parameter durch Kommas. Innerhalb der Funktion kannst du sie wie normale Variablen nutzen.

2. Standardwerte (Default-Parameter)

Manchmal möchtest du einen Parameter optional machen oder ihm einen
Standardwert geben, falls beim Funktionsaufruf kein Argument übergeben wird.

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

// Aufruf ohne Argument
begruessen();        // "Willkommen, Gast!"
// Aufruf mit Argument
begruessen("Anna");  // "Willkommen, Anna!"

In diesem Fall wird „Gast“ verwendet, wenn kein Argument im Aufruf spezifiziert ist.

3. Rückgabewerte

In PHP kannst du mit return einen Wert aus einer Funktion zurückgeben.
Das ist nützlich, wenn du das Ergebnis einer Berechnung oder Verarbeitung weiterverwenden möchtest,
anstatt es nur auszugeben.

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

$ergebnis = multiplizieren(4, 5); // Funktionsaufruf liefert 20
echo "4 * 5 = $ergebnis"; // 4 * 5 = 20

return beendet die Funktion sofort. Code nach return wird nicht ausgeführt.
Du kannst auch direkt return $a * $b; schreiben, ohne Zwischenspeicherung in $produkt.

Mehrere Return-Pfade

function bewertePunktzahl($punkte) {
    if ($punkte >= 90) {
        return "Sehr gut";
    } elseif ($punkte >= 75) {
        return "Gut";
    } else {
        return "Ausreichend oder schlechter";
    }
}

echo bewertePunktzahl(92);  // Sehr gut
echo bewertePunktzahl(80);  // Gut
echo bewertePunktzahl(65);  // Ausreichend oder schlechter

Hier entscheidet die if-else-Logik, welcher Rückgabewert geliefert wird.

4. Typdeklaration für Parameter & Rückgabewerte

Seit PHP 7 kannst du den Datentyp der Parameter und des Rückgabewerts festlegen.
Das erhöht die Zuverlässigkeit, indem falsche Typen früh erkannt werden.

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

echo addiere(3, 7);   // 10

```
int $a
```
und
```
int $b
```
bedeutet, dass a und b
idealerweise Integer sein sollen.
```
:
```
```
int
```
nach dem Funktionskopf bedeutet, dass die Funktion
ebenfalls einen Integer zurückgibt.

Ohne declare(strict_types=1) versucht PHP ggf. automatisch zu konvertieren.
Mit strict types wird hingegen bei falschen Datentypen ein Fehler geworfen.

5. Variadische Funktionen (beliebig viele Parameter)

Wenn du nicht genau weißt, wie viele Argumente übergeben werden, kannst du den „Splat-Operator“
… nutzen. Die Parameter werden dann als Array zusammengefasst:

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

echo summe(1, 2, 3); // 6
echo summe(4, 5);    // 9

6. Praktisches Beispiel

Nehmen wir an, wir wollen eine Funktion zur Berechnung des Durchschnitts anbieten:

function durchschnitt(...$werte) {
    if (count($werte) === 0) {
        return 0; // Keine Werte => Durchschnitt 0 (oder du gibst null zurück)
    }
    $summe = 0;
    foreach ($werte as $wert) {
        $summe += $wert;
    }
    return $summe / count($werte);
}

echo durchschnitt(10, 20, 30); // 20
echo durchschnitt();           // 0

So haben wir eine flexible Funktion, die mit beliebig vielen Zahlen umgehen kann.

7. Best Practices

Kurz und prägnant: Vergib Funktionen einen beschreibenden Namen,
der ihr Verhalten klarmacht (z. B. berechneSteuer anstelle von calcSt).
Beschränke Anzahl der Parameter: Zu viele Parameter deuten auf
zu komplexe Logik. Überlege, ob du stattdessen ein Array oder ein Objekt übergibst.
Rückgabewerte dokumentieren: Erkläre (zum Beispiel in Kommentaren),
was genau deine Funktion zurückgibt (Typ, Bedeutung bei Fehlern etc.).

Fazit

Durch Parameter machst du deine PHP-Funktionen flexibel,
und über Rückgabewerte (mittels return) stellst du
das Ergebnis einer Operation dem restlichen Code zur Verfügung.
Ob du einzelne Variablen, Standardwerte oder gar eine unbegrenzte Anzahl von Argumenten
an deine Funktionen übergibst, hängt vom Anwendungsfall ab.
Mit einer durchdachten Parametrisierung und Nutzung von return
erhältst du wiederverwendbare Bausteine, die deinen Code strukturierter und
leichter wartbar machen.