Entendendo as Funções de Callback em PHP

Um callback (ou "callable") é uma função que você passa para outra função para que seja chamada posteriormente. Os callbacks são a base das funções de ordem superior do PHP — array_map, usort, array_filter e muitos hooks de frameworks esperam que você forneça um callback. Este capítulo explica o que é considerado callable em PHP, as quatro formas de escrever um, e como utilizá-los no dia a dia.

Esta página pressupõe que você já entenda as funções básicas do PHP. Se você é iniciante na definição de funções, leia isso primeiro.

O que são Funções de Callback em PHP?

Uma função de callback em PHP é qualquer função passada como argumento para outra função e então invocada dentro dela. O PHP reconhece um valor como callable em quatro formas:

• Uma string com o nome da função — 'strtoupper' refere-se à função embutida strtoupper().
• Uma função anônima (closure) — function () { ... } atribuída a uma variável ou passada inline.
• Uma arrow function — fn() => ..., uma forma abreviada para closures curtas (PHP 7.4+).
• Uma referência a objeto/método — [$object, 'methodName'] ou ['ClassName', 'staticMethod'].

O type hint para um parâmetro que aceita qualquer uma dessas formas é callable. Você pode invocar o valor diretamente ($callback()) ou com call_user_func() / call_user_func_array() quando precisar encaminhar uma lista dinâmica de argumentos.

Por que Usar Funções de Callback em PHP?

Os callbacks permitem que você escreva uma função uma vez e personalize seu comportamento no ponto de chamada, sem reescrevê-la:

• Reusabilidade. Uma função genérica (por exemplo, "percorrer esta lista e fazer algo em cada item") funciona para qualquer tarefa fornecida como callback.
• Lógica mais limpa. Funções de ordem superior embutidas como array_map e array_filter substituem loops manuais por uma única linha declarativa.
• Desacoplamento. Código orientado a eventos — manipuladores de formulários, processadores de comandos CLI, hooks de frameworks — registra um callback que é executado apenas quando o evento ocorre, mantendo o gatilho e o manipulador separados.

Como Usar Funções de Callback em PHP

Usar funções de callback em PHP é simples. Basta passar o nome da função ou a função anônima como argumento para a função pai. Veja um exemplo de como usar uma função nomeada como callback:

Exemplo PHP de como usar uma função nomeada como callback

No exemplo acima, a myCallbackFunction é passada como argumento para a parentFunction. Quando a parentFunction é executada, ela chama call_user_func e passa a myCallbackFunction como argumento. Como resultado, a myCallbackFunction é executada e exibe a mensagem "The callback function has been executed."

Veja um exemplo de como usar uma função anônima como callback:

Exemplo PHP de como usar uma função anônima como callback

Neste exemplo, a função anônima é atribuída à variável $myCallbackFunction. Essa variável pode então ser passada como argumento para a parentFunction, assim como a função nomeada no exemplo anterior.

A partir do PHP 7.4, você também pode usar a sintaxe concisa de arrow function (fn) para callbacks simples. As arrow functions capturam automaticamente variáveis do escopo pai e fornecem uma sintaxe mais limpa para callbacks curtos:

$myCallback = fn() => print("The arrow callback function has been executed.");
parentFunction($myCallback);

Passando Argumentos para um Callback

A maioria dos callbacks úteis recebe dados. A função pai decide quais argumentos passar ao invocar o callback. Use call_user_func() para passá-los posicionalmente, ou call_user_func_array() para encaminhar um array de argumentos:

<?php

function applyToPair(callable $callback, int $a, int $b) {
  return call_user_func($callback, $a, $b);
}

$add      = fn(int $x, int $y) => $x + $y;
$multiply = fn(int $x, int $y) => $x * $y;

echo applyToPair($add, 4, 6);      // 10
echo "\n";
echo applyToPair($multiply, 4, 6); // 24

Aqui applyToPair não sabe se está somando ou multiplicando — essa decisão fica no callback que você passa.

Usando Callbacks com Funções Embutidas

O lugar mais comum onde você usará callbacks são as funções de array do PHP. Elas recebem um callback e o aplicam em toda uma lista, substituindo loops escritos manualmente.

<?php

$numbers = [1, 2, 3, 4, 5];

// array_map: transform every element
$squares = array_map(fn($n) => $n * $n, $numbers);
echo implode(', ', $squares);   // 1, 4, 9, 16, 25
echo "\n";

// array_filter: keep elements where the callback returns true
$evens = array_filter($numbers, fn($n) => $n % 2 === 0);
echo implode(', ', $evens);     // 2, 4
echo "\n";

// usort: sort using a comparison callback (descending order)
$values = [3, 1, 4, 1, 5];
usort($values, fn($a, $b) => $b <=> $a);
echo implode(', ', $values);    // 5, 4, 3, 1, 1

Para saber mais sobre ordenação, veja Ordenando Arrays em PHP.

Usando Métodos de Objetos como Callbacks

Um callback também pode apontar para um método. Passe [$object, 'methodName'] para um método de instância, ou ['ClassName', 'staticMethod'] para um método estático:

<?php

class Greeter {
  public function greet(string $name): string {
    return "Hello, {$name}!";
  }

  public static function shout(string $name): string {
    return strtoupper("Hi {$name}");
  }
}

$greeter = new Greeter();

// Instance method as a callback
echo call_user_func([$greeter, 'greet'], 'Ada');   // Hello, Ada!
echo "\n";

// Static method as a callback
echo call_user_func(['Greeter', 'shout'], 'Ada');  // HI ADA

Dica: Desde o PHP 8.1 você pode usar a sintaxe de callable de primeira classe — $greeter->greet(...) ou strtoupper(...) — para obter uma Closure de qualquer callable sem usar strings entre aspas, o que é mais seguro e amigável para IDEs.

Conclusão

Em conclusão, as funções de callback em PHP são uma ferramenta poderosa para a programação em PHP. Elas permitem a reutilização de código, simplificam código complexo e habilitam a programação orientada a eventos no lado do servidor. Ao entender como usar funções de callback em PHP, você pode levar suas habilidades em PHP a um novo nível.

Prática