Comment définissez-vous des fonctions avec des types et des valeurs par défaut ?

Question

Accepted Answer

Les fonctions PHP sont définies avec le mot-clé `function`. PHP moderne supporte les **déclarations de type** sur les paramètres et les valeurs de retour, les **valeurs par défaut**, et les paramètres variadiques — rendant les fonctions plus robustes et auto-documentées.

## Fonctions de base avec déclarations de type

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

Les déclarations de type (`int $a`, type de retour `: int`) permettent à PHP de vérifier les types d'arguments et de retour — détectant les bugs et documentant l'intention. Les valeurs par défaut rendent les paramètres optionnels.

## Types nullables et types 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` permet null ; les **types union** (`int|string`, PHP 8) permettent plusieurs types — rendant les signatures précises.

## Arguments variadiques et nommés

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

## Types stricts (recommandé)

```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)` rend les déclarations de type strictes — PHP rejette les types non correspondants au lieu de les convertir silencieusement, ce qui est la pratique moderne recommandée pour déterminer les bugs.

## Pourquoi c'est important

Comprendre les définitions modernes de fonctions PHP — en particulier les **déclarations de type** — est important pour écrire du code robuste et maintenable, et reflète combien PHP a évolué à partir de ses origines faiblement typées.

Les paramètres et valeurs de retour typés (plus les types nullables et union) rendent les fonctions auto-documentées et permettent à PHP de détecter les erreurs de type, tandis que les arguments par défaut et nommés et les variadiques fournissent des signatures flexibles et lisibles.

La pratique moderne la plus importante est **`declare(strict_types=1)`**, qui applique une vérification de type stricte (rejetant les non-correspondances plutôt que de les convertir silencieusement) — un outil clé pour détecter les bugs tôt et écrire du code fiable.

Savoir comment définir des fonctions bien typées avec des valeurs par défaut, et utiliser des types stricts, est une connaissance quotidienne pour le développement PHP moderne professionnel, distinguant un code solide et type-safe du style faiblement typé du PHP plus ancien.