The spaceship operator () returns -1, 0, or 1 based on whether the left operand is less than, equal to, or greater than the right operand, making it ideal for comparisons in sorting; 1. It simplifies multi-field sorting by replacing verbose if-else logic with clean array comparisons; 2. It works with numbers, strings, and arrays using standard PHP comparison rules; 3. Common uses include sorting objects, alphabetical string comparisons, and version checks; 4. Caution is needed with type juggling, incompatible array structures, and PHP version compatibility below 7.0; the operator enhances readability and reduces boilerplate code when used correctly.

The spaceship operator () is a compact, powerful tool introduced in PHP 7.0 that simplifies three-way comparisons — especially when sorting or comparing values. Instead of writing multiple conditions to determine whether one value is less than, equal to, or greater than another, gives you a single expression that returns -1, 0, or 1 depending on the relationship between two operands.

What Does the Spaceship Operator Do?

The spaceship operator compares two expressions and returns:

• -1 if the left operand is less than the right
• 0 if both operands are equal
• 1 if the left operand is greater than the right

This behavior aligns perfectly with how comparison functions work in sorting algorithms, making it ideal for usort, uasort, and custom comparison logic.

For example:

echo 5 <=> 10; // returns -1
echo 10 <=> 10; // returns 0
echo 15 <=> 10; // returns 1

It works with numbers, strings, and even arrays (using standard PHP comparison rules).

How It Simplifies Sorting

Before <=>, implementing multi-level sorting in PHP often meant writing verbose if-else blocks inside comparison functions.

Without the spaceship operator:

usort($users, function($a, $b) {
    if ($a['age'] == $b['age']) {
        return $a['name'] < $b['name'] ? -1 : ($a['name'] > $b['name'] ? 1 : 0);
    }
    return $a['age'] < $b['age'] ? -1 : 1;
});

With <=>, this becomes clean and readable:

usort($users, function($a, $b) {
    return [$a['age'], $a['name']] <=> [$b['age'], $b['name']];
});

Yes — it even works with arrays! PHP compares them lexicographically, so you can chain multiple fields naturally.

Common Use Cases

Here are practical scenarios where <=> shines:

• Sorting objects by multiple properties:

  usort($products, fn($x, $y) => 
      [$x->category, $x->price] <=> [$y->category, $y->price]
  );

• String comparisons (alphabetical order):

  'apple' <=> 'banana'; // -1
  'cherry' <=> 'apple'; // 1

• Version number comparisons:

  version_compare('2.5.0', '2.4.9') <=> 0; // 1 (since 2.5.0 > 2.4.9)
  // Or directly:
  '2.5.0' <=> '2.4.9'; // works if strings compare correctly

  Just be cautious: string comparison follows dictionary order, so '10' is true in string context. For version numbers, <code>version_compare() is safer.

  Things to Watch Out For

  • Type juggling: PHP uses loose comparison rules. 0 'abc' returns -1 because non-numeric strings are treated as 0 in numeric context.
  • Arrays must be comparable: Comparing dissimilar arrays can lead to unexpected results or warnings.
  • Not all PHP versions support it: Only available from PHP 7.0 .

  So while makes code cleaner, always ensure operands are of compatible types and predictable formats.

  Basically, the spaceship operator isn’t just a novelty — it’s a practical syntax improvement that reduces boilerplate and enhances readability, especially in sorting logic. Once you start using it, you’ll wonder how you lived without it.

  The above is the detailed content of The Spaceship Operator (``): Simplifying Three-Way Comparisons. For more information, please follow other related articles on the PHP Chinese website!