Les opérateurs sont des symboles qui permettent de manipuler les variables.

Opérateurs arithmétiques

<?php
$un_chiffre = 4; //affectation de l'entier 4 à la variable un_chiffre
$un_mot = 'je suis fan des pâtes'; //affectation de la chaîne de caractères à la variable "un_mot"

+ : Opérateur d'addition

<?php
$mon_premier_chiffre = 3;                                 //affectation du premier chiffre
$mon_deuxieme_chiffre = 4;                                //affectation du deuxième chiffre
$resultat = $mon_premier_chiffre + $mon_deuxieme_chiffre; //affectation de l'addition des deux chiffres
echo $resultat; //affiche 3+4 soit 7

Si les opérandes sont des tableaux, "+" est l'opérateur union^[1].

<?php
$mon_premier_chiffre = 3;
$mon_deuxieme_chiffre = 4;
$resultat = $mon_premier_chiffre - $mon_deuxieme_chiffre;
echo $resultat; //affiche 3-4 soit -1

<?php
$mon_premier_chiffre = 3;
$mon_deuxieme_chiffre = 4;
$resultat = $mon_premier_chiffre * $mon_deuxieme_chiffre;
echo $resultat; //affiche 3*4 soit 12

<?php
$mon_premier_chiffre = 2;
$mon_deuxieme_chiffre = 3;
$resultat = $mon_premier_chiffre ** $mon_deuxieme_chiffre;
echo $resultat; //affiche 2^3 soit 8

<?php
$mon_premier_chiffre = 3;
$mon_deuxieme_chiffre = 4;
$resultat = $mon_premier_chiffre / $mon_deuxieme_chiffre;
echo $resultat; //affiche 3/4 soit 0,75

 % Opérateur modulo

<?php
$mon_premier_chiffre = 3;
$mon_deuxieme_chiffre = 4;
$resultat = $mon_premier_chiffre % $mon_deuxieme_chiffre;
echo $resultat; //affiche 3 modulo 4 soit 3 (le modulo est le reste entier de la division euclidienne)

Il sert à tester si un nombre est le multiple d'un autre :

<?php
if ($nb % 3 == 0) { 
 // $nb est un multiple de trois
}

 le reste de la division peut être obtenu avec la fonction fmod()^[2].

Lors de la division de nombres à virgules flottantes, on peut facilement avoir un problème de précision du langage à cause du mode de leur stockage en mémoire. Par exemple sur http://phpfiddle.org/ :

echo PHP_VERSION.PHP_EOL;
var_dump(fmod(9999.00000, 9998.00001));

donne :

7.3.14
float(0.99999000000025)

Il faut les arrondir à un nombre de chiffre après la virgule bien déterminé.

Opérateurs logiques booléens

Les opérateurs logiques agissent sur les types booléens (true ou false).

•  ! : négation. Transforme false en true et true en false.
• && : opérateur "et".
• and : opérateur "et" de moindre priorité.
• || : opérateur "ou"
• or : opérateur "ou" de moindre priorité.

Opérateurs logiques bit à bit

Les opérateurs logiques bit à bit agissent sur chaque bit des valeurs entières.

• ~ Négation : 0 -> 1 et 1 -> 0
• & Opérateur et (and)
• | Opérateur ou (or)
• ^ Opérateur ou exclusif (xor)

Opérateur d'assignation

Ils permettent de simplifier l'écriture des assignations.

• += additionne deux valeurs et stocke le résultat dans la variable ($x+=5 équivaut à $x=$x+5)
• -= soustrait deux valeurs et stocke le résultat dans la variable ($x-=5 équivaut à $x=$x-5)
• *= multiplie deux valeurs et stocke le résultat dans la variable ($x*=5 équivaut à $x=$x*5)
• /= divise deux valeurs et stocke le résultat dans la variable ($x/=5 équivaut à $x=$x/5)
•  %= donne le reste de la division de deux valeurs et stocke le résultat dans la variable ($x%=5 équivaut à $x=$x%5)
• |= effectue un OU logique entre deux valeurs et stocke le résultat dans la variable ($x|=5 équivaut à $x=$x|5)
• ^= effectue un OU exclusif entre deux valeurs et stocke le résultat dans la variable ($x^=5 équivaut à $x=$x^5)
• &= effectue un ET logique entre deux valeurs et stocke le résultat dans la variable ($x&=5 équivaut à $x=$x&5)
• .= concatène deux chaînes et stocke le résultat dans la variable ($x.='test' équivaut à $x=$x.'test')

Opérateur d'incrémentation

• ++ : incrémente de 1 la valeur de la variable si "$x=1", "$x++" vaut "++$x" qui vaut "2".
• -- : décrémente de 1 la valeur de la variable si "$x=2", "$x--" vaut "--$x" qui vaut "1".

Ces opérateurs sont très utiles dans les boucles (notamment for).

Opérateur de comparaison

• == renvoie un booléen pour indiquer l'égalité (ce n'est pas =) : $x == 1 teste si la valeur $x est égale à 1.
• === renvoie un booléen pour indiquer à l'identique, c'est-à-dire l'égalité à la fois de la valeur et du type.
•  != (alias <>) renvoie un booléen pour indiquer la différence : $x != 1 teste si la valeur $x est différente de 1.
•  !== renvoie un booléen pour indiquer la différence ou de la valeur ou du type.
• > renvoie un booléen pour indiquer la supériorité stricte si $x > 1 teste si la valeur $x est strictement supérieure à 1.
• < renvoie un booléen pour indiquer l'infériorité stricte : $x < 1 teste si la valeur $x est strictement inférieure à 1.
• >= renvoie un booléen pour indiquer la supériorité-égalité si $x >= 1 teste si la valeur $x est supérieure ou égale à 1.
• <= renvoie un booléen pour indiquer l'infériorité-égalité si $x <= 1 teste si la valeur $x est inférieure ou égale à 1.
• <=>^[3] renvoie 1 si le premier opérande est supérieur, 0 s'il est égal, et -1 s'il est inférieur au deuxième.

{{{1}}}

Opérateur divers

$appreciation = ($note>10) ? "bon" : "mauvais";

if ($note>10)
$appreciation="bon";
else
$appreciation="mauvais";

if ($note > 10) {
    $appreciation = "bon";
} else {
    $appreciation = "mauvais";
}

print 1 ?: 0;
// 1

print 'Un est plus ' . (1 > 2
    ? ' grand'
    : ' petit'
). ' que deux.';

print $voiture->couleur;
$voiture->repeindre('bleu');

print $voiture::couleur;

print 1/0; //Warning: Division by zero, puis INF

print @(1/0); // INF

public function archive(&$db)
{
    var_dump($db);
}

public function somme(...$nombres)
{
    $somme = 0;
    foreach ($nombres as $n) {
        $somme += $n;
    }
    return $somme;
}

echo somme(1, 2, 3);
echo somme(1, 2, 3, 4);

Précédence des opérateurs

Quand une opérande est entourée de deux opérateurs (ex : 1 + 2 * 3 = 7), des règles de priorités s'appliquent systématiquement pour résoudre les opérations^[7].

Références