Funções: definindo, parâmetros e retorno

Funções são blocos de código reutilizáveis que executam uma tarefa específica. Em PHP, as funções são fundamentais para organizar a lógica do programa, evitar repetição de código e melhorar a manutenibilidade. Este artigo aborda desde a definição básica até conceitos avançados como funções de ordem superior.

1. Definindo funções em PHP

A sintaxe básica para definir uma função utiliza a palavra-chave function, seguida do nome, parênteses para parâmetros e chaves para o corpo:

<?php
function saudacao() {
    return "Olá, mundo!";
}

echo saudacao(); // Saída: Olá, mundo!

Nomeando funções: regras e boas práticas

  • Nomes devem começar com letra ou underscore (_)
  • Seguir o padrão camelCase (ex: calcularTotal)
  • Ser descritivos sobre o que a função faz
  • Evitar nomes muito genéricos como funcao1()

Funções anônimas (closures)

Funções anônimas podem ser atribuídas a variáveis ou passadas como argumentos:

<?php
$saudacao = function($nome) {
    return "Olá, $nome!";
};

echo $saudacao("Maria"); // Saída: Olá, Maria!

2. Parâmetros de funções

Parâmetros obrigatórios

A ordem dos parâmetros importa e todos devem ser fornecidos na chamada:

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

echo soma(5, 3); // 8
// soma(5) geraria erro: argumento faltando

Parâmetros com valor padrão

Valores padrão permitem omitir argumentos na chamada:

<?php
function criarUsuario($nome, $email, $ativo = true) {
    return "Usuário: $nome, Email: $email, Ativo: " . ($ativo ? 'Sim' : 'Não');
}

echo criarUsuario("João", "joao@email.com"); // Ativo: Sim
echo criarUsuario("Ana", "ana@email.com", false); // Ativo: Não

Passagem por valor vs. por referência

Por padrão, PHP passa argumentos por valor (cópia). Use & para passagem por referência:

<?php
function adicionarItem(&$lista, $item) {
    $lista[] = $item;
}

$frutas = ["maçã", "banana"];
adicionarItem($frutas, "laranja");
print_r($frutas); // Array ( [0] => maçã [1] => banana [2] => laranja )

3. Tipos em parâmetros

Declaração de tipos escalares

PHP 7+ permite declarar tipos para parâmetros:

<?php
function calcularDesconto(float $preco, int $percentual): float {
    return $preco - ($preco * $percentual / 100);
}

echo calcularDesconto(150.00, 10); // 135.0
// calcularDesconto("150", 10) geraria TypeError

Tipos compostos

<?php
function processarItens(array $itens, callable $callback): array {
    return array_map($callback, $itens);
}

function filtrarPares(iterable $numeros): array {
    $resultado = [];
    foreach ($numeros as $num) {
        if ($num % 2 == 0) $resultado[] = $num;
    }
    return $resultado;
}

Tipos união (PHP 8.0+) e mixed

<?php
function formatarValor(int|float $valor): string {
    return number_format($valor, 2, ',', '.');
}

function logMensagem(mixed $dado): void {
    error_log(print_r($dado, true));
}

4. Retorno de funções

Declaração de tipo de retorno

<?php
function buscarUsuario(int $id): ?array {
    // Retorna array ou null se não encontrado
    $usuarios = [1 => ['nome' => 'João'], 2 => ['nome' => 'Maria']];
    return $usuarios[$id] ?? null;
}

function logAcao(string $acao): void {
    // Não retorna valor
    echo "[LOG] Ação: $acao\n";
}

Retorno de múltiplos valores com array

<?php
function dividir(int $a, int $b): array {
    $quociente = intdiv($a, $b);
    $resto = $a % $b;
    return [$quociente, $resto];
}

[$q, $r] = dividir(10, 3);
echo "Quociente: $q, Resto: $r"; // Quociente: 3, Resto: 1

Retorno por referência

<?php
class Container {
    private array $dados = [];

    public function &obterReferencia(string $chave): mixed {
        return $this->dados[$chave];
    }
}

$container = new Container();
$ref = &$container->obterReferencia('nome');
$ref = 'Valor modificado'; // Modifica diretamente o array interno

5. Parâmetros variádicos e nomeados

Parâmetros variádicos com ...$args

<?php
function somarTodos(int ...$numeros): int {
    return array_sum($numeros);
}

echo somarTodos(1, 2, 3, 4, 5); // 15

Coleta de argumentos com func_get_args()

<?php
function media() {
    $args = func_get_args();
    if (count($args) === 0) return 0;
    return array_sum($args) / count($args);
}

echo media(8, 9, 10); // 9.0

Named arguments (PHP 8.0+)

Permitem especificar argumentos pelo nome, ignorando ordem:

<?php
function criarPedido($produto, $quantidade = 1, $desconto = 0, $urgente = false) {
    return "Pedido: $produto, Qtd: $quantidade, Desc: $desconto%, Urgente: " . ($urgente ? 'Sim' : 'Não');
}

echo criarPedido(
    produto: "Notebook",
    urgente: true,
    quantidade: 2
);
// Pedido: Notebook, Qtd: 2, Desc: 0%, Urgente: Sim

6. Funções internas e escopo

Escopo de variáveis

Variáveis dentro de funções são locais. Use global para acessar variáveis globais:

<?php
$contador = 0;

function incrementar() {
    global $contador;
    $contador++;
}

incrementar();
echo $contador; // 1

Funções internas do PHP

PHP possui centenas de funções nativas úteis:

<?php
$texto = "Olá, Mundo!";
echo strlen($texto); // 12
echo strtoupper($texto); // "OLÁ, MUNDO!"

$numeros = [3, 1, 4, 1, 5];
array_push($numeros, 9);
sort($numeros);
print_r($numeros); // [1, 1, 3, 4, 5, 9]

Funções recursivas

Funções que chamam a si mesmas, com cuidado para evitar estouro de pilha:

<?php
function fatorial(int $n): int {
    if ($n <= 1) return 1;
    return $n * fatorial($n - 1);
}

echo fatorial(5); // 120

// Cuidado: fatorial(100000) causaria erro de memória

7. Funções de ordem superior

Passando funções como argumento (callbacks)

<?php
function processarArray(array $dados, callable $callback): array {
    $resultado = [];
    foreach ($dados as $item) {
        $resultado[] = $callback($item);
    }
    return $resultado;
}

$numeros = [1, 2, 3, 4, 5];
$dobrados = processarArray($numeros, function($n) {
    return $n * 2;
});
print_r($dobrados); // [2, 4, 6, 8, 10]

Retornando funções

<?php
function criarMultiplicador(int $fator): callable {
    return function($valor) use ($fator) {
        return $valor * $fator;
    };
}

$dobro = criarMultiplicador(2);
echo $dobro(5); // 10

$triplo = criarMultiplicador(3);
echo $triplo(5); // 15

Exemplos com funções nativas de array

<?php
$numeros = [1, 2, 3, 4, 5, 6];

// array_map: aplica função a cada elemento
$quadrados = array_map(fn($n) => $n ** 2, $numeros);
print_r($quadrados); // [1, 4, 9, 16, 25, 36]

// array_filter: filtra elementos
$pares = array_filter($numeros, fn($n) => $n % 2 === 0);
print_r($pares); // [2, 4, 6]

// array_reduce: reduz array a um único valor
$soma = array_reduce($numeros, fn($carry, $item) => $carry + $item, 0);
echo $soma; // 21

Conclusão

Funções são o coração da programação modular em PHP. Dominar desde a definição básica até conceitos avançados como tipos, passagem por referência, parâmetros variádicos e funções de ordem superior permite escrever código mais limpo, reutilizável e eficiente. Com PHP 8.0+, recursos como tipos união e named arguments tornam as funções ainda mais expressivas e seguras.

Referências