Mastering the New PHP 8.5 Pipe Operator (|>)

🧭 What is the Pipe Operator (|>) in PHP 8.5?

PHP 8.5 introduces a game-changing feature: the Pipe Operator (|>). This operator allows you to chain functions together in a left-to-right flow, where the result of one function automatically becomes the input for the next.

Think of it like a pipeline: data flows through each function, getting transformed along the way.

✅ No more nested calls.
✅ No more temporary variables.
✅ Just a clean, easy-to-read transformation chain.

🧱 Why Do We Need the Pipe Operator?

Imagine you want to transform a string by applying several functions:

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

This works, but it’s hard to read — you have to start from the inside out.
Alternatively, you could use temporary variables:

$string = "Hello World";
$upper = strtoupper($string);
$shuffled = str_shuffle($upper);
$result = trim($shuffled);

But that feels a bit verbose.

Enter the Pipe Operator (|>):

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

💡 Much cleaner, right?

🏗️ How the Pipe Operator Works

The Pipe Operator takes the result of the left expression and automatically passes it as the first argument to the right callable.

✅ The left side is an expression or value (like a string, array, object, or function result).
✅ The right side must be a callable that accepts one required parameter.

📦 Example:

$message = "OpenAI GPT"
    |> strtoupper(...)
    |> strrev(...)
    |> trim(...);

echo $message;
// Output: "TPG IANEPO"

🎯 What Can You Use on the Right Side? (Supported Callables)

The Pipe Operator works with:

✅ Built-in functions like strtoupper, trim, etc.
✅ User-defined functions:

function addExclamation($text) {
    return $text . "!";
}
$message = "Hello"
    |> addExclamation(...);

✅ Static methods:

class TextUtils {
    public static function greet($name) {
        return "Hello, $name";
    }
}

$name = "Alice"
    |> TextUtils::greet(...);

✅ Instance methods and objects with __invoke.
✅ Arrow functions and anonymous functions:

$name = "Bob"
    |> fn($n) => strtoupper($n);

✅ First-class callables using ....

⚠️ Limitations of the Pipe Operator

🚫 The pipe operator is designed for single-argument functions only.

🚫 You can’t change the parameter position; the value is always passed as the first argument.

🚫 If a function does not accept any arguments, you cannot use it in a pipe chain.

🚫 Functions that return void will pass null to the next function.

🌊 Readable Chains with the Pipe Operator

✅ Single line:

$result = "OpenAI" |> strtoupper(...) |> strrev(...) |> trim(...);

✅ Multiline (more readable!):

$result = "OpenAI"
    |> strtoupper(...)
    |> strrev(...)
    |> trim(...);

🔍 Type Safety and Coercion

The Pipe Operator follows PHP’s existing type rules:

• If strict_types is enabled, type mismatches will throw errors.
• The operator doesn’t change type behavior; it just improves syntax.

🌟 Real-World Example: Cleaning User Input

function sanitize($input) {
    return htmlspecialchars($input, ENT_QUOTES, 'UTF-8');
}

$userInput = "  <h1>Hello World!</h1>  ";

$cleaned = $userInput
    |> trim(...)
    |> strtolower(...)
    |> sanitize(...);

echo $cleaned;
// Output: &lt;h1&gt;hello world!&lt;/h1&gt;

📊 Summary Table: The Pipe Operator at a Glance

🚀 Why the Pipe Operator is a Game-Changer

✅ Makes your code cleaner and more readable.
✅ Great for data transformation (strings, arrays, objects).
✅ No more nested functions or temporary variables.
✅ Brings PHP closer to functional programming concepts.

🏁 Final Thoughts

The Pipe Operator (|>) in PHP 8.5 isn’t just syntactic sugar — it’s a powerful new tool for writing elegant, readable, and expressive code.

As you get comfortable with it, you’ll find your PHP code looking cleaner and easier to maintain, especially when chaining multiple single-argument functions.

✨ Start using it today, and make your PHP code flow like a river!