Jak definiujesz funkcje z typami i wartościami domyślnymi?

Question

Accepted Answer

Funkcje PHP są definiowane za pomocą słowa kluczowego `function`. Nowoczesny PHP obsługuje **deklaracje typów** na parametrach i wartościach zwracanych, **wartości domyślne** i parametry wariadyczne — co sprawia, że funkcje są bardziej niezawodne i samo-dokumentujące się.

## Podstawowe funkcje z deklaracjami typów

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

Deklaracje typów (`int $a`, `: int` typ zwracany) pozwalają PHP sprawdzić typy argumentów i zwracane — łapią błędy i dokumentują intencję. Wartości domyślne czynią parametry opcjonalnymi.

## Typy nullable i 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` pozwala na null; **union types** (`int|string`, PHP 8) pozwalają na kilka typów — co sprawia, że sygnatury są precyzyjne.

## Argumenty wariadyczne i nazwane

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

## Dlaczego to ważne

```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)` sprawia, że deklaracje typów są ścisłe — PHP odrzuca niedopasowane typy zamiast je po cichu konwertować, co jest zalecaną nowoczesną praktyką łapania błędów.

## Dlaczego to ważne

Zrozumienie nowoczesnych definicji funkcji PHP — szczególnie **deklaracji typów** — jest ważne dla pisania niezawodnego, łatwego w utrzymaniu kodu i odzwierciedla, jak daleko PHP ewoluował od swoich słabo typowanych początków.

Typowane parametry i wartości zwracane (plus typy nullable i union types) czynią funkcje samo-dokumentującymi się i pozwalają PHP łapać błędy typów, podczas gdy argumenty domyślne i nazwane oraz wariadyki zapewniają elastyczne, czytelne sygnatury.

Najważniejszą nowoczesną praktyką jest **`declare(strict_types=1)`**, która wymusza ścisłe sprawdzanie typów (odrzucanie niedopasowań zamiast ich cichej konwersji) — kluczowe narzędzie do wczesnego łapania błędów i pisania niezawodnego kodu.

Wiedzieć, jak definiować dobrze wpisane funkcje z wartościami domyślnymi i używać ścisłych typów, to codzienna wiedza dla profesjonalnego nowoczesnego razvoju PHP, rozróżniająca solidny kod bezpieczny typowo od słabo typowanego stylu starszego PHP.