Funções são blocos de código reutilizáveis que executam uma tarefa específica. Em PHP, elas são fundamentais para organizar o código, evitar repetição e facilitar a manutenção. Nesta aula, você aprenderá a declarar funções, trabalhar com parâmetros, valores padrão, retorno e tipagem, tanto de parâmetros quanto de valores retornados.

Dominar funções é essencial para escrever código limpo e eficiente. Vamos explorar cada aspecto com exemplos práticos que você pode testar em seu ambiente de desenvolvimento.

Declaração

Em PHP, uma função é declarada com a palavra-chave function, seguida pelo nome da função, parênteses (que podem conter parâmetros) e um bloco de código entre chaves. O nome da função deve ser único e seguir as regras de nomenclatura do PHP (case-insensitive, mas é boa prática usar snake_case).

Funções podem ser definidas em qualquer lugar do script, mas geralmente são colocadas no topo ou em arquivos separados para melhor organização. Elas só são executadas quando chamadas explicitamente.

<?php
// Declaração simples
function saudacao() {
    echo "Olá, mundo!";
}

// Chamada da função
saudacao(); // Imprime: Olá, mundo!
?>

Funções podem ser definidas condicionalmente, mas isso é raro e deve ser evitado por clareza. Também é possível usar funções anônimas (closures) e funções arrow (a partir do PHP 7.4), que veremos em aulas futuras.

Parâmetros e valores padrão

Parâmetros são variáveis que a função recebe para processar. Eles são definidos entre os parênteses da declaração. Ao chamar a função, você passa argumentos que serão atribuídos a esses parâmetros.

Parâmetros podem ter valores padrão, que são usados quando nenhum argumento é passado. Isso torna a função mais flexível. Valores padrão devem ser constantes ou expressões simples, não variáveis ou chamadas de função.

<?php
function cumprimentar($nome, $sobrenome = "Silva") {
    echo "Olá, $nome $sobrenome!";
}

cumprimentar("João"); // Olá, João Silva!
cumprimentar("Maria", "Santos"); // Olá, Maria Santos!
?>

Parâmetros podem ser passados por valor (padrão) ou por referência (usando &). Por valor, a função recebe uma cópia; por referência, a função pode modificar a variável original. Isso é útil para economizar memória ou permitir alterações.

<?php
function incrementar(&$num) {
    $num++;
}

$valor = 5;
incrementar($valor);
echo $valor; // 6
?>

Desde o PHP 8, é possível usar parâmetros nomeados, que permitem passar argumentos em qualquer ordem, especificando o nome do parâmetro. Isso melhora a legibilidade quando há muitos parâmetros.

<?php
function configurar($host, $porta = 3306, $usuario = "root") {
    echo "Host: $host, Porta: $porta, Usuário: $usuario";
}

configurar(usuario: "admin", host: "localhost"); // Host: localhost, Porta: 3306, Usuário: admin
?>

Retorno

Funções podem retornar um valor usando a instrução return. O valor retornado pode ser de qualquer tipo (incluindo arrays, objetos, etc.). Quando o PHP encontra return, a execução da função é encerrada imediatamente e o valor é devolvido ao chamador.

Se uma função não tiver return, ela retorna null. É possível retornar múltiplos valores usando um array ou, a partir do PHP 7.1, com a sintaxe de desestruturação.

<?php
function soma($a, $b) {
    return $a + $b;
}

$resultado = soma(3, 4);
echo $resultado; // 7

function dados() {
    return ["João", 30];
}

list($nome, $idade) = dados();
echo "$nome tem $idade anos";
?>

O tipo de retorno pode ser declarado opcionalmente, o que veremos a seguir. Declarar o retorno ajuda a documentar e garantir que a função produza o tipo esperado.

Tipagem de parâmetros e retorno

O PHP é uma linguagem de tipagem dinâmica, mas desde o PHP 5 você pode declarar tipos para parâmetros e, desde o PHP 7, para retorno. Isso é chamado de tipagem escalar e ajuda a evitar erros, tornando o código mais previsível.

Os tipos suportados incluem: int, float, string, bool, array, object, callable, iterable, e classes específicas. Por padrão, o PHP tenta converter valores para o tipo declarado (modo coercivo). Para exigir tipos exatos, use declare(strict_types=1); no início do arquivo.

<?php
declare(strict_types=1);

function somar(int $a, int $b): int {
    return $a + $b;
}

echo somar(2, 3); // 5
// echo somar(2.5, 3); // Erro em strict_types
echo somar("2", 3); // Erro em strict_types, pois string não é convertida
?>

No modo coercivo (sem strict_types), o PHP converte automaticamente: somar("2", 3) funcionaria, resultando em 5. Tipos podem ser opcionais (nullable) usando ?tipo, o que permite null como valor. Também é possível usar tipos união (PHP 8) como int|string.

<?php
function saudacao(?string $nome): string {
    return "Olá, " . ($nome ?? "visitante") . "!";
}

echo saudacao(null); // Olá, visitante!
echo saudacao("Ana"); // Olá, Ana!

function converter(int|string $valor): string {
    return (string) $valor;
}
?>

Com a tipagem, o IDE pode fornecer autocompletar e detectar erros em tempo de desenvolvimento. É uma boa prática declarar tipos sempre que possível, pois documenta a intenção e previne bugs.

Boas práticas

Ao criar funções, prefira nomes que indiquem claramente o que fazem (verbos no infinitivo). Mantenha funções pequenas e com uma única responsabilidade. Evite efeitos colaterais, como modificar variáveis globais, a menos que necessário. Use parâmetros para entrada e retorno para saída.

Documente suas funções com comentários PHPDoc para descrever parâmetros, retorno e possíveis exceções. Isso ajuda outros desenvolvedores e ferramentas de análise.

/**
 * Calcula a média de um array de números.
 *
 * @param float[] $numeros Lista de números.
 * @return float A média.
 */
function media(array $numeros): float {
    if (empty($numeros)) {
        return 0.0;
    }
    return array_sum($numeros) / count($numeros);
}
?>

Referências

Exercícios

  1. Crie uma função chamada ehPar que recebe um número inteiro e retorna true se for par, false caso contrário. Teste com valores pares e ímpares.

    ✓ Resposta: 
    <?php
function ehPar(int $numero): bool {
    return $numero % 2 === 0;
}

var_dump(ehPar(4)); // bool(true)
var_dump(ehPar(7)); // bool(false)
?>
  2. Escreva uma função saudacaoPersonalizada que aceite um nome e um horário (manhã, tarde, noite) e retorne uma saudação apropriada. Use valores padrão para o horário ("dia"). Teste chamadas com e sem o segundo argumento.

    ✓ Resposta: 
    <?php
function saudacaoPersonalizada(string $nome, string $horario = "dia"): string {
    switch ($horario) {
        case "manhã":
            return "Bom dia, $nome!";
        case "tarde":
            return "Boa tarde, $nome!";
        case "noite":
            return "Boa noite, $nome!";
        default:
            return "Olá, $nome!";
    }
}

echo saudacaoPersonalizada("João"); // Olá, João!
echo saudacaoPersonalizada("Maria", "manhã"); // Bom dia, Maria!
?>
  3. Crie uma função calcular que receba dois números e uma operação ("soma", "subtracao", "multiplicacao", "divisao") e retorne o resultado. Use tipagem e trate divisão por zero (retorne null).

    ✓ Resposta: 
    <?php
function calcular(float $a, float $b, string $operacao): ?float {
    switch ($operacao) {
        case "soma":
            return $a + $b;
        case "subtracao":
            return $a - $b;
        case "multiplicacao":
            return $a * $b;
        case "divisao":
            if ($b == 0) {
                return null;
            }
            return $a / $b;
        default:
            return null;
    }
}

var_dump(calcular(10, 2, "divisao")); // float(5)
var_dump(calcular(10, 0, "divisao")); // NULL
?>
  4. Implemente uma função inverterArray que recebe um array e retorna um novo array com a ordem invertida, sem usar array_reverse. Use um loop for.

    ✓ Resposta: 
    <?php
function inverterArray(array $arr): array {
    $invertido = [];
    $tamanho = count($arr);
    for ($i = $tamanho - 1; $i >= 0; $i--) {
        $invertido[] = $arr[$i];
    }
    return $invertido;
}

print_r(inverterArray([1, 2, 3, 4])); // Array ( [0] => 4 [1] => 3 [2] => 2 [3] => 1 )
?>
  5. Escreva uma função contarVogais que recebe uma string e retorna a quantidade de vogais (a, e, i, o, u), ignorando maiúsculas/minúsculas. Dica: use str_split e in_array.

    ✓ Resposta: 
    <?php
function contarVogais(string $texto): int {
    $vogais = ['a', 'e', 'i', 'o', 'u'];
    $contador = 0;
    $letras = str_split(strtolower($texto));
    foreach ($letras as $letra) {
        if (in_array($letra, $vogais)) {
            $contador++;
        }
    }
    return $contador;
}

echo contarVogais("Olá Mundo"); // 4
?>