¿Cómo defines funciones con tipos y valores por defecto?

Question

Accepted Answer

Las funciones en PHP se definen con la palabra clave `function`. PHP moderno soporta **declaraciones de tipos** en parámetros y valores de retorno, **valores por defecto**, y parámetros variádicos — haciendo las funciones más robustas y autodocumentadas.

## Funciones básicas con declaraciones de tipos

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

Las declaraciones de tipos (`int $a`, `: int` tipo de retorno) hacen que PHP verifique los tipos de argumentos y retorno — detectando errores y documentando la intención. Los valores por defecto hacen que los parámetros sean opcionales.

## Tipos anulables y tipos unión (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; **tipos unión** (`int|string`, PHP 8) permiten varios tipos — haciendo las firmas más precisas.

## Argumentos variádicos y nombrados

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

## Tipos estrictos (recomendado)

```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)` hace que las declaraciones de tipos sean estrictas — PHP rechaza tipos que no coincidan en lugar de coercionarlos silenciosamente, que es la práctica moderna recomendada para detectar errores.

## Por qué es importante

Comprender las definiciones modernas de funciones en PHP — especialmente **declaraciones de tipos** — es importante para escribir código robusto y mantenible, y refleja cuánto ha evolucionado PHP desde sus orígenes débilmente tipados.

Los parámetros tipados y valores de retorno (más tipos anulables y tipos unión) hacen que las funciones sean autodocumentadas y permiten que PHP detecte errores de tipo, mientras que los argumentos por defecto y nombrados y los parámetros variádicos proporcionan firmas flexibles y legibles.

La práctica moderna más importante es **`declare(strict_types=1)`**, que impone verificación de tipos estricta (rechazando desajustes en lugar de coercionarlos silenciosamente) — una herramienta clave para detectar errores temprano y escribir código confiable.

Saber cómo definir funciones bien tipadas con valores por defecto, y usar tipos estrictos, es conocimiento cotidiano para el desarrollo profesional moderno de PHP, distinguiendo código sólido y type-safe del estilo débilmente tipado del PHP antiguo.