Hvordan definerer du funksjoner med typer og standardverdier?

Question

Accepted Answer

PHP-funksjoner er definert med `function`-nøkkelordet. Moderne PHP støtter **type-deklarasjoner** på parametere og returverdier, **standardverdier** og variadiske parametere — noe som gjør funksjoner mer robust og selvforklarende.

## Grunnleggende funksjoner med type-deklarasjoner

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

Type-deklarasjoner (`int $a`, `: int` returtype) lar PHP sjekke argument- og returtyper — det fanger opp feil og dokumenterer intensjon. Standardverdier gjør parametere 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` tillater null; **union-typer** (`int|string`, PHP 8) tillater flere typer — noe som gjør signaturer nøyaktige.

## Variadiske og navngitte 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 (anbefalt)

```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)` gjør type-deklarasjoner strenge — PHP avviser ikke-samsvarende typer i stedet for å tvinge dem stille, noe som er anbefalt moderne praksis for å fange opp feil.

## Hvorfor det er viktig

Å forstå moderne PHP-funksjonsdefinisjoner — spesielt **type-deklarasjoner** — er viktig for å skrive robust, vedlikehold code, og reflekterer hvor langt PHP har utviklet seg fra sine løst-typet opprinnelser.

Typede parametere og returverdier (pluss nullable og union-typer) gjør funksjoner selvforklarende og lar PHP fange opp typefeil, mens standard- og navngitte argumenter og variadics gir fleksible, lesbare signaturer.

Den viktigste moderne praksisen er **`declare(strict_types=1)`**, som håndhever streng typesjekking (avviser uovereensstemmelser i stedet for å tvinge dem stille) — et nøkkelverktøy for å fange opp feil tidlig og skrive pålitelig kode.

Å vite hvordan du definerer velltypede funksjoner med standardverdier, og bruker strenge typer, er hverdagskunnskap for profesjonell moderne PHP-utvikling, som skiller solid, type-sikker kode fra det løst-typet stilen av eldre PHP.