Cum definiți funcții cu tipuri și valori implicite?

Question

Accepted Answer

Funcțiile PHP sunt definite cu cuvântul cheie `function`. PHP modern suportă **declarații de tip** pe parametri și valori de returnare, **valori implicite** și parametri variadici — făcând funcțiile mai robuste și auto-documentate.

## Funcții de bază cu declarații de tip

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

Declarațiile de tip (`int $a`, `: int` tip de returnare) permit PHP-ului să verifice tipurile argumentelor și returnării — capturând bug-uri și documentând intenția. Valorile implicite fac parametrii opționali.

## Tipuri anulabile și tipuri 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` permite null; **tipurile union** (`int|string`, PHP 8) permit mai multe tipuri — făcând semnăturile precise.

## Argumentele variadice și numite

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

## Tipuri stricte (recomandat)

```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)` face declarațiile de tip stricte — PHP respinge tipurile nepotrivite în loc să le forțeze în tăcere, care este practica modernă recomandată pentru capturarea bug-urilor.

## De ce este important

Înțelegerea definițiilor moderne de funcții PHP — în special **declarații de tip** — este importantă pentru scrierea de cod robust și ușor de menținut, și reflectă cât de mult PHP a evoluat de la originile sale slab tipate.

Parametrii tipați și valorile de returnare (plus tipurile anulabile și tipurile union) fac funcțiile auto-documentate și permit PHP-ului să captureze erori de tip, în timp ce argumentele implicite și numite și variadics oferă semnături flexibile și lizibile.

Cea mai importantă practică modernă este **`declare(strict_types=1)`**, care impune verificarea tipului strict (respinge nepotrivirile în loc să le forțeze în tăcere) — un instrument-cheie pentru capturarea bug-urilor devreme și scrierea de cod fiabil.

Cunoscând cum să definiți funcții bine tipate cu implicit și să utilizați tipuri stricte, este cunoaștere zilnică pentru dezvoltarea modernă profesională a PHP, distingând codul solid și type-safe de stilul slab tipat al PHP-ului mai vechi.