Opérateurs PHP : arithmétiques, logiques, chaînes et plus

Un opérateur prend une ou plusieurs valeurs et en produit une nouvelle : $a + $b additionne, $a . $b assemble des chaînes, $a && $b est un ET logique, $a === $b compare, $i++ incrémente.

<?php
$a = 17;
$b = 5;

echo "a + b  = ", $a + $b, "\n";
echo "a - b  = ", $a - $b, "\n";
echo "a * b  = ", $a * $b, "\n";
echo "a / b  = ", $a / $b, "\n";
echo "a % b  = ", $a % $b, "\n";
echo "a ** 2 = ", $a ** 2, "\n";
echo "intdiv = ", intdiv($a, $b), "\n";

/ renvoie un float sauf si deux entiers se divisent exactement : 17 / 5 vaut 3.4, 10 / 5 vaut l'entier 2. Quand vous ne voulez que la partie entière, utilisez intdiv(). Les arrondis sont expliqués sur la page des fonctions mathématiques.

Opérateurs arithmétiques

Le modulo sert pour les cas « un élément sur N » et les tests pair/impair. Son résultat prend le signe du côté gauche, et une division par zéro lève une erreur que vous pouvez intercepter :

<?php
for ($i = 1; $i <= 6; $i++) {
    echo $i, $i % 2 === 0 ? " even" : " odd", "\n";
}

var_dump(-7 % 3);
var_dump(fmod(7.5, 2));   // modulo for floats

try {
    echo 10 % 0;
} catch (DivisionByZeroError $e) {
    echo "Error: ", $e->getMessage(), "\n";
}

Opérateurs d'affectation

= stocke une valeur. Chaque opérateur arithmétique et de chaîne a une forme combinée qui met à jour une variable sur place.

<?php
$total = 100;
$total += 20;   // $total = $total + 20
$total -= 5;
$total *= 2;
$total /= 10;
$total **= 2;
echo $total, "\n";

$path = "/home";
$path .= "/docs";      // append a string
echo $path, "\n";

$name = null;
$name ??= "Guest";     // assign only if null or unset
echo $name, "\n";

??= appartient à la famille de l'opérateur de fusion null. Il n'affecte que si la variable n'est pas définie ou vaut null.

Incrémenter et décrémenter : ++ et --

$i++ renvoie la valeur actuelle, puis ajoute 1. ++$i ajoute 1, puis renvoie la nouvelle valeur. La différence n'apparaît que si vous utilisez le résultat dans la même expression.

<?php
$i = 5;
echo $i++, "\n";  // prints 5, then $i becomes 6
echo $i, "\n";

$j = 5;
echo ++$j, "\n";  // $j becomes 6, prints 6

$k = 10;
$k--;
echo $k, "\n";

// ++ also works on letters
$col = "A";
$col++;
echo $col, "\n";
$col = "Z";
$col++;
echo $col, "\n";

L'astuce sur les lettres est souvent utilisée pour générer des noms de colonnes de tableur (A, B, ... Z, AA).

Opérateurs logiques : &&, ||, ! et xor

&& et || court-circuitent : le côté droit n'est pas évalué quand le côté gauche décide déjà du résultat. C'est ce qui rend isset($user) && $user->isAdmin() sûr.

<?php
$age = 20;
$hasTicket = true;

var_dump($age >= 18 && $hasTicket);
var_dump($age < 12 || $age > 65);
var_dump(!$hasTicket);
var_dump(true xor true);

function check(string $label): bool {
    echo "checked $label\n";
    return true;
}
false && check("A");   // never runs
true || check("B");    // never runs
true && check("C");    // runs

and ou && : le piège de la priorité

and et or sont moins prioritaires que =, donc dans une affectation ils s'appliquent après le stockage de la valeur. C'est un bug classique :

<?php
$x = true and false;   // read as: ($x = true) and false
var_dump($x);

$y = true && false;    // read as: $y = (true && false)
var_dump($y);

$z = (true and false); // parentheses fix it
var_dump($z);

Cette faible priorité est utile dans un idiome, $file = fopen($path, 'r') or die('Cannot open');, où vous voulez que l'affectation ait lieu d'abord. Partout ailleurs, utilisez && et ||.

Opérateurs de chaîne : . et .=

PHP a deux opérateurs de chaîne : . assemble deux chaînes ("Grace" . " " . "Hopper") et .= ajoute à une variable ($html .= "<li>"). + n'assemble jamais de chaînes : "3" + "4" donne le nombre 7, alors que "3" . "4" donne la chaîne "34". La page sur les chaînes traite de l'interpolation et des guillemets.

La comparaison et l'opérateur spaceship <=>

== compare après conversion des types, === vérifie aussi le type, et <=> renvoie -1, 0 ou 1, exactement ce dont ont besoin les fonctions de tri. Les détails et le tableau complet des comparaisons souples sont sur la page des opérateurs de comparaison.

<?php
var_dump(1 <=> 2);
var_dump(2 <=> 2);
var_dump(3 <=> 2);

$prices = [30, 5, 120, 18];
usort($prices, fn($a, $b) => $a <=> $b);
echo implode(", ", $prices), "\n";

usort($prices, fn($a, $b) => $b <=> $a);   // descending
echo implode(", ", $prices), "\n";

Opérateurs de tableau

+ sur des tableaux est une union : les clés du tableau de gauche l'emportent et seules les clés absentes sont ajoutées depuis la droite. Cela surprend ceux qui s'attendent à un ajout à la fin. == vérifie les mêmes paires clé/valeur, === exige aussi le même ordre et les mêmes types.

<?php
print_r([1, 2] + [3, 4, 5]);
print_r(["a" => 1] + ["a" => 99, "b" => 2]);

var_dump(["a" => 1, "b" => 2] == ["b" => 2, "a" => 1]);
var_dump(["a" => 1, "b" => 2] === ["b" => 2, "a" => 1]);

Pour ajouter une liste à la suite d'une autre, utilisez array_merge() ou la syntaxe de décomposition [...$a, ...$b].

Priorité des opérateurs

Quand une expression mélange des opérateurs, PHP les applique dans un ordre fixe. Ceux qui piègent le plus souvent, avec ce qu'affiche PHP 8.3 :

echo 2 + 3 * 4;        // 14: * before +
echo (2 + 3) * 4;      // 20
echo 2 ** 3 ** 2;      // 512: right to left, 2 ** 9
echo -2 ** 2;          // -4: ** before unary minus
echo "Sum: " . 2 + 3;  // Sum: 5, since PHP 8 + runs before .

En cas de doute, ajoutez des parenthèses. Elles ne coûtent rien, et la prochaine personne qui lira la ligne n'aura pas à se souvenir du tableau.