Kako definirate funkcije s tipi in privzetimi vrednostmi?

Question

Accepted Answer

PHP funkcije se definirajo s ključno besedo `function`. Sodoben PHP podpira **type declarations** na parametrih in povratnih vrednostih, **privzete vrednosti** in variadične parametre — kar funkcije naredi bolj robustne in samodokumentirajuće.

## Osnovne funkcije s type declarations

```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 declarations (`int $a`, `: int` povratni tip) omogočajo PHP-u, da preveri vrste argumentov in povratnih vrednosti — kar preiskovati napake in dokumentirati namen. Privzete vrednosti naredijo parametre opcijske.

## Nullable tipi in union tipi (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` dovoli null; **union tipi** (`int|string`, PHP 8) dovoljujejo več tipov — kar podpise naredi natančnejše.

## Variadični in poimenovani 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 tipi (priporoč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)` naredi type declarations stroge — PHP zavrne neusklajenega vrste namesto tega, da bi jih tiho prisiljal, kar je priporočena sodobna praksa za odkrivanje napak.

## Zakaj je to pomembno

Razumevanje sodobnih PHP definicij funkcij — zlasti **type declarations** — je pomembno za pisanje robustne, vzdrževane kode in odraža, kako daleč se je PHP razvil od svojih ohlapno tipiziranih izvorov.

Typizirani parametri in povratne vrednosti (plus nullable in union tipi) naredijo funkcije samodokumentirajuće in omogočajo PHP-u, da preiskovati napake v tipih, medtem ko privzete in poimenovane vrednosti ter variadični parametri zagotavljajo fleksibilne, berljive podpise.

Najpomembnejša sodobna praksa je **`declare(strict_types=1)`**, ki uveljavlja strogo preverjanje tipov (zavrnitev neusklajenosti namesto tihe prisile) — ključno orodje za zgodnje odkrivanje napak in pisanje zanesljive kode.

Znanje, kako definirati dobro tipizirane funkcije s privzetimi vrednostmi in uporaba strogih tipov, je vsakdanje znanje za profesionalni sodobni PHP razvoj, kar razlikuje trdno, tipsko varno kodo od ohlapno tipizirane slogu starejšega PHP-ja.