Jak definujete funkce s typy a výchozími hodnotami?

Question

Accepted Answer

PHP funkce se definují pomocí klíčového slova `function`. Moderní PHP podporuje **deklarace typů** u parametrů a návratových hodnot, **výchozí hodnoty** a variabilní parametry — což činí funkce robustnějšími a lépe dokumentovanými.

## Základní funkce s deklaracemi typů

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

Deklarace typů (`int $a`, `: int` návratový typ) umožňují PHP kontrolovat typy argumentů a návratových hodnot — objevují chyby a dokumentují záměr. Výchozí hodnoty činí parametry volitelné.

## Nullable typy a union typy (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` umožňuje null; **union typy** (`int|string`, PHP 8) umožňují několik typů — což činí signatury přesnější.

## Variabilní a pojmenované argumenty

```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 (doporučeno)

```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)` činí deklarace typů přisnými — PHP odmítá neodpovídající typy místo jejich tichého převodu, což je doporučená moderní praxe pro odchycení chyb.

## Proč je to důležité

Pochopení moderních PHP definic funkcí — zvláště **deklarací typů** — je důležité pro psaní robustního, udržovatelného kódu a odráží, jak daleko se PHP vyvinulo ze své volně typizované minulosti.

Typizované parametry a návratové hodnoty (plus nullable a union typy) činí funkce samy se dokumentujícími a umožňují PHP odchytit chyby typu, zatímco výchozí a pojmenované argumenty a variadiky poskytují flexibilní, čitelné signatury.

Nejdůležitější moderní praxí je **`declare(strict_types=1)`**, která vynucuje přísnou kontrolu typů (odmítnutí neshod místo jejich tichého převodu) — klíčový nástroj pro včasné odchycení chyb a psaní spolehlivého kódu.

Znalost, jak definovat dobře typizované funkce s výchozími hodnotami a používat strict types, je každodenní znalostí pro profesionální vývoj moderního PHP, rozlišující solidní, type-safe kód od volně typizovaného stylu starších verzí PHP.