Les opérateurs prennent des valeurs (les opérandes) et réalisent des opérations avec elles.
Beaucoup d'opérateurs attendent des types de données particuliers. Par exemple les opérateurs arithmétiques attendent des nombres. Si les opérandes ne sont pas des types attendus, PHP prend en charge automatiquement les conversions de types (type juggling).

### Les opérateurs arithmétiques

- + : addition
- - : soustraction
- * : multiplication
- / : division
- % : modulo (reste d'une division)

Les opérateurs arithmétiques attendent normalement des nombres (entiers ou à virgule flottante). Les régles de conversion suivantes sont appliquées :

Premier opérande | Second opérande | Conversion | Résultat
Entier | Entier | Aucune | Entier (sauf pour les divisions et le modulo, où le résultat peut être un nombre à virgule flottante
Virgule | Virgule | Aucune | Nombre à virgule flottante
Entier | Virgule | L'entier est converti en un nombre à virgule flottante. | Nombre à virgule flottante.
Entier | Chaîne | La chaîne est convertie en un nombre. Si ce nombre est à virgule flottante, l'entier est converti en nombre à virgule flottante. | Entier ou nombre à virgule flottante.
Virgule | Chaîne | La chaîne est convertie en un nombre à virgule flottante. | Nombre à virgule flottante.
Chaîne | Chaîne | Les chaînes sont converties en nombre, puis éventuellement en nombres à virgule flottante. | Entier ou nombre à virgule flottante.

Conversion des chaînes en nombre :

- si la chaîne ne commence pas par un nombre, sa valeur est 0
- les nombres trouvés jusqu'au premier caractère non numérique forment la valeur numérique
- si la chaîne contient un point, ou le caractère E, le résultat est un nombre à virgule flottante.

Exemples :

- "abc" donnera 0
- "123abc" donnera l'entier 123
- "123.45" donnera le nombre à virgule flottante 123.45
- "123 abc." donnera le nombre à virgule flottante 123
- "1E3 abc" donnera le nombre à virgule flottante 1000

Exemple : opérateurs arithmétiques
<!DOCTYPE html> <html lang="fr"> <head><title>Opérateurs arithmétiques et transtypage</title> </head> <body> <?php $r = 10 + 10; echo '<hr>Resultat : ', $r, '<br>Type : ', gettype($r); $r = 10.0 + 10; echo '<hr>Resultat : ', $r, '<br>Type : ', gettype($r); $r = '10' + '10'; echo '<hr>Resultat : ', $r, '<br>Type : ', gettype($r); $r = '10.0' + 'françois'; echo '<hr>Resultat : ', $r, '<br>Type : ', gettype($r); $r = 10 + '10françois'; echo '<hr>Resultat : ', $r, '<br>Type : ', gettype($r); ?> </body> </html>

### Concaténation de chaînes

La concaténation de chaînes se fait avec l'opérateur . (point). Si nécessaire, les opérandes sont convertis automatiquement en chaînes.

Les chaînes peuvent être entourées de guillemets simples ou doubles. PHP traîtera différemment les chaînes suivant le type des guillemets :

- si la chaîne est entourée de guillemets simples, elle est évaluée tel que.
- si la chaîne est entourée de guillemets doubles, les variables éventuelles contenues dans la chaîne seront remplacées par leur valeur.

Je vous conseille d'utiliser des guillemets simples si vous n'avez pas de variables dans vos chaînes. De cette façon, PHP n'examinera pas la chaîne pour savoir si elle contient des variables à valoriser. Vous aurez beaucoup plus d'informations sur le sujet dans le chapitre consacré aux chaînes de caractères.

Exemple : concaténation de chaînes
<!DOCTYPE html> <html lang="fr"> <head><title>Concaténation de chaînes</title></head> <body> <?php $x = 'François'; $y = 'Piat'; $z = $x . ' ' . $y; echo $z; $z = "Mon nom est $y"; echo '<p>' . $z; echo "<p>Mon nom est $y, $x $y"; // guillemets doubles echo '<p>Mon nom est $y, $x $y'; // guillemets simples ?> </body> </html>

### Incrément et décrément

Les opérateurs d'autoincrément et d'autodécrément ne sont applicables qu'à des variables numériques ou alphanumériques.

Opérateur | Syntaxe |  | Résultat sur la variable | Valeur retournée
++ | $x ++ | post incrément | $x = $x + 1 | $x
| ++ $x | pré incrément | $x = $x + 1 | $x + 1
-- | $x -- | post décrément | $x = $x - 1 | $x
| -- $x | pré décrément | $x = $x - 1 | $x - 1

Exemple : incrément et décrément variables numériques
<html lang="fr"> <head><title>incrément et décrément</title></head> <body> <?php //====================================================== echo '<h3>Post incrément</h3>'; $x = 1; $x++; echo 'Exemple 1 : ', $x; //------------------------------------------------------ $x = 1; echo '<br>Exemple 2', '<br>valeur retournée : ', $x++, '<br>valeur de la variable : ', $x; //====================================================== echo '<h3>Pré incrément</h3>'; $x = 1; ++$x; echo 'Exemple 1 : ', $x; //------------------------------------------------------ $x = 1; echo '<br>Exemple 2', '<br>valeur retournée : ', ++$x, '<br>valeur de la variable : ', $x; ?> </body> </html>
Exemple : incrément et décrément variables alphanumériques
<html lang="fr"> <head><title>incrément et décrément</title></head> <body> <?php //====================================================== echo '<h3>Variables alphanumériques</h3>'; $x = 'a'; $x++; echo '<hr>Incrément de a : ', $x; //------------------------------------------------------ $x = 'abcd'; $x++; echo '<hr>Incrément de abcd : ', $x; //------------------------------------------------------ $x = 'abcz'; $x++; echo '<hr>Incrément de abcz : ', $x; //------------------------------------------------------ $x = 'K7'; $x++; echo '<hr>Incrément de K7 : ', $x; //------------------------------------------------------ $x = 'K9'; $x++; echo '<hr>Incrément de K9 : ', $x; ?> </body> </html>

### Opérateurs d'assignement

Ces opérateurs donnent une valeur, ou modifient la valeur d'une variable. L'assignement peut être simple ou avec opération.

- = : une valeur est assignée.

  $x = 10; $x contient la valeur 10
  $x = $y = 10; $y contient la valeur 10 puis la valeur de $y est affectée à $x
  $x = $y + $z; $x contient le résultat de l'addition de $y et $z

- .= : concaténation de chaînes de caractères. L'opérande de droite est ajouté à la suite de l'opérande de gauche qui reçoit le résultat.

  $x = 'François';
  $x .= ' Piat';
  $x contient 'François Piat'

- += : ajoute l'opérande de droite à l'opérande de gauche qui reçoit le résultat.

  $x += 5 est identique à $x = $x + 5

- -= : soustrait l'opérande de droite de l'opérande de gauche qui reçoit le résultat.

  $x -= 5 est identique à $x = $x - 5

- /= : divise l'opérande de gauche par l'opérande de droite, puis assigne le résultat à l'opérande de gauche.

  $x /= 5 est identique à $x = $x / 5

- *= : multiplie l'opérande de gauche par l'opérande de droite, puis assigne le résultat à l'opérande de gauche.

  $x *= 5 est identique à $x = $x * 5

- %= : divise l'opérande de gauche par l'opérande de droite, puis assigne le reste de la divison à l'opérande de gauche.

  $x %= 5 est identique à $x = $x % 5

- ^= : opération de bit XOR sur les opérandes. Le résultat est affecté à l'opérande de gauche.
- &= : opération de bit AND sur les opérandes. Le résultat est affecté à l'opérande de gauche.
- |= : opération de bit OU sur les opérandes. Le résultat est affecté à l'opérande de gauche.

Exemple : opérateurs d'assignement
<!DOCTYPE html> <html lang="fr"> <head><title>Opérateurs d'assignement</title></head> <body> <?php $x = 'François'; echo '<hr>Valeur de $x après affectation : ', $x; $x .= ' Piat'; echo '<hr>Valeur de $x après concaténation : ', $x; $x = 10; echo '<hr>Valeur de $x après affectation : ', $x; $x += 10; echo '<hr>Valeur de $x après addition : ', $x; $x /= 5; echo '<hr>Valeur de $x après division : ', $x; $x -= 4; echo '<hr>Valeur de $x après soustraction : ', $x; ?> </body> </html>

### Opérateurs de bits

Ces opérateurs travaillent sur la représentation binaire des opérandes.

- $a & $b : AND (les bits positionnés à 1 dans $a ET dans $b sont positionnés à 1).
- $a | $b : OR (les bits positionnés à 1 dans $a OU $b sont sont positionnés à 1).
- $a ^ $b : XOR (les bits positionnés à 1 dans $a OU dans $b sont positionnés à 1).
- ~ $a : NOT (les bits qui sont positionnés à 1 dans $a sont positionnés à 0, et vice versa).
- $a << $b : décale les bits de $a dans $b par la gauche (chaque décalage équivaut à une multiplication par 2).
- $a >> $b : décalage des bits de $a dans $b par la droite (chaque décalage équivaut à une division par 2).

### Opérateurs de comparaison

Ces opérateurs comparent des opérandes de n'importe quel type et renvoient la valeur true ou la valeur false.

- == : égalité (les opérandes ont la même valeur, avec transtypage automatique pour la comparaison si les opérandes ne sont pas de même type)
- === : identité (les opérandes sont du même type et ont la même valeur).
- != ou <> : différence (les opérandes n'ont pas la même valeur, avec transtypage automatique pour la comparaison si les opérandes ne sont pas de même type)
- !== : non identique (les opérandes ne sont pas du même type ou ont une valeur différente).
- > : plus grand que (le premier opérande est strictement plus grand que le second, avec transtypage automatique pour la comparaison si les opérandes ne sont pas de même type)
- >= : plus grand ou égal (le premier opérande est plus grand ou égal au second, avec transtypage automatique pour la comparaison si les opérandes ne sont pas de même type)
- < : plus petit que (le premier opérande est strictement plus petit que le second, avec transtypage automatique pour la comparaison si les opérandes ne sont pas de même type)
- <= : plus petit ou égal (le premier opérande est plus petit ou égal au second, avec transtypage automatique pour la comparaison si les opérandes ne sont pas de même type)

Premier opérateur | Second opérateur | Type de comparaison
Numérique | Numérique | Numérique
Chaîne entiérement numérique | Chaîne entiérement numérique | Numérique
Chaîne entiérement numérique | Numérique | Numérique
Chaîne non entiérement numérique | Numérique | Numérique
Chaîne non entiérement numérique | Chaîne entiérement numérique | Lexicale
Chaîne non entiérement numérique | Chaîne non entiérement numérique | Lexicale

Conclusion : si vous comparez un nombre avec une chaîne ou si la comparaison implique deux chaînes numériques, alors chaque chaîne sera convertie en un nombre et la comparaison sera effectuée numériquement.

Exemple : opérateur de comparaison - égalité et identité
<!DOCTYPE html> <html lang="fr"> <head><title>Opérateur de comparaison</title></head> <body> <?php comparerVariables(1, 1); comparerVariables(2.0, 2); comparerVariables("3", 3); comparerVariables("4 rue des alouettes", 4); comparerVariables("4 rue des alouettes", '4'); comparerVariables(1, true); comparerVariables('true', true); comparerVariables('false', false); //------------------------------------------------------ function comparerVariables($x, $y) { echo '<hr>x contient ', $x, ' et y contient ', $y; if ($x == $y) { echo '<br>x est égal à y'; } else { echo '<br>x est différent de y'; } if ($x === $y) { echo '<br>x est identique à y'; } else { echo '<br>x n\'est pas identique à y', '<br>x est du type ' ,gettype($x), '<br>y est du type ', gettype($y); } } ?> </body> </html>

Comme vous pouvez le remarquer certaines égalités peuvent sembler étranges quand on est habitué à travailler avec des langages fortement typé.
On notera par exemple que la chaîne 'true' est égale au booléen true, mais que la chaîne 'false' n'est pas égale au booléen false. Si on peut admettre que la chaîne '3' soit égale au nombre 3, il est plus difficile de se figurer que la chaîne '4 rue des alouettes" est égale au nombre 4.
Soyez donc attentif quand vous faites des tests aux transtypages automatiques qui sont faits par PHP pour comparer des valeurs.
Si vous voulez faire des tests "forts", utilisez les opérateurs d'indentité et pas simplement les opérateurs d'égalité.

### Opérateurs logiques

- AND ou && : le résultat est true si les 2 opérandes sont évalués comme true. A partir du moment où un des opérandes est évalué à false, les opérandes suivants ne sont pas évalués, et le résultat est false.

  Dans $r = $a AND $b $r sera égal à true si $a ET $b sont évalués comme true.

  Dans if ( $a == 0 && $b > 1) ... le test sera vrai si $a est égal à 0 ET $b est supérieur à 1.

- OR ou || : le résultat est true si un des 2 opérandes est évalué comme true. A partir du moment où un des opérandes est évalué comme true, les opérandes suivants ne sont pas évalués, et le résultat est true.

  Dans $r = $a OR $b $r sera égal à true si $a est évalué comme true, OU si $b est évalués comme true.

  Dans if ( $a == 0 || $b > 1) ... le test sera vrai si $a est égal à 0 OU si $b est supérieur à 1.

- XOR : le résultat est true si et seulement si un seul des deux opérandes est évalué comme true.
- ! : négation (le résultat est true si l'opérande est évalué comme false).

Exemple : opérateurs logiques
<!DOCTYPE html> <html lang="fr"> <head><title>Opérateurs logiques</title></head> <body> <?php $x = 1; $y = 2; //------------------------------------------------------ echo '<h3>Opérateur AND</h3>'; if ($x == 1 && $y == 2) { echo 'vrai'; } else { echo 'faux'; } //------------------------------------------------------ echo '<h3>Opérateur OR</h3>'; if ($x == 1 || $y == 3) { echo 'vrai'; } else { echo 'faux'; } //------------------------------------------------------ echo '<h3>Opérateur XOR</h3>'; if ($x == 1 XOR $y == 3) { echo 'vrai'; } else { echo 'faux'; } //------------------------------------------------------ echo '<h3>Opérateur !</h3>'; if (!$x) { echo 'vrai'; } else { echo 'faux'; } ?> </body> </html>

### Opérateurs de type

Bien que PHP soit un langage sans définition de type des variables, des opérateurs permettent de forcer le type d'une variable.

- (int) ou (integer) : la variable devient un entier.
- (float) ou (real) : la variable devient un nombre à virgule flottante.
- (string) : la variable devient une chaîne de caractères.
- (bool) ou (boolean) : la variable devient un booléen.
- (array) : la variable devient un tableau.
- (object) : la variable devient un objet.

Toutes les conversions ne sont pas utiles. Par exemple, transformer un tableau en numérique donne comme résultat 1, le transformer en chaîne donne "array".

Transformer un objet en tableau donne un tableau associatif : nom de propriété associé à la valeur de la propriété.

Transformer un tableau en objet donnera un objet dont les propriétés seront les valeurs du tableau.

Exemple : opérateurs de type
<!DOCTYPE html> <html lang="fr"> <head><title>Opérateurs de type</title></head> <body> <?php $x = 'Piat'; echo '<hr>Variable = ', $x, '<br>type : ', gettype($x); $x = (int) $x; echo '<hr>Variable = ', $x, '<br>type : ', gettype($x); $x = '1.23'; echo '<hr>Variable = ', $x, '<br>type : ', gettype($x); $x = (double) $x; echo '<hr>Variable = ', $x, '<br>type : ', gettype($x); $x = (int) $x; echo '<hr>Variable = ', $x, '<br>type : ', gettype($x); $x = array('pre' => 'François', 'nom' => 'Piat'); $x = (object) $x; echo '<hr>Tableau en objet<br>', $x->pre, '<br>', $x->nom; $x->pre = 'Pierre'; $x->nom = 'Dupont'; $x = (array) $x; echo '<hr>Objet en tableau<pre>'; print_r($x); ?> </body> </html>

### Autres opérateurs

- @ : lorsque cet opérateur est ajouté en préfixe d'une expression PHP, les messages d'erreur qui pourraient être générés par cette expression ne seront pas affichés.
- `..` : exécution de la chaîne comprise entre les guillemets obliques, comme une commande système.
- ? : : opérateur de test conditionnel.
  Syntaxe :
  (test) ? valeur_si_vrai : valeur_si_faux
  (test) ? instruction_si_vrai : instruction_si_faux

Exemple : opérateur d'erreur
<!DOCTYPE html> <html lang="fr"> <head><title>Opérateur d'erreur</title></head> <body> <?php echo '<hr>Erreur avec message PHP<hr>'; // L'instruction suivante provoque une erreur, // avec l'affichage d'un message. $x = file('lefichier'); echo '<hr>Erreur sans message<hr>'; // L'instruction suivante provoque une erreur, // aucun message n'est affiché. $x = @file('lefichier'); echo '<hr>Erreur avec message personnalisé<hr>'; // L'instruction suivante provoque une erreur. // Le message d'erreur est personnalisé $x = @file('lefichier') or print("Impossible d'ouvrir le fichier"); ?> </body> </html>
Exemple : opérateur conditionnel
<!DOCTYPE html> <html lang="fr"> <head><title>Opérateur conditionnel</title></head> <body> <?php $seconde = date('s'); echo 'Seconde = ', $seconde; //------------------------------------------------------- // Affichage paire/impaire avec un if if ($seconde % 2 == 0) { echo '<hr>paire'; } else { echo '<hr>impaire'; } //------------------------------------------------------- // Affichage paire/impaire avec operateur conditionnel // 1ere façon $x = ($seconde % 2 == 0) ? 'paire' : 'impaire'; echo '<hr>', $x; //------------------------------------------------------- // 2eme façon echo '<hr>',($seconde % 2 == 0) ? 'paire' : 'impaire'; ?> </body> </html>