Kako definirate funkcije s tipovima i zadanom vrijednosti?

Question

Accepted Answer

PHP funkcije se definiraju ključnom riječi `function`. Moderni PHP podržava **deklaracije tipova** na parametrima i povratnim vrijednostima, **zadane vrijednosti**, i varijadske parametre — čineći funkcije robusnijima i samoobjašnjavajućima.

## Osnovne funkcije s deklaracijama tipova

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

Deklaracije tipova (`int $a`, `: int` povratni tip) omogućuju PHP-u da provjerava tipove argumenata i povrata — prihvaćajući greške i dokumentirajući namjeru. Zadane vrijednosti čine parametre opcionalne.

## Nullable tipovi i union tipovi (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` dopušta null; **union tipovi** (`int|string`, PHP 8) dopuštaju nekoliko tipova — čineći potpise preciznima.

## Varijadski i naimenovani argumenti

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

## Strogi tipovi (preporuč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)` čini deklaracije tipova strogima — PHP odbija neusklađene tipove umjesto da ih tiho prisili, što je preporučena suvremena praksa za hvatanje grešaka.

## Zašto je to važno

Razumijevanje suvremenih PHP definicija funkcija — posebno **deklaracija tipova** — važno je za pisanje robusnog, održivog koda i odražava koliko je PHP evoluirao iz svojih slabo tipiziranih početaka.

Otipizirani parametri i povratne vrijednosti (plus nullable i union tipovi) čine funkcije samoobjašnjavajućima i omogućuju PHP-u da hvata greške tipova, dok zadane i naimenovane vrijednosti argumenata i varijadski parametri pružaju fleksibilne, čitljive potpise.

Najvažnija suvremena praksa je **`declare(strict_types=1)`**, koja provodi strogost tipova (odbijajući neusklađenosti umjesto tihe prisile) — ključni alat za rani uhvat grešaka i pisanje pouzdanog koda.

Znati kako definirati dobro otkucane funkcije sa zadanim vrijednostima i koristi strogih tipova svakodnevna je znanja za profesionalni suvremeni PHP razvoj, razlikujući čvrst, type-safe kod od slabo otkucanog stila starijeg PHP-a.