A aplicação parcial de funções está disponível a partir do PHP 8.6.0. Uma função ou chamada de método que fornece alguns dos argumentos e usa marcadores de posição para os outros não executa a chamada. Em vez disso, ela cria um Closure cujos parâmetros são aqueles que foram substituídos por um marcador de posição. Ela estende a sintaxe de chamável de primeira classe, que é o caso particular em que nenhum argumento é fornecido: qualquer expressão que possa ser chamada pode ser usada, e a função ou método a ser chamado é determinada quando o Closure é criado.
? representa exatamente um argumento. O parâmetro correspondente
do Closure é sempre obrigatório,
mesmo que o parâmetro da função original seja opcional.
... representa todos os parâmetros que não foram
mencionados de outra forma. Eles mantêm seus valores padrão, e um
parâmetro variádico continua variádico. Ele só pode aparecer uma vez, e
deve ser o último argumento.
Exemplo #1 Aplicação parcial de funções
<?php
function volume(int $length, int $width, int $height): int
{
return $length * $width * $height;
}
// "?" representa exatamente um argumento
$closure = volume(2, ?, 4);
// equivalente a: static fn(int $width): int => volume(2, $width, 4)
var_dump($closure(3));
$closure = volume(?, 3, ?);
// equivalente a: static fn(int $length, int $height): int => volume($length, 3, $height)
var_dump($closure(2, 4));
// "..." representa todos os argumentos restantes
$closure = volume(2, ...);
// equivalente a: static fn(int $width, int $height): int => volume(2, $width, $height)
var_dump($closure(3, 4));
// Com todos os argumentos fornecidos, "..." apenas adia a chamada
$closure = volume(2, 3, 4, ...);
// equivalente a: static fn(): int => volume(2, 3, 4)
var_dump($closure());
?>O exemplo acima produzirá:
int(24) int(24) int(24) int(24)
A aplicação parcial de funções é uma maneira conveniente de fornecer o chamável de parâmetro único esperado pelo operador pipe.
Exemplo #2 Aplicação parcial de funções com |>
<?php
echo ' Hello World '
|> trim(...)
|> str_replace(' ', '', ?)
|> strtoupper(...)
|> str_pad(?, 12, '*', STR_PAD_BOTH);
?>O exemplo acima produzirá:
*HELLOWORLD*
Os parâmetros do Closure recebem seu nome, declaração de tipo e modo de passagem por referência da função original, assim como seu tipo de retorno. A aplicação parcial de funções pode ser usada em expressões constantes, desde que os argumentos sejam expressões constantes por si mesmas.
Argumentos nomeados podem
ser usados para fornecer um argumento, e um marcador também pode ser nomeado,
usando nome: ?. Como em uma chamada regular, eles devem vir
após os argumentos posicionais. Os parâmetros do
Closure seguem a ordem em que os marcadores nomeados
são escritos, o que torna possível reordená-los.
Exemplo #3 Marcadores nomeados
<?php
// Os parâmetros do closure são $subject, depois $search
$remove = str_replace(subject: ?, search: ?, replace: '');
var_dump($remove('a-b-c', '-'));
?>O exemplo acima produzirá:
string(3) "abc"
Os argumentos fornecidos são avaliados uma vez, quando o Closure é criado, e não cada vez que ele é chamado. Isso difere de uma função de seta envolvendo a mesma chamada, cujo corpo é avaliado a cada chamada.
Exemplo #4 Os argumentos são avaliados quando o Closure é criado
<?php
function now(): string
{
echo "now() foi chamada\n";
return '12:00';
}
function greet(string $name, string $time): string
{
return "Olá $name, são $time\n";
}
$arrow = fn(string $name) => greet($name, now());
echo "Função de seta criada\n";
echo $arrow('Alice');
$partial = greet(?, now());
echo "Aplicação parcial criada\n";
echo $partial('Bob');
?>O exemplo acima produzirá:
Função de seta criada now() foi chamada Olá Alice, são 12:00 now() foi chamada Aplicação parcial criada Olá Bob, são 12:00
Se o marcador ... não for usado, os argumentos passados para
o Closure além de seus parâmetros são ignorados.
Se for usado, eles são encaminhados para a função original. Isso
é importante quando o Closure é usado como um callback
por uma função que passa mais argumentos do que o esperado, como a chave
de um elemento de array: com ... eles alcançam os parâmetros
opcionais da função original.
Exemplo #5 Argumentos adicionais são encaminhados apenas com ...
<?php
function greet(string $name, string $greeting = 'Hello'): string
{
return "$greeting $name\n";
}
// O segundo argumento é ignorado
$closure = greet(?);
echo $closure('Alice', 'Goodbye');
// O segundo argumento é encaminhado para greet()
$closure = greet(?, ...);
echo $closure('Alice', 'Goodbye');
?>O exemplo acima produzirá:
Hello Alice Goodbye Alice
A criação de objetos (por exemplo, new Foo(1, ?)) não é suportada,
porque a sintaxe new Foo() não é considerada uma chamada.
Marcadores não podem ser combinados com o operador nullsafe.
Marcadores não podem ser combinados com desempacotamento de argumentos.
Funções que inspecionam o escopo de chamada, como compact(), extract(), func_get_args() e get_defined_vars(), não podem ser usadas. Um Error é lançado.
Exemplo #6 Usos inválidos que resultam em erro no momento da compilação
<?php
new Foo(1, ?); // Não é possível criar Closure para a expressão 'new'
$obj?->method(1, ?); // Não é possível combinar o operador nullsafe com criação de Closure
foo(?, ...$array); // Não é possível combinar aplicação parcial e desempacotamento de array
foo(..., ?); // Marcador variádico precisa ser o último
foo(a: 1, ?); // Não é possível usar argumento posicional após argumento nomeadoUm ArgumentCountError é lançado, quando o Closure é criado, se o número de algumentos e marcadores não corresponde aos parâmetros da função.