PHP Funktionen: definieren, return, Parameter und Typen

Eine PHP-Funktion wird mit dem Schlüsselwort function, einem Namen, einer Parameterliste und einem Rumpf definiert; return gibt einen Wert an den Aufrufer zurück. function add(int $a, int $b): int { return $a + $b; } definiert sie, und add(2, 3) ruft sie auf und liefert 5.

<?php
function greet(string $name): string
{
    return "Hello, $name";
}

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

echo greet('Ada'), "\n";
echo add(2, 3), "\n";
echo add(add(1, 2), 10), "\n";

Die string und int vor den Parametern sind Typdeklarationen, und : string nach den Klammern ist der Rückgabetyp. Beides ist optional, fängt aber Fehler früh ab und dokumentiert, was die Funktion erwartet.

Rückgabewerte und mehrere Werte zurückgeben

return beendet die Funktion sofort. Eine Funktion ohne return oder mit einem bloßen return; liefert null; deklariere : void, wenn sie nur wegen ihrer Wirkung aufgerufen wird. Eine Funktion gibt einen Wert zurück, aber dieser Wert kann ein Array sein, das du auf der aufrufenden Seite zerlegst:

<?php
function grade(int $score): string
{
    if ($score >= 90) {
        return 'A';
    }
    return $score >= 75 ? 'B' : 'C';   // reached only below 90
}

function stats(array $numbers): array
{
    return [
        'min' => min($numbers),
        'max' => max($numbers),
        'avg' => array_sum($numbers) / count($numbers),
    ];
}

function logLine(string $msg): void
{
    echo "[log] $msg\n";
}

echo grade(95), grade(80), grade(40), "\n";

['min' => $min, 'max' => $max, 'avg' => $avg] = stats([4, 8, 15, 16, 23, 42]);
echo "min $min, max $max, average $avg\n";

[$quotient, $remainder] = [intdiv(17, 5), 17 % 5];
echo "17 / 5 = $quotient remainder $remainder\n";

var_dump(logLine('saved'));   // a void function returns null

Die anderen Formen von [...] = stehen unter Array-Destructuring.

Standardparameter und benannte Argumente

Ein Parameter mit = value ist optional: Aufrufer können ihn weglassen. Optionale Parameter stehen nach den Pflichtparametern. Seit PHP 8.0 kann der Aufrufer mit benannten Argumenten jeden Parameter über seinen Namen übergeben und so die optionalen überspringen, die er nicht braucht.

<?php
function makeTag(string $text, string $tag = 'p', ?string $class = null, bool $escape = true): string
{
    $body = $escape ? htmlspecialchars($text) : $text;
    $attr = $class !== null ? " class=\"$class\"" : '';
    return "<$tag$attr>$body</$tag>";
}

echo makeTag('Hello'), "\n";
echo makeTag('Title', 'h1'), "\n";

// Named arguments: skip $tag and $class, set only $escape
echo makeTag('<b>bold</b>', escape: false), "\n";
echo makeTag(class: 'note', text: 'Order does not matter'), "\n";

Benannte Argumente machen auch Aufrufe eingebauter Funktionen lesbar: str_pad('7', 3, '0', pad_type: STR_PAD_LEFT). Der Parametername wird Teil der öffentlichen Schnittstelle der Funktion, also kann das Umbenennen eines Parameters Aufrufer kaputtmachen, die Namen verwenden.

Übergabe per Referenz

Normalerweise übergibt PHP eine Kopie jedes Arguments, also kann die Funktion die Variable des Aufrufers nicht ändern. Ein & vor einem Parameter übergibt die Variable selbst. Eingebaute Funktionen wie sort() arbeiten so.

<?php
function addOne(int $n): void
{
    $n++;          // changes the copy only
}

function addOneRef(int &$n): void
{
    $n++;          // changes the caller's variable
}

$a = 5;
addOne($a);
echo $a, "\n";

addOneRef($a);
echo $a, "\n";

function addItem(array &$cart, string $item): void
{
    $cart[] = $item;
}

$cart = [];
addItem($cart, 'apple');
addItem($cart, 'pear');
print_r($cart);

Einen neuen Wert zurückzugeben ist meist klarer, als ein Argument zu ändern. Verwende Referenzen, wenn die Funktion wirklich dafür gedacht ist, etwas direkt zu ändern.

Typdeklarationen und strict_types

Standardmäßig wandelt PHP Argumente in den deklarierten Typ um, wenn es kann: add("5", 3) macht aus "5" den Wert 5. Mit declare(strict_types=1); ganz oben in der Datei schaltest du das für Aufrufe in dieser Datei ab, sodass ein falscher Typ einen TypeError wirft, statt umgewandelt zu werden.

<?php
declare(strict_types=1);
// This throws a TypeError on purpose: "5" is a string, not an int

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

echo add(2, 3), "\n";
echo add("5", 3), "\n";

Ohne die Zeile mit declare gibt derselbe Aufruf 8 aus. Strings, die keine Zahlen sind, wie "five", werfen in beiden Modi einen TypeError.

Die Typen, die du für Parameter und Rückgabewerte deklarieren kannst:

<?php
// ?string: a string or null
function findUser(int $id): ?string
{
    $users = [1 => 'Ada', 2 => 'Linus'];
    return $users[$id] ?? null;
}

// int|float: a union type (PHP 8.0)
function half(int|float $n): float
{
    return $n / 2;
}

// mixed: anything at all
function describe(mixed $value): string
{
    return get_debug_type($value);
}

var_dump(findUser(1), findUser(9));
var_dump(half(5), half(2.5));
echo describe([1, 2]), ' ', describe(null), ' ', describe(1.5), "\n";

never ist ein Rückgabetyp für Funktionen, die immer werfen oder das Skript beenden. Klassen- und Interface-Namen funktionieren ebenfalls als Typen.

Variable Anzahl von Argumenten mit ...$args

...$numbers sammelt beliebig viele Argumente in einem Array. Dasselbe ... auf der aufrufenden Seite verteilt ein Array auf einzelne Argumente.

<?php
function sum(int ...$numbers): int
{
    return array_sum($numbers);
}

echo sum(), "\n";
echo sum(1, 2, 3), "\n";

$values = [10, 20, 30];
echo sum(...$values), "\n";          // spread an array

function logMessage(string $level, string ...$parts): string
{
    return strtoupper($level) . ': ' . implode(' ', $parts);
}

echo logMessage('info', 'user', 'Ada', 'logged in'), "\n";

Eine äußere Variable in einer Funktion verwenden

Eine Funktion hat ihren eigenen Scope. Eine außerhalb definierte Variable ist darin nicht sichtbar, was Umsteiger aus JavaScript überrascht:

<?php
$taxRate = 0.2;

function priceWithTax(float $price): float
{
    return $price * (1 + $taxRate);   // $taxRate is undefined here
}

Warning: Undefined variable $taxRate in /path/to/index.php on line 6

und die Funktion liefert den Preis ohne Steuer. Übergib den Wert stattdessen als Parameter. So bleibt die Funktion ehrlich darüber, wovon sie abhängt, und leicht testbar:

<?php
$taxRate = 0.2;

function priceWithTax(float $price, float $taxRate): float
{
    return $price * (1 + $taxRate);
}

echo priceWithTax(100, $taxRate), "\n";
echo priceWithTax(100, 0.1), "\n";

Das Schlüsselwort global funktioniert auch, versteckt aber die Abhängigkeit; der Scope von Variablen behandelt es. Für kurze Funktionen, die an andere Funktionen übergeben werden, etwa Callbacks für array_map(), siehe anonyme Funktionen, die äußere Variablen mit use einfangen können.