DEV Community: thiCha

Pipe operator is coming to PHP !

thiCha — Tue, 07 Oct 2025 18:32:12 +0000

A new operator is coming to PHP: the pipe ! (|>)

Just like in linux, you will now be able to chain multiple commands together.

What it is

This operator will help us make the code more readable and expressive.

Before:

$result = ucfirst(strtolower(str_replace('_', ' ', "HELLO_WORLD")));

With the pipe operator:

$result = "HELLO_WORLD"
    |> str_replace('_', ' ', ...)
    |> strtolower(...)
    |> ucfirst(...);

The other way to make the first example readable is to use a temporary variable:

$result = "HELLO_WORLD";
$result = str_replace('_', ' ', $result);
$result = strtolower($result);
$result = ucfirst($result);

The pipe operator gives you clean style to chain calls.

How to use it

In PHP, we use callables so we have multiple ways to use it:

userland functions
built-in functions
static class methods
lambda functions
arrow-functions
invokable classes
first-class callables.

Here’s a demo:

$result = "42"
    |> intval(...)
    |> fn($x) => $x * 2
    |> function(int $x): string { return "Value: $x"; }
    |> new Transformer()
    |> [MathHelper::class, 'addExclamation']
    |> format_output(...);

echo $result; // Value: 84!

The drawback

“Perfect,” you might think — and almost!

But there’s a small limitation.

The pipe operator only works when the result of the previous can be passed as the first argument of the next callable.
So while the pipe operator makes code cleaner, it does have some functional-style constraints you’ll need to keep in mind.

Conclusion

The pipe operator brings a fresh, functional touch to PHP — making our code flow as smoothly as our ideas.

Tell Don't Ask principle explained

thiCha — Thu, 26 Dec 2024 19:43:05 +0000

The basic principle of the Tell Don't Ask principle is to prefer telling an object what to do rather than asking an object for its data and acting on this data.

The idea is to put into the object the behavior related to that object.

The object that owns a data is responsible of its own logic.

The code is therefore more coherent within the codebase and within the object itself.

Last but not least, the behavior is encapsulated in the object meaning that you can work with a minimal public interface outside of the object which makes it easier to maintain and modify.

Yoda condition, in PHP, What is ?

thiCha — Wed, 28 Aug 2024 17:22:13 +0000

While scrolling through code you might come across something like this if (1 === $var).

What could possibly be the difference between if ($var === 1) and if (1 === $var) ?

if ($var === 1)

This is how we learn the code because it you can write the same way you speak: if the variable $var is equal to 1 then do something.

if (1 === $var)

This is known as the “Yoda condition” from the famous Jedi Master speaking backwards.

It has to be known that there is no difference in functionality between the two approaches. So, why the hell would you use a Yoda condition when writing conditions ?

The only reason why the Yoda condition is used

When writing an if statement, it may have happened that you missed some equal signs. The problem is when you end up with something like this:

if ($var = 1) { // Instead of $var === 1
    // Do something
}

What happens here ?

No error is detected because this is code is valid. The problem is that it does not work like intended: the variable is assigned to the value 1, no comparison is performed and it is always true.

This is where the Yoda condition is useful; with the same case, we get:

if (1 = $var) { // Instead of 1 === $var
    // Do something
}

Here we also missed some equals but the code is not valid and, this time, we get an error since this is not valid.

Conclusion

We have seen that the sole purpose of the Yoda condition is to avoid accidental assignment which comes at the cost of less readeability.

Should you use it ? Why not ! But keep in mind that this will not improve your code by any margin.

Also it can help to flex at a party with devs (which does not occur that often by the way).

For you reading, thank you ! 💚

Magic Strings & Magic Numbers 🪄

thiCha — Mon, 29 Jul 2024 21:39:40 +0000

Magic numbers are literal numeric values that are used in code without any explanation of their meaning. Magic strings are strings literals without any explanation either.

Why is it a problem ?

First of all, it is not easy to read when there is only a number that is written in code. Let's look at an example:

$myModel = new Model();
$myModel->status_id = 3; // A magic number
$myModel->save();

Here there is no explanation of the meaning behind the value "3". I can probably find the answer by looking at the code surrounding this snippet or look for a corresponding value elsewhere (like in a database table).

Also the number "3" is not important in itself for my comprehension of the code. The status should correspond to a more realistic status of my business like "Created", "Sent", "Archived".

The same applies to Magic Strings:

switch ($request->code_response) {
  case "code_1": // Magic String
    doAnAction();
    break;
  case "code_2": // Also a Magic String
    doAnotherAction();
    break;
...

I can probably guess the utility of these code values by looking at the code of the doAnAction() and doAnotherAction() functions but it would greatly help to have a code more readable at this stage.

How to solve this problem ?

Different solutions can be used. The simplest one is to use a named variable:

$statusCreated = 3;

$myModel = new Model();
$myModel->status_id = $statusCreated;
$myModel->save();

A better solution is to use constant values in a separate class or even an enum.

enum MyModelStatuses {
...
  case CREATED = 3;
  case ARCHIVED = 4;
...
}

$myModel = new Model();
$myModel->status_id = MyModelStatuses::CREATED->value; // don't forget to import the new class
$myModel->save();

A separate class allow you to have a global logic behind these values that can be reused elsewhere.

Another solution when the Magic Number is only used in one class is to use a const variable in the class:
From:

class MyClass {
  public function myFunction() {
    for ($i = 0; $i < 10; $i++) { // Here 10 is a Magic Number
      // Do something
    }
  }
}

To:

class MyClass {
  private const NUMBER_OF_ITERATIONS = 10;

  public function myFunction() {
    for ($i = 0; $i < self::NUMBER_OF_ITERATIONS; $i++) {
      // Do something
    }
  }
}

Such constants are used as parameters inside your class and can be easily replaced by new values.

Let's see a last use case of avoiding Magic Numbers.

$myModel = new MyModel();
$myModel->duration = 60; // Magic Number
$myModel->save();

Here the value 60 can be confusing. What is its unit ? It could me seconds, it could be minutes or even hours !

$secondsInAMinute = 60;

$myModel = new MyModel();
$myModel->duration = $secondsInAMinute;
$myModel->save();

The name of the new variable itself helps to make the code readable. Also the same number could refer to different meanings (in this case we could have 60 as $minutesInAnHour somewhere else in the code).

That's it ! I hope that this article helped you understand what are Magic Numbers (and Magic Strings) and how to remove them from your code !

Spaceship operator 🚀 in PHP

thiCha — Tue, 16 Jul 2024 11:00:23 +0000

Introduced in PHP 7, the Spaceship operator <=> is used to compare two expressions.

It returns:

0 if both values are equal
1 if left operand is greater
-1 if right operand is greater

Let’s see it with an example:

echo 2 <=> 2; // Outputs 0
echo 3 <=> 1; // Outputs 1
echo 1 <=> 3; // Outputs -1

echo "b" <=> "b"; // Outputs  0
echo "a" <=> "c"; // Outputs -1
echo "c" <=> "a"; // Outputs 1

// Note: for string comparison, the ASCII value of the characters are used, that is why "c" is greater than "a"
echo "ping" <=> "pong"; // Outputs -1 since "o" is greater than "i"

This operator can be used for sorting arrays:

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

usort($numbers, function ($a, $b) {
    return $a <=> $b; // Sort in ascending order
});

echo print_r($numbers); // Outputs [1,2,3,4,5,9]

usort($numbers, function ($a, $b) {
    return $b <=> $a; // Sort in descending order
});

echo print_r($numbers); // [9,5,4,3,2,1]

Elvis operator ?: vs Null coalescing operator

thiCha — Thu, 30 May 2024 14:59:17 +0000

The Elvis operator and the Null coalescing operator are both binary operators that allow you to evaluate an expression/variable and define a default value when the expression/variable is not available.

The Elvis operator

The Elvis operator is used to return a default value when the given operand is false.
Its name comes from the resemblance of the notation ?: with the hairstyle of the famous singer.

Usage in PHP:

$variable = [];
$result = $variable ?: 'default value';
echo $result; // Outputs: default value (since an empty array is considered falsy)

Equivalent with a Ternary condition:

$variable = [];
$result = $result ? $result : 'default value';

The Null coalescing operator

Quite similar to the Elvis operator, the null coalescing operator returns a default value when the given operand is null or undefined.

Usage in PHP:

$variable = [];
$result = $variable ?? 'default value';
echo $result; // Outputs: [] (since an empty array is not null)

Equivalent with a Ternary condition:

$variable = [];
$result = isset($result) ? $result : 'default value';