Hvordan definerer du funktioner med typer og standardværdier?

Question

Accepted Answer

PHP-funktioner defineres med nøgleordet `function`. Moderne PHP understøtter **typedeklarationer** på parametre og returværdier, **standardværdier**, og variadiske parametre — hvilket gør funktioner mere robuste og selvdokumenterende.

## Grundlæggende funktioner med typedeklarationer

```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"
```

Typedeklarationer (`int $a`, `: int` returtype) får PHP til at kontrollere argument- og returtyper — hvilket fanger fejl og dokumenterer hensigten. Standardværdier gør parametre valgfrie.

## Nullable-typer og union-typer (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` tillader null; **union-typer** (`int|string`, PHP 8) tillader flere typer — hvilket gør signaturer præcise.

## Variadiske og navngivne argumenter

```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");
```

## Strenge typer (anbefalet)

```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)` gør typedeklarationer strenge — PHP afviser ikke-matchende typer i stedet for stiltiende at tvinge dem, hvilket er den anbefalede moderne praksis for at fange fejl.

## Hvorfor det betyder noget

At forstå moderne PHP-funktionsdefinitioner — især **typedeklarationer** — er vigtig for at skrive robust, vedligeholdelsesvenlig kode, og afspejler hvor langt PHP er udviklet fra sine løst typede oprindelser.

Typede parametre og returværdier (plus nullable og union-typer) gør funktioner selvdokumenterende og lader PHP fange typefejl, mens standard- og navngivne argumenter og variadiske parametre giver fleksible, læsbare signaturer.

Den vigtigste moderne praksis er **`declare(strict_types=1)`**, som håndhæver streng typekontrol (afviser uoverensstemmelser i stedet for stiltiende at tvinge dem) — et nøgleværktøj til at fange fejl tidligt og skrive pålidelig kode.

At vide, hvordan man definerer veltyede funktioner med standardværdier, og bruger strenge typer, er daglig viden for professionel moderne PHP-udvikling, hvilket skelner solid, typesikker kode fra den løst typede stil fra ældre PHP.