PHP 8.5 e l'operatore pipe |> : pipeline leggibili senza mal di testa

26 settembre 2025. Segnati la data: PHP 8.5 si presenta alla porta e dovrai conviverci. Tra le novità spicca l'operatore pipe |>, che ti costringe a dire addio alle parentesi matrioska e ad abbracciare pipeline che puoi leggere senza analgesici.

In queste righe smonti l'operatore, ne misuri i limiti e, soprattutto, rubi casi d'uso reali per portarlo in produzione senza fingere panico.

Perché mai un pipe in PHP?

In praticamente ogni app incolli trasformazioni: ripulisci l'input, validi il payload, istanzi oggetti, serializzi risposte. Finora avevi due pessime scelte:

• annidare chiamate (foo(bar(baz($input)))) sperando che il collega del lunedì capisca l'ordine;
• seminare variabili temporanee ($step1, $step2, $step3) finché il file sembra un quaderno stropicciato.

Il pipe |> ti offre la terza via: passa il valore a sinistra come argomento implicito all'espressione di destra. Risultato: codice che leggi dall'alto verso il basso, esattamente come ragioni quando non sei a corto di caffè.

Sintassi: l'unica regola da ricordare

La regola è corta: quello che sta a sinistra finisce come primo parametro a destra. Se la funzione lo vuole altrove, piazza ... nel punto giusto. Niente rituali, solo tre puntini.

php
1$result = $dati
2    |> trim(...)
3    |> htmlspecialchars(..., ENT_QUOTES, 'UTF-8')
4    |> mb_strtoupper(..., 'UTF-8');

Qui trim riceve $dati, il risultato passa a htmlspecialchars e chiude su mb_strtoupper. Zero parentesi extra, zero variabili usa-e-getta.

ℹ️ Se l'espressione accetta più argomenti, ... segnala lo slot esatto. Dimenticalo e PHP infila il valore nel primo parametro, poi divertiti a inseguire il bug “imprevisto”.

Caso pratico n. 1: mettere in riga un form

Immagina un'API che riceve il titolo di un articolo. Vuoi:

1. togliere spazi inutili;
2. tagliare a 80 caratteri;
3. assicurarti che non sia vuoto;
4. restituire un errore decente se esplode tutto.

php
1$title = $payload['title'] ?? '';
2
3$normalizedTitle = $title
4    |> trim(...)
5    |> fn(string $value) => mb_substr($value, 0, 80)
6    |> fn(string $value) => match (true) {
7        $value === '' => throw new InvalidArgumentException('Il titolo è obbligatorio.'),
8        default => $value,
9    };

Ogni tappa della pipeline resta isolata, testabile e facile da rileggere. Le funzioni anonime sono il guardrail che ti evita di creare un'altra classe solo per calmare l'architetto ansioso.

Caso pratico n. 2: lucidare una risposta HTTP

Pensa al tuo microservizio meteo che sputa JSON. Con il pipe componi la trasformazione tenendo ogni intenzione nella propria corsia:

php
1$responseBody = $weatherProvider->fetchForCity('Lyon')
2    |> fn(array $data) => array_merge($data, [
3        'updatedAt' => (new DateTimeImmutable('now', new DateTimeZone('Europe/Paris')))->format(DateTimeInterface::ATOM),
4    ])
5    |> array_map(fn($value) => is_float($value) ? round($value, 1) : $value, ...)
6    |> fn(array $data) => array_intersect_key($data, array_flip(['temperature', 'humidity', 'windSpeed', 'updatedAt']))
7    |> json_encode(..., JSON_THROW_ON_ERROR | JSON_PRETTY_PRINT);

Leggi il flusso come una serie di trasformazioni pulite. Hai bisogno di log o metriche? Inserisci una lambda in mezzo e passa oltre.

Caso pratico n. 3: idratare un oggetto di dominio

Il pipe va d'accordo anche con metodi statici o di istanza, finché accettano il valore come primo argomento. Guarda il Value Object EmailAddress, perfetto per bloccare indirizzi digitati con i gomiti:

php
1$recipient = $input['email'] ?? '';
2
3$email = $recipient
4    |> trim(...)
5    |> mb_strtolower(..., 'UTF-8')
6    |> EmailAddress::fromString(...)
7    |> fn(EmailAddress $address) => ContactPreference::fromEmail($address);

Con ... dentro EmailAddress::fromString(...) dici a PHP dove incollare il valore. Poi puoi concatenare un costruttore di aggregato o un comando CQRS senza trasformare il codice in spaghetti.

Buone pratiche per dormirci sereno

• Cerca coerenza: ogni pipeline deve raccontare una sola storia. Se mischia validazione, persistenza e render, tagliala prima che lo faccia la review.
• Dai nomi o commenti quando servono: una lambda fn($x) => $x non serve. Meglio una funzione tipo sanitizeTitle se l'intento non si capisce al volo.
• Cura la verticalità: allinea i pipe, lascia aria tra i blocchi logici, aggiungi commenti lampo quando risparmiano mal di testa.
• Pensa ai test: estrai helper puri (es. limitLength) per testarli a parte. La pipeline resta orchestration, non discarica.
• Rispetta i tipi: ogni step deve accettare e restituire ciò che il successivo pretende. union types e readonly classes sposano bene questo stile funzionale, se li usi per qualcosa più utile di vantarti su LinkedIn.

Quando lasciare il pipe nel cassetto

Nonostante il fascino, non è la soluzione universale:

• Trasformazioni con effetti collaterali (email, richieste HTTP, scritture su disco) sporcano il flusso. Impacchettale in un metodo esplicito e chiamalo in coda, assumendoti la responsabilità.
• API che aspettano il valore come secondo argomento: sì, puoi spostarlo con ..., ma la leggibilità crolla. Scrivi un helper e smettila di far finta che vada tutto bene.
• Pipeline mutate: se hai più di tre lambda con stranezze di stato, respira, spezzale o torna all'imperativo. Nessuno premia la pipeline più illeggibile.

Come innestarlo in una codebase viva

1. Mappa gli hotspot: caccia gli accrocchi di array_map/array_filter, le validazioni di form e le trasformazioni delle risposte.
2. Refactor progressivo: sostituisci i blocchi annidati con pipeline corte. Metti test di regressione se ci tieni al sonno.
3. Allinea le convenzioni: scrivi sul playbook interno quando usare il pipe, come battezzare gli helper e come gestire le eccezioni.
4. Aggiorna il tooling: rinfresca snippet e linter per la nuova sintassi (php-cs-fixer, Psalm, PHPStan) o passerai settimane a insultare warning inutili.
5. Forma il team: fai una review dedicata o un live coding per mostrare i guadagni di leggibilità, anche ai nostalgici di PHP 5.

Riepilogo flash

• Il pipe |> di PHP 8.5 spinge il valore a sinistra dentro l'espressione a destra senza variabili temporanee.
• Aggiungi ... per parcheggiare il valore dove serve davvero, oppure preparati a bug fantasma.
• Pipeline corte e coerenti alzano leggibilità, testabilità ed espressività.
• Tieni l'operatore per trasformazioni pure (o quasi); incapsula gli effetti collaterali altrove.
• Sistema ecosistema (linter, standard, formazione) così la novità non manda in frantumi il resto del progetto.

Il pipe non trasforma PHP in un linguaggio funzionale puro, ma ti mette in mano uno strumento affilato per scrivere codice moderno e espressivo. Ora tocca a te: rendi le tue catene di trasformazione chiare quanto le tue idee… o almeno meno nebulose del solito.