Wie definierst du Funktionen mit Typen und Defaults?

Question

Accepted Answer

PHP-Funktionen werden mit dem Schlüsselwort `function` definiert. Modernes PHP unterstützt **Typdeklarationen** für Parameter und Rückgabewerte, **Standardwerte** und variadic Parameter — was Funktionen robuster und selbsterklärend macht.

## Grundlegende Funktionen mit Typdeklarationen

```php
<?php
// modern PHP — typed parameters and a typed return
function add(int $a, int $b): int {
    return $a + $b;
}

function greet(string $name, string $greeting = "Hello"): string {  // default value
    return "$greeting, $name";
}

greet("Ann");              // "Hello, Ann"
greet("Ann", "Hi");        // "Hi, Ann"
```

Typdeklarationen (`int $a`, `: int` Rückgabetyp) lassen PHP Argument- und Rückgabetypen überprüfen — Bugs werden gefunden und die Absicht dokumentiert. Standardwerte machen Parameter optional.

## Nullable Types und Union Types (PHP 8+)

```php
function find(?int $id): ?User {        // ? = nullable (int|null, User|null)
    return $id ? lookup($id) : null;
}

function process(int|string $input): void {   // union type — int OR string (PHP 8)
    // ...
}
```

`?Type` erlaubt null; **Union Types** (`int|string`, PHP 8) erlauben mehrere Typen — Signaturen werden präzise.

## Variadic und Named Arguments

```php
function sum(int ...$numbers): int {     // variadic — any number of int args
    return array_sum($numbers);
}
sum(1, 2, 3);            // 6

// named arguments (PHP 8) — pass by parameter name, skip optional ones
greet(name: "Ann", greeting: "Hey");
```

## Strict Types (empfohlen)

```php
<?php
declare(strict_types=1);    // at the top of the file — enforce STRICT type checking

add("5", 3);   // ❌ TypeError with strict_types (without it, "5" would coerce to 5)
```

`declare(strict_types=1)` macht Typdeklarationen strict — PHP lehnt nicht übereinstimmende Typen ab, anstatt sie stillschweigend zu konvertieren, was die empfohlene moderne Praxis zum Finden von Bugs ist.

## Warum es wichtig ist

Das Verständnis moderner PHP-Funktionsdefinitionen — besonders **Typdeklarationen** — ist wichtig für das Schreiben robuster, wartbarer Code und zeigt, wie weit sich PHP von seinen schwach typisierten Ursprüngen entwickelt hat.

Typisierte Parameter und Rückgabewerte (plus nullable und Union Types) machen Funktionen selbsterklärend und lassen PHP Typfehler finden, während Default- und Named Arguments sowie Variadics flexible, lesbare Signaturen bieten.

Die wichtigste moderne Praxis ist **`declare(strict_types=1)`**, die strikte Typprüfung erzwingt (nicht übereinstimmende Typen ablehnt, anstatt sie stillschweigend zu konvertieren) — ein Schlüsselwerkzeug zum frühen Finden von Bugs und zum Schreiben zuverlässigen Code.

Zu wissen, wie man gut typisierte Funktionen mit Defaults definiert und strikte Typen nutzt, ist Alltagswissen für professionelle moderne PHP-Entwicklung und unterscheidet soliden, typesicheren Code vom schwach typisierten Stil älteren PHPs.