• + : 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 :

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

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.

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

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.

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).

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)

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.

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é.

•  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).

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.

•  @  : 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