Come si definiscono funzioni con tipi e valori predefiniti?

Question

Accepted Answer

Le funzioni PHP sono definite con la parola chiave `function`. PHP moderno supporta **dichiarazioni di tipo** su parametri e valori di ritorno, **valori predefiniti**, e parametri variadici — rendendo le funzioni più robuste e autodocumentanti.

## Funzioni di base con dichiarazioni di tipo

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

Le dichiarazioni di tipo (`int $a`, ritorno `: int`) fanno sì che PHP controlli i tipi degli argomenti e dei ritorni — catturando bug e documentando l'intento. I valori predefiniti rendono i parametri facoltativi.

## Tipi nullable e tipi union (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` consente null; i **tipi union** (`int|string`, PHP 8) consentono più tipi — rendendo le firme precise.

## Argomenti variadici e nominati

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

## Tipi strict (consigliato)

```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)` rende le dichiarazioni di tipo strict — PHP rifiuta i tipi non corrispondenti invece di convertirli silenziosamente, che è la pratica moderna consigliata per catturare i bug.

## Perché è importante

Comprendere le definizioni moderne di funzioni PHP — in particolare le **dichiarazioni di tipo** — è importante per scrivere codice robusto e mantenibile, e riflette quanto PHP si è evoluto dalle sue origini debolmente tipizzate.

I parametri tipizzati e i valori di ritorno (più i tipi nullable e union) rendono le funzioni autodocumentanti e permettono a PHP di catturare errori di tipo, mentre gli argomenti predefiniti e nominati e i variadici forniscono firme flessibili e leggibili.

La pratica moderna più importante è **`declare(strict_types=1)`**, che applica il controllo del tipo strict (rifiutando le mancate corrispondenze piuttosto che convertirle silenziosamente) — uno strumento chiave per catturare i bug presto e scrivere codice affidabile.

Sapere come definire funzioni ben tipizzate con valori predefiniti, e utilizzare tipi strict, è una conoscenza quotidiana per lo sviluppo PHP moderno professionale, distinguendo il codice solido e type-safe dallo stile debolmente tipizzato del PHP più vecchio.