Hur definierar du funktioner med typer och standardvärden?

Question

Accepted Answer

PHP-funktioner definieras med nyckelordet `function`. Modern PHP stöder **typdeklarationer** på parametrar och returvärden, **standardvärden**, och variabla parametrar — vilket gör funktioner mer robusta och självidokumenterande.

## Grundläggande funktioner med typdeklarationer

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

Typdeklarationer (`int $a`, `: int` returtyp) gör att PHP kontrollerar argument- och returtyper — vilket fångar buggar och dokumenterar avsikten. Standardvärden gör parametrar valfria.

## Nullbara typer och unionstyper (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` tillåter null; **unionstyper** (`int|string`, PHP 8) tillåter flera typer — vilket gör signaturer exakta.

## Variabla och namngivna argument

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

## Strikta typer (rekommenderat)

```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 typdeklarationer strikta — PHP avvisar felaktig matchade typer istället för att tyst tvångskonvertera dem, vilket är den rekommenderade moderna praktiken för att fånga buggar.

## Varför det är viktigt

Att förstå moderna PHP-funktionsdefinitioner — särskilt **typdeklarationer** — är viktigt för att skriva robust, underhållbar kod, och reflekterar hur långt PHP har utvecklats från sina löst typade ursprung.

Typade parametrar och returvärden (plus nullbara och unionstyper) gör funktioner självidokumenterande och låter PHP fånga typfel, medan standard- och namngivna argument och variadiska parametrar ger flexibla, läsbara signaturer.

Den viktigaste moderna praktiken är **`declare(strict_types=1)`**, vilket tillämpar strikt typkontroll (avvisar felaktig matchade typer istället för att tyst tvångskonvertera dem) — ett nyckelverktyg för att fånga buggar tidigt och skriva tillförlitlig kod.

Att veta hur man definierar vältypad funktioner med standardvärden, och använder strikta typer, är vardagskunskap för professionell modern PHP-utveckling, vilket skiljer solid, typesäker kod från den löst typade stilen i äldre PHP.