Les opérateurs PHP

Un opérateur prend une ou plusieurs valeurs (appelées opérandes) et produit une nouvelle valeur à partir d'elles. Les opérateurs sont les éléments fondamentaux de chaque expression que vous écrivez en PHP — ils vous permettent d'effectuer des calculs arithmétiques, de comparer des valeurs, de combiner des conditions booléennes, d'affecter des résultats à des variables et de concaténer des chaînes.

Ce chapitre couvre chaque catégorie d'opérateur PHP avec des exemples exécutables : arithmétiques, affectation, comparaison, logiques, incrémentation/décrémentation, chaînes, tableaux, l'opérateur vaisseau spatial, l'opérateur null-coalescent et la façon dont la précédence des opérateurs détermine l'ordre d'évaluation.

Opérateurs arithmétiques

Les opérateurs arithmétiques effectuent les opérations mathématiques habituelles sur les nombres.

<?php
$x = 10;
$y = 3;

echo $x + $y;   // 13
echo $x - $y;   // 7
echo $x * $y;   // 30
echo $x / $y;   // 3.3333333333333
echo $x % $y;   // 1   (remainder of 10 / 3)
echo $x ** $y;  // 1000 (10 to the power of 3)

Remarque : Contrairement à de nombreux langages, le / de PHP ne tronque pas. 10 / 4 vaut 2.5, pas 2. Utilisez intdiv() pour la division entière. L'opérateur % fonctionne sur les entiers ; pour les restes en virgule flottante, utilisez fmod().

Opérateurs d'affectation

L'opérateur d'affectation de base est = — il stocke la valeur de droite dans la variable de gauche. Chaque opérateur arithmétique possède également une forme combinée (composée) qui met à jour une variable sur place.

<?php
$total = 100;
$total += 20;  // 120
$total -= 50;  // 70
$total *= 2;   // 140
echo $total;   // 140

Opérateurs de comparaison

Les opérateurs de comparaison comparent deux valeurs et retournent un boolean (true ou false). Notez la distinction importante entre la comparaison lâche (==) et la comparaison stricte (===).

<?php
var_dump(10 == "10");   // bool(true)  — values match after juggling
var_dump(10 === "10");  // bool(false) — int vs string, types differ
var_dump(5 != 8);       // bool(true)
var_dump(5 >= 5);       // bool(true)

Attention : Préférez === quand les types sont importants. 0 == "abc" est false dans les versions modernes de PHP (8.0+), mais la comparaison lâche présente encore des cas surprenants — la comparaison stricte les évite.

L'opérateur vaisseau spatial <=>

L'opérateur vaisseau spatial compare deux valeurs et renvoie -1, 0 ou 1. Il est particulièrement utile comme valeur de retour d'un callback de tri.

<?php
echo 1 <=> 2;   // -1  (left is smaller)
echo 2 <=> 2;   //  0  (equal)
echo 3 <=> 2;   //  1  (left is larger)

Opérateurs logiques

Les opérateurs logiques combinent des expressions booléennes, généralement dans des conditions if.

<?php
$age = 25;
$hasLicense = true;

var_dump($age >= 18 && $hasLicense);  // bool(true)
var_dump($age < 18 || $hasLicense);   // bool(true)
var_dump(!$hasLicense);               // bool(false)

&& et and se comportent de la même façon dans les conditions mais ont une précédence différente — and/or lient moins fortement que =, ce qui peut vous surprendre. Tenez-vous en à && et ||.

PHP effectue également des évaluations court-circuit : dans $a && expensive(), si $a est false, le côté droit n'est jamais évalué.

Opérateurs d'incrémentation et de décrémentation

Ces opérateurs ajoutent ou soustraient 1 à une variable. Leur position (pré ou post) change ce que l'expression retourne.

<?php
$x = 5;
echo $x++;  // 5  (prints old value, then $x becomes 6)
echo $x;    // 6
echo ++$x;  // 7  (increments first, then prints)

Opérateurs de chaînes

PHP dispose de deux opérateurs dédiés aux chaînes :

• . — l'opérateur de concaténation, joint deux chaînes.
• .= — l'opérateur d'affectation par concaténation, ajoute du contenu à la variable.

<?php
$greeting = "Hello";
$greeting .= ", World!";   // append
echo $greeting;            // Hello, World!
echo "PHP" . " " . "rocks"; // PHP rocks

Opérateurs de tableaux

Les opérateurs de tableaux agissent sur des tableaux entiers.

<?php
$a = ["a" => 1, "b" => 2];
$b = ["b" => 99, "c" => 3];

print_r($a + $b);
// Array ( [a] => 1 [b] => 2 [c] => 3 )
// "b" keeps the LEFT value (2), "c" is added

Opérateur null-coalescent ??

L'opérateur ?? retourne son opérande gauche s'il existe et n'est pas null, sinon l'opérande droit. C'est le remplacement propre des vérifications isset().

<?php
$data = ["name" => "Ann"];

$name = $data["name"] ?? "Guest";  // "Ann"
$role = $data["role"] ?? "Member"; // "Member" — key missing, no warning
echo "$name / $role";              // Ann / Member

L'affectation null-coalescente ??= n'affecte que lorsque la variable est actuellement null ou non définie : $config["theme"] ??= "dark";.

Précédence des opérateurs

Lorsqu'une expression mélange des opérateurs, la précédence détermine lequel s'exécute en premier, tout comme en mathématiques (* avant +). Utilisez des parenthèses pour rendre l'intention explicite et remplacer les valeurs par défaut.

<?php
echo 2 + 3 * 4;     // 14  — * binds tighter than +
echo (2 + 3) * 4;   // 20  — parentheses force addition first

Du plus haut au plus bas, quelques niveaux clés : **, puis !, puis * / %, puis + -, puis les comparaisons (< > == ===), puis &&, puis ||, et enfin =. En cas de doute, ajoutez des parenthèses — elles ne coûtent rien et évitent les bugs.

Résumé

• Arithmétique (+ - * / % **) opère sur les nombres ; / retourne un flottant, % retourne le reste.
• Affectation (= += .= …) stocke et met à jour des valeurs ; les formes composées sont des raccourcis.
• Comparaison (== === != <=>) retourne des booléens — préférez le strict === pour éviter les surprises liées au transtypage.
• Logique (&& || !) combine des conditions et court-circuite.
• Incrémentation/décrémentation (++ --) diffèrent selon la position pré/post.
• Chaîne (. .=) joint du texte ; tableau (+ == ===) compare et fusionne des tableaux.
• ?? fournit des valeurs par défaut pour les valeurs manquantes ; la précédence et les parenthèses contrôlent l'ordre d'évaluation.

Ensuite, mettez ces opérateurs en pratique dans les instructions conditionnelles et les boucles.

Pratique