O Operador Pipe (|>) no PHP 8.5

Encadear transformações em PHP sempre exigiu variáveis intermediárias ou aninhar chamadas de função umas dentro das outras, o que vira uma leitura de dentro para fora difícil de acompanhar. O operador pipe (|>), introduzido no PHP 8.5, resolve isso permitindo passar o resultado de uma expressão diretamente como argumento da próxima chamada, lida de cima para baixo (ou da esquerda para a direita), na ordem em que o processamento realmente acontece.

Como funciona

O operando da esquerda é avaliado e passado como único argumento para o callable da direita. O resultado dessa chamada se torna o operando da esquerda do próximo |>, e assim por diante. O lado direito precisa ser um first-class callable — por isso funções nomeadas aparecem com (...) no lugar dos parênteses de chamada:

$resultado = "  Hello World  "
    |> trim(...)
    |> strtoupper(...)
    |> str_shuffle(...);

echo $resultado; // uma permutação aleatória de "HELLOWORLD"

Sem o pipe, a mesma transformação ficaria com as chamadas aninhadas de dentro para fora:

$resultado = str_shuffle(strtoupper(trim("  Hello World  ")));

Funções com mais de um parâmetro

Como cada etapa do pipe só pode receber um argumento (o valor vindo da etapa anterior), funções que precisam de parâmetros extras — como str_replace() ou array_column() — precisam ser envolvidas em uma arrow function:

$preco = "R$ 1.299,90"
    |> fn(string $s) => str_replace(['R$', '.', ','], ['', '', '.'], $s)
    |> trim(...)
    |> floatval(...);

echo $preco; // 1299.9

A arrow function recebe o valor da etapa anterior como parâmetro e decide como repassá-lo para a função que precisa de argumentos adicionais.

Combinando com métodos e closures

O lado direito aceita qualquer forma de callable que o PHP já suporta — métodos estáticos, métodos de instância e closures, não apenas funções globais:

final class Slug
{
    public static function gerar(string $texto): string
    {
        return strtolower(trim(preg_replace('/[^A-Za-z0-9]+/', '-', $texto), '-'));
    }
}

$slug = "Artigo: Operador Pipe no PHP!"
    |> Slug::gerar(...)
    |> fn(string $s) => substr($s, 0, 50);

echo $slug; // artigo-operador-pipe-no-php

Casos de uso práticos

Pipelines de normalização de texto ou dados de entrada (trim, lowercase, remoção de acentos, validação) sem variáveis temporárias descartáveis.
Transformação de coleções em sequência, aplicando uma função de cada vez a um array já processado pela etapa anterior.
Composição de regras de validação ou sanitização que hoje ficam espalhadas em chamadas aninhadas difíceis de reordenar.
Substituir cadeias de métodos fluentes (fluent interfaces) quando a classe não foi desenhada para isso, já que o pipe funciona com qualquer função ou método existente.

Cuidados

O callable do lado direito deve aceitar exatamente um parâmetro — passar uma função que exige dois ou mais argumentos obrigatórios sem envolvê-la em uma arrow function resulta em erro. Parâmetros passados por referência também têm suporte limitado: tentar encadear um valor composto (como um array) por referência pode lançar o erro "Argument could not be passed by reference". Vale notar ainda que |> tem precedência menor do que a arrow function, então ao usar fn(...) => ... dentro de um pipe mais longo, pode ser necessário envolver a arrow function em parênteses para evitar que ela capture o restante da expressão.

Compatibilidade

O operador pipe foi introduzido no PHP 8.5, lançado em novembro de 2025, e exige essa versão ou superior — não há como fazer polyfill dessa sintaxe em versões anteriores.

documentação oficial

Conclusão

O operador pipe dá ao PHP uma forma nativa de expressar pipelines de transformação na ordem em que eles realmente acontecem, eliminando variáveis intermediárias e chamadas aninhadas de difícil leitura. É um recurso simples na superfície, mas que muda bastante o estilo de escrever código que processa um valor em várias etapas sucessivas.