EnglishEnglish العربيةالعربية PortuguêsPortuguês Japanese日本語

Funções avançadas

Você já domina os conceitos básicos das funções. Esta lição permite que você escreva funções mais flexíveis, mais modernas e mais no estilo do PHP 8 — parâmetros variádicos, argumentos nomeados, funções-seta —, tudo fruto da evolução contínua do PHP.

1. Parâmetros variáveis (...$args)

Não sabe quantos argumentos serão passados? Use ... para capturá-los todos em um array:

PHP 
<?php
function sum(...$numbers): int {
    return array_sum($numbers);
}

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

// You can also have fixed parameters before the variadic ones
function sendMessage(string $to, string ...$messages): void {
    foreach ($messages as $msg) {
        echo "Sent to {$to}: {$msg}<br>";
    }
}

sendMessage("John", "Good morning", "How's lunch?", "Good night");
// Sent to John: Good morning
// Sent to John: How's lunch?
// Sent to John: Good night
?>

▶ Exemplo: ... para distribuir um array entre os argumentos

PHP 
<?php
function add(int $a, int $b, int $c): int {
    return $a + $b + $c;
}

$nums = [1, 2, 3];
echo add(...$nums);  // 6 (the array is spread into 3 separate arguments)

// Commonly used with array_push and similar functions
$stack = ["a", "b"];
array_push($stack, ...["c", "d", "e"]);
print_r($stack);  // ["a", "b", "c", "d", "e"]
?>
▶ Experimente

... funciona nos dois sentidos — na definição de uma função, ele agrupa os argumentos em um array; no local da chamada, ele distribui um array entre os argumentos.

2. Argumentos nomeados (PHP 8.0)

Não é preciso memorizar a ordem dos parâmetros — passe os argumentos por nome:

▶ Exemplo: Argumentos nomeados

PHP 
<?php
function createUser(
    string $name,
    int $age,
    string $email = "",
    bool $isAdmin = false
): array {
    return compact('name', 'age', 'email', 'isAdmin');
}

// Traditional: must follow parameter order
$u1 = createUser("John", 25, "john@example.com", true);

// Named arguments: order doesn't matter — skip parameters with defaults
$u2 = createUser(
    name: "Jane",
    age: 22,
    isAdmin: true
    // email uses the default
);

// When a function has many parameters, named arguments dramatically improve readability
setcookie(
    name: "theme",
    value: "dark",
    expires_or_options: time() + 3600,
    httponly: true
);
?>
▶ Experimente
💡 Dica: Os argumentos nomeados são especialmente úteis quando: (1) uma função tem muitos parâmetros, a maioria com valores padrão; (2) você deseja passar apenas os últimos argumentos; (3) você deseja um código autodocumentado — createUser(name: "John", age: 25) fica claro na hora.

3. Passagem por referência (&$var)

Por padrão, o PHP passa os argumentos das funções por valor — modificar um parâmetro dentro da função não afeta a variável externa. Adicione & para passar por referência:

PHP 
<?php
// Pass by value (default): internal modification doesn't affect the outside
function addTen(int $n): void {
    $n += 10;
}
$x = 5;
addTen($x);
echo $x;  // 5 (unchanged)

// Pass by reference: internal modification directly affects the outer variable
function addTenRef(int &$n): void {
    $n += 10;
}
addTenRef($x);
echo $x;  // 15 (changed!)
?>
Passagem por valor Passagem por referência
Sintaxe function f($x) function f(&$x)
Modificação interna Não afeta a variável externa Afeta a variável externa
Ideal para A maioria das situações Quando você precisa “retornar” vários valores
⚠️ Atenção: A passagem por referência torna o comportamento da função “opaco” — quem chama a função não sabe que sua variável foi alterada. Usar um valor de retorno costuma ser mais claro. Use referências apenas quando for necessário modificar o array original in loco (por exemplo, sort(&$arr)).

4. Âmbito das variáveis

No PHP, o interior de uma função e o exterior são dois mundos distintos:

PHP 
<?php
$globalVar = "I'm outside";

function test(): void {
    // echo $globalVar;  // Warning: Undefined variable
    // Functions can't directly access outer variables

    $localVar = "I'm inside";
    echo $localVar;  // OK
}

test();
// echo $localVar;  // Warning: can't access the function's inner variable either
?>

(1) Usando o “global” para romper a barreira

PHP 
<?php
$counter = 0;

function increment(): void {
    global $counter;  // Declare: I want to use the global variable
    $counter++;
}

increment();
increment();
echo $counter;  // 2
?>

(2) A matriz superglobal $GLOBALS

PHP 
<?php
$name = "John";

function showName(): void {
    echo $GLOBALS['name'];  // John
}
showName();
?>
💡 Dica: A palavra-chave global é um mal necessário — saiba que ela existe, mas evite usá-la sempre que possível. Variáveis globais dificultam o teste e a manutenção do código. Na maioria das vezes, passe os dados para as funções como parâmetros.

5. Variáveis estáticas

Uma variável static dentro de uma função mantém seu valor entre as chamadas:

PHP 
<?php
function getNextId(): int {
    static $id = 0;
    $id++;
    return $id;
}

echo getNextId();  // 1
echo getNextId();  // 2
echo getNextId();  // 3

// A static variable is only initialized once — on the first call
// Subsequent calls preserve the previous value
?>
💡 Dica: As variáveis estáticas são úteis para armazenar em cache resultados calculados (evitando o recálculo) ou para gerar IDs exclusivos. Mas não as utilize como substituto das propriedades de classe — é para isso que serve a programação orientada a objetos.

6. Funções anônimas (closures)

As funções não precisam de nomes — elas podem ser atribuídas a variáveis e passadas como argumentos:

PHP 
<?php
// Anonymous function assigned to a variable
$greet = function(string $name): string {
    return "Hello, {$name}!";
};

echo $greet("John");  // Hello, John!

// Passed as an argument to another function (callback)
$numbers = [1, 2, 3, 4, 5];
$doubled = array_map(function($n) {
    return $n * 2;
}, $numbers);
print_r($doubled);  // [2, 4, 6, 8, 10]
?>

(1) A palavra-chave use para funções anônimas

Se uma função anônima precisar de uma variável externa, é necessário importá-la com use:

PHP 
<?php
$prefix = "User";

// ❌ Wrong: $prefix is not visible inside the anonymous function
// $greet = function($name) {
//     return "{$prefix}: {$name}";
// };

// ✅ Correct: import the outer variable with use
$greet = function($name) use ($prefix): string {
    return "{$prefix}: {$name}";
};

echo $greet("John");  // User: John

// Import by reference (allows modifying the outer variable)
$count = 0;
$inc = function() use (&$count): void {
    $count++;
};
$inc(); $inc();
echo $count;  // 2
?>

7. Funções-seta (PHP 7.4+)

As funções-seta fn() => são a versão ultraconcisa das funções anônimas de expressão única. Elas capturam automaticamente as variáveis externas (sem necessidade de use):

PHP 
<?php
$factor = 3;

// Anonymous function syntax
$anon = function($n) use ($factor) {
    return $n * $factor;
};

// Arrow function syntax (automatically captures $factor)
$arrow = fn($n) => $n * $factor;

echo $anon(5);   // 15
echo $arrow(5);  // 15

// The golden pair with array_map
$nums = [1, 2, 3, 4, 5];
$tripled = array_map(fn($n) => $n * $factor, $nums);
print_r($tripled);  // [3, 6, 9, 12, 15]
?>
💡 Dica: As funções-seta só podem conter uma única expressão (sem lógica em várias linhas). Elas capturam automaticamente as variáveis externas por valor. São perfeitas para callbacks simples map / filter / usort.

8. Callbacks e o tipo callable

O PHP permite usar nomes de funções como strings, funções anônimas e métodos de objetos como callbacks:

PHP 
<?php
// Method 1: function name as a string
function double(int $n): int {
    return $n * 2;
}
$result = array_map('double', [1, 2, 3]);
// 'double' (with quotes) — the function name string is passed to array_map

// Method 2: anonymous function
$result = array_map(fn($n) => $n * 3, [1, 2, 3]);

// Method 3: callable type declaration
function apply(callable $fn, array $data): array {
    return array_map($fn, $data);
}

$result = apply('double', [1, 2, 3]);          // ✅
$result = apply(fn($n) => $n * 2, [1, 2, 3]);  // ✅
// apply(123, [1, 2, 3]);  // TypeError!
?>

❓ Perguntas Frequentes

P: Quantos significados ... tem em PHP? R: Dois. (1) Na definição de uma função, ...$args agrupa os argumentos restantes em um array. (2) Na chamada de uma função, ...$arr divide um array em argumentos individuais. sum(...$nums) é a expansão; function sum(...$nums) é o agrupamento.

P: Os argumentos nomeados alteram a ordem dos argumentos? Posso misturar argumentos posicionais e nomeados? R: Você pode misturá-los. A regra é: os argumentos nomeados devem vir depois dos posicionais. foo(1, c: 3, b: 2) é válido; foo(a: 1, 2, 3) não é.

P: Quando devo usar funções anônimas e quando devo usar funções-seta? R: Use funções-seta fn($x) => $x * 2 para expressões únicas. Use funções anônimas function($x) { ... } para lógica com várias linhas. As funções-seta são mais concisas e capturam automaticamente as variáveis externas (não é necessário use).

📖 Resumo

📝 Exercícios

  1. Escreva uma função average(...$numbers): float que receba qualquer número de argumentos numéricos e retorne a média deles.
  2. Use array_map e uma função de seta para converter todas as strings de um array para maiúsculas.
  3. Use uma variável estática para escrever uma função hitCounter() que retorne uma contagem de visitas que aumenta a cada chamada.
Web-Tutorial.com

Equipe Técnica Web-Tutorial

Uma plataforma de tutoriais mantida por diversos desenvolvedores. Cada tutorial é escrito e revisado por profissionais da área correspondente. Trabalhamos para manter nosso conteúdo preciso e confiável — se encontrar algum problema, avise-nos.

100%