Como você define funções com tipos e valores padrão?

Question

Accepted Answer

As funções PHP são definidas com a palavra-chave `function`. O PHP moderno suporta **declarações de tipo** em parâmetros e valores de retorno, **valores padrão** e parâmetros variádicos — tornando as funções mais robustas e autodocumentadas.

## Funções básicas com declarações de 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"
```

As declarações de tipo (`int $a`, `: int` tipo de retorno) fazem o PHP verificar tipos de argumentos e retorno — capturando bugs e documentando intenção. Valores padrão tornam os parâmetros opcionais.

## Tipos anuláveis e tipos 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 nulo; **tipos union** (`int|string`, PHP 8) permitem vários tipos — tornando as assinaturas precisas.

## Argumentos variádicos e nomeados

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

## Por que isso importa

```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)` torna as declarações de tipo rigorosas — o PHP rejeita tipos incompatíveis em vez de convertê-los silenciosamente, que é a prática moderna recomendada para capturar bugs.

## Por que isso importa

Compreender definições modernas de funções PHP — especialmente **declarações de tipo** — é importante para escrever código robusto e mantível, e reflete o quanto o PHP evoluiu de suas origens fracamente tipadas.

Parâmetros tipados e valores de retorno (além de tipos anuláveis e tipos union) tornam as funções autodocumentadas e permitem que o PHP capture erros de tipo, enquanto argumentos padrão e nomeados e variádicos fornecem assinaturas flexíveis e legíveis.

A prática moderna mais importante é **`declare(strict_types=1)`**, que impõe verificação de tipo rigorosa (rejeita incompatibilidades em vez de convertê-las silenciosamente) — uma ferramenta-chave para capturar bugs cedo e escrever código confiável.

Saber como definir funções bem tipadas com padrões e usar tipos rigorosos é conhecimento cotidiano para desenvolvimento PHP moderno profissional, distinguindo código sólido e type-safe do estilo fracamente tipado do PHP mais antigo.