PHP Academy · Aula

Funções anônimas e closures

Escreva funções inline e capture variáveis com use.

Funções anônimas e closures é uma aula grátis de PHP Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de PHP Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de PHP Academy inclui 4 aulas no total.

O que são funções anônimas?

Uma função anônima (lambda) é uma função sem nome. No PHP, ela é uma instância da classe integrada Closure e pode ser armazenada em uma variável, passada como argumento ou retornada por outra função.

Função anônima básica

Atribua uma função a uma variável e chame-a:

<?php
$double = function(int $n): int {
    return $n * 2;
};

echo $double(5);   // 10
echo $double(21);  // 42

Passando funções anônimas

Passe um fechamento como argumento para funções como array_map, usort ou para suas próprias funções de retorno de chamada:

<?php
$nums = [3, 1, 4, 1, 5, 9];

$squared = array_map(function(int $n): int {
    return $n ** 2;
}, $nums);

print_r($squared); // [9, 1, 16, 1, 25, 81]

Retornando funções

Uma função pode criar e retornar um fechamento — este é um padrão de fábrica:

<?php
function makeMultiplier(int $factor): Closure {
    return function(int $n) use ($factor): int {
        return $n * $factor;
    };
}

$triple  = makeMultiplier(3);
$tenX    = makeMultiplier(10);

echo $triple(5);   // 15
echo $tenX(5);     // 50

Fechamentos e use

Os fechamentos podem capturar variáveis do escopo externo com use. A captura é feita por valor (cópia), a menos que você adicione &:

<?php
$taxRate = 0.18;

$addTax = function(float $price) use ($taxRate): float {
    return $price * (1 + $taxRate);
};

$taxRate = 0.20;  // change outer variable
echo $addTax(100); // 118 — captured value at creation time

Captura por referência com use(&)

Para permitir que o fechamento veja valores externos atualizados, capture por referência:

<?php
$count = 0;

$increment = function() use (&$count): void {
    $count++;
};

$increment();
$increment();
echo $count;  // 2

Funções de seta (PHP 7.4)

As funções de seta são fechamentos compactos de uma única expressão que capturam automaticamente o escopo externo por valor:

<?php
$rate = 1.18;
$prices = [10, 20, 30];

// Arrow function — no 'use' needed
$withTax = array_map(fn($p) => $p * $rate, $prices);

print_r($withTax); // [11.8, 23.6, 35.4]

Funções de seta não podem modificar o escopo externo

As funções de seta capturam apenas por valor — elas não podem modificar variáveis externas:

<?php
$total = 0;
$nums  = [1, 2, 3];

// This does NOT modify $total!
array_walk($nums, fn($n) => $total += $n);

echo $total;  // 0

// Use a reference closure for mutation:
array_walk($nums, function($n) use (&$total) { $total += $n; });
echo $total;  // 6

Fechamentos como funções de retorno de chamada

Muitas funções do PHP aceitam algo chamável — você pode passar um fechamento, um array [$obj, 'method'] ou o nome de uma função em uma string:

<?php
$words = ['banana', 'apple', 'cherry'];

usort($words, fn($a, $b) => strcmp($a, $b));

print_r($words); // ['apple', 'banana', 'cherry']

Fechamento invocado imediatamente

Você pode definir e chamar um fechamento na mesma linha — isso é útil para criar um escopo isolado:

<?php
$result = (function(): int {
    $x = 10;
    $y = 20;
    return $x + $y;
})();

echo $result; // 30
// $x and $y are not in outer scope

Closure::bind e bindTo

Você pode reassociar um fechamento ao contexto de outro objeto usando Closure::bind():

<?php
class Counter {
    private int $value = 0;
}

$increment = Closure::bind(function(int $by): void {
    $this->value += $by;
}, new Counter(), Counter::class);

// Now $increment has access to private $value

Verificação rápida

Qual é a principal diferença entre um fechamento comum com use e uma função de seta no PHP?

Recapitulação: funções anônimas e fechamentos

Resumo:

Funções anônimas são armazenadas em variáveis e podem ser passadas de um lugar para outro
Fechamentos capturam variáveis externas com use($var) (por valor) ou use(&$var) (por referência)
As funções de seta (PHP 7.4) capturam automaticamente o escopo externo por valor
São úteis para funções de retorno de chamada: array_map, usort, array_filter…
Podem ser retornadas por funções de fábrica

Perguntas Frequentes

A aula “Funções anônimas e closures” é grátis?

Sim — o texto completo de “Funções anônimas e closures” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de PHP Academy, atualize para CoddyKit PRO. O curso de PHP Academy inclui 4 aulas no total.

O que vou aprender em “Funções anônimas e closures”?

Escreva funções inline e capture variáveis com use. Você pratica PHP Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar PHP Academy?

Nenhuma experiência prévia é necessária. PHP Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Funções anônimas e closures”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de PHP Academy?

Sim. Cada aula de PHP Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para PHP Academy