Vous êtes ici :
Accueil Cours Programmations La base du langage PHP Les opérateurs

La base du langage PHP : Les opérateurs

Un opérateur est quelque chose qui prend une ou plusieurs valeurs (ou expressions, dans le jargon de la programmation) et qui retourne une autre valeur (donc la construction elle-même devient une expression).

Les opérateurs peuvent être regroupés en fonction du nombre de valeurs qu'ils acceptent. L'opérateur unaire n'opère que sur une seule valeur, par exemple ! (l'opérateur de négation) ou ++ (l'opérateur d'incrémentation). Le second type, les opérateurs binaires (comme le très célèbre opérateur mathématique + ou -) contient la plupart des opérateurs supportés par PHP. Enfin, l'opérateur ternaire, ? :, qui accepte trois valeurs (on peut aussi l'appeler l'opérateur conditionnel).

Une liste complète des opérateurs se trouve dans la section précédence des opérateurs. Cette section explique aussi la précédence des opérateurs et l'associativité, c'est à dire les priorités d'exécution des opérateurs.

Les opérateurs arithmétiques

Vous rappelez-vous des opérations élémentaires apprises à l'école ? Les opérateurs arithmétiques fonctionnent comme elles.

arithmétiques fonctionnent comme elles.

Opérations élémentaires
Exemple Nom Résultat
-$a Négation Opposé de $a.
$a + $b Addition Somme de $a et $b.
$a - $b Soustraction Différence de $a et $b.
$a * $b Multiplication Produit de $a et $b.
$a / $b Division Quotient de $a et $b.
$a % $b Modulo Reste de $a divisé par $b.
$a ** $b Exponentielle Résultat de l'élévation de $a à la puissance $b. Introduit en PHP 5.6.

 

L'opérateur de division ("/") retourne une valeur à virgule flottante sauf si les 2 opérandes sont des entiers (ou une chaîne de caractères qui a été convertie en entiers) et que leur division est exacte (i.e. a pour reste 0), auquel cas une valeur entière sera retournée.

Les opérandes du modulo sont converties en entiers (en supprimant la partie décimale) avant exécution.

Le résultat de l'opération modulo % a le même signe que le premier opérande, ansi le résultat de $a % $b aura le signe de $a. Par exemple:

<?php

echo (5 % 3)."\n";           // affiche 2
echo (5 % -3)."\n";          // affiche 2
echo (-5 % 3)."\n";          // affiche -2
echo (-5 % -3)."\n";         // affiche -2

?> 

 

Les opérateurs d'affectation

L'opérateur d'affectation le plus simple est le signe "=". Le premier réflexe est de penser que ce signe veut dire "égal à". Ce n'est pas le cas. Il signifie que l'opérande de gauche se voit affecter la valeur de l'expression qui est à droite du signe égal.

La valeur d'une expression d'affectation est la valeur affectée. Par exemple, la valeur de l'expression '$a = 3' est la valeur 3. Cela permet d'utiliser des astuces telles que :

<?php
$a = ($b = 4) + 5;
// $a est maintenant égal à 9, et $b vaut 4.
?> 

 

Pour les arrays, affecter une valeur à une clé donnée est effectué au moyen de l'opérateur "=>". La précédence de cet opérateur est la même que celle des opérateurs d'affectation.

En plus du simple opérateur d'affectation, il existe des "opérateurs combinés" pour tous les opérateurs arithmétiques, l'union de tableaux et pour les opérateurs sur les chaînes de caractères. Cela permet d'utiliser la valeur d'une variable dans une expression et d'affecter le résultat de cette expression à cette variable. Par exemple :

<?php
$a = 3;
$a += 5; // affecte la valeur 8 à la variable $a correspond à l'instruction '$a = $a + 5';
$b = "Bonjour ";
$b .= " tout le monde!";  /* affecte la valeur "Bonjour 
tout le monde!" à la variable $b
 identique à $b = $b." tout le monde!";
*/
?> 

 

On peut noter que l'affectation copie le contenu de la variable originale dans la nouvelle variable (affectation par valeur), ce qui fait que les changements de valeur d'une variable ne modifieront pas la valeur de l'autre. Cela peut se révéler important lors de la copie d'un grand tableau durant une boucle.

Une exception au comportement d'affectation par valeur en PHP est le type object, ceux-ci sont affectés par référence dans PHP 5. La copie d'objet doit être explicitement demandée grâce au mot-clé clone.

  • Affectation par référence

L'affectation par référence est aussi supportée, au moyen de la syntaxe "$var = &$othervar;". L'affectation par référence signifie que les deux variables pointent vers le même conteneur de donnée, rien n'est copié nulle part.

 

Exemple #1 Affectation par référence

<?php
$a = 3;
$b = &$a; // $b est une référence à $a

print "$a\n"; // affiche 3
print "$b\n"; // affiche 3

$a = 4; // change $a

print "$a\n"; // affiche 4
print "$b\n"; // affiche 4 aussi, car $b est une référence à $a, qui a été
              // changée
?> 

Depuis PHP 5, l'opérateur new retourne une référence automatiquement, donc affecter le résultat de new par référence retournera une erreur E_DEPRECATED depuis PHP 5.3, et une erreur de niveau E_STRICT avant PHP 5.3.

Par exemple, ce code génère un message d'erreur:

<?php
class C {}

/* La ligne suivante génère une erreur dont le message est:
 * Deprecated: Assigning the return value of new by reference is deprecated in...
 */
$o = &new C;
?> 

Opérateurs de comparaison

Les opérateurs de comparaison, comme leur nom l'indique, vous permettent de comparer deux valeurs. Vous devriez également être intéressés par les tables de comparaisons de types, car ils montrent des exemples de beaucoup de types de comparaisons.

Opérateurs de comparaison
Exemple Nom Résultat
$a == $b Egal TRUE si $a est égal à $b après le transtypage.
$a === $b Identique TRUE si $a est égal à $b et qu'ils sont de même type.
$a != $b Différent TRUE si $a est différent de $b après le transtypage.
$a <> $b Différent TRUE si $a est différent de $b après le transtypage.
$a !== $b Différent TRUE si $a est différent de $b ou bien s'ils ne sont pas du même type.
$a < $b Plus petit que TRUE si $a est strictement plus petit que $b.
$a > $b Plus grand TRUE si $a est strictement plus grand que $b.
$a <= $b Inférieur ou égal TRUE si $a est plus petit ou égal à $b.
$a >= $b Supérieur ou égal TRUE si $a est plus grand ou égal à $b.
$a <=> $b Opérateur combiné Un entier inférieur, égal ou supérieur à zéro lorsque $a est respectivement inférieur, égal, ou supérieur à $b. Disponible depuis PHP 7.
$a ?? $b ?? $c Opérateur d'union nul Retourne la première opérande depuis la gauche vers la droite qui existe, et différent de NULL. Si rien n'existe, NULL sera retourné. Disponible depuis PHP 7.

 

Si vous comparez un nombre avec une chaîne ou bien que la comparaison implique des chaînes numériques, alors chaque chaîne sera convertie en un nombre et la comparaison sera effectuée numériquement. Ces règles s'appliquent également à l'instruction switch. La conversion de type n'intervient pas lorsque la comparaison est === ou !== vu que ceci engendre aussi bien une comparaison de type que de valeur.

<?php
var_dump(0 == "a"); // 0 == 0 -> true
var_dump("1" == "01"); // 1 == 1 -> true
var_dump("10" == "1e1"); // 10 == 10 -> true
var_dump(100 == "1e2"); // 100 == 100 -> true

switch ("a") {
case 0:
    echo "0";
    break;
case "a": // jamais évalué parce que "a" est déjà trouvé avec 0
    echo "a";
    break;
}
?> 
<?php  
// Entiers
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1
 
// Nombre flottants
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1
 
// Chaines de caractères
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
 
echo "a" <=> "aa"; // -1
echo "zz" <=> "aa"; // 1
 
// Tableaux
echo [] <=> []; // 0
echo [1, 2, 3] <=> [1, 2, 3]; // 0
echo [1, 2, 3] <=> []; // 1
echo [1, 2, 3] <=> [1, 2, 1]; // 1
echo [1, 2, 3] <=> [1, 2, 4]; // -1
 
// Objets
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 0
 
$a = (object) ["a" => "b"]; 
$b = (object) ["a" => "c"]; 
echo $a <=> $b; // -1
 
$a = (object) ["a" => "c"]; 
$b = (object) ["a" => "b"]; 
echo $a <=> $b; // 1
 
// seulement les valeurs sont comparées
$a = (object) ["a" => "b"]; 
$b = (object) ["b" => "b"]; 
echo $a <=> $b; // 1

?> 

 

Pour les différents types, la comparaison est faite en suivant la table suivante (dans l'ordre).

 

Comparaison avec plusieurs types
Type de l'opérande 1 Type de l'opérande 2 Résultat
null ou chaîne de caractères string Convertit NULL en "", comparaison numérique ou lexicale
booléen ou null N'importe quoi Convertit en booléen, FALSE < TRUE
objet objet Les classes internes peuvent définir leur propre méthode de comparaison; différentes classes ne sont pas comparables; entre objets de même classe, PHP a son propre comportement
chaîne de caractères, ressource ou nombre chaîne de caractères, ressource ou nombre Transforme les chaînes de caractères et les ressources en nombres
tableaux tableaux Le tableau avec le moins de membres est plus petit, si la clé de l'opérande 1 n'est pas trouvée dans l'opérande 2, alors les tableaux ne sont pas comparables, sinon la comparaison se fait valeur par valeur (voir l'exemple suivant)
object N'importe quoi L'objet est toujours plus grand
array N'importe quoi Le tableau est toujours plus grand

 

Exemple #1 Comparaison Booléen/null

<?php
// Boolén et null sont toujours comparés comme des booléens
var_dump(1 == TRUE);  // TRUE - identique à (bool)1 == TRUE
var_dump(0 == FALSE); // TRUE - identique à (bool)0 == FALSE
var_dump(100 < TRUE); // FALSE - identique à (bool)100 < TRUE
var_dump(-10 < FALSE);// FALSE - identique à (bool)-10 < FALSE
var_dump(min(-100, -10, NULL, 10, 100)); // NULL - (bool)NULL < (bool)-100 est identique à FALSE < TRUE
?> 

Exemple #2 Transcription des comparaisons standards des tableaux

<?php
// Les tableaux sont comparés comme ceci avec les opérateurs standards de comparaison
function standard_array_compare($op1, $op2)
{
   if (count($op1) < count($op2)) {
      return -1; // $op1 < $op2
   } elseif (count($op1) > count($op2)) {
      return 1; // $op1 > $op2
   }
   foreach ($op1 as $key => $val) {
      if (!array_key_exists($key, $op2)) {
         return null; // incomparable
      } elseif ($val < $op2[$key]) {
         return -1;
      } elseif ($val > $op2[$key]) {
         return 1;
      }
   }
   return 0; // $op1 == $op2
}
?> 

 

  • L'opérateur ternaire

Un autre opérateur conditionnel est l'opérateur ternaire ("?:").

Exemple #3 Affectation d'une valeur par défaut

<?php
// Exemple d'utilisation pour l'opérateur ternaire
$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];

// La ligne ci-dessus est identique à la condition suivante :
if (empty($_POST['action'])) {
   $action = 'default';
} else {
   $action = $_POST['action'];
}

?> 

 

L'expression (expr1) ? (expr2) : (expr3) est évaluée à expr2 si expr1 est évaluée à TRUE, et expr3 si expr1 est évaluée à FALSE.
Depuis PHP 5.3, il est possible d'omettre la partie centrale de l'opérateur ternaire. L'expression
expr1 ?: expr3 retourne expr1 si expr1 vaut TRUE, et expr3 sinon.
 

Note: Notez que l'opérateur ternaire est une expression, et il n'est pas évalué en tant que variable, mais en tant que résultat de l'expression. Il est important de le savoir si vous voulez retourner une variable par référence. L'instruction return $var == 42 ? $a : $b; dans une fonction retournée par référence ne fonctionnera donc pas et une alerte est émise.

Note:

Il est recommandé de ne pas "empiler" les expressions ternaires. Le comportement de PHP lors de l'utilisation de plus d'un opérateur ternaire dans une seule instruction n'est pas évident :

Exemple #4 Comportement de PHP

<?php
// A première vue, ce qui suit devrait retourner 'true'
echo (true?'true':false?'t':'f');

// cependant, l'expression ci-dessus retournera 't'
// car l'expression ternaire est évaluée de gauche à droite

// l'expression suivante est une version plus évidente du même code
echo ((true ? 'true' : false) ? 't' : 'f');

// ici, vous pouvez voir que la première expression est évaluée à 'true',
// ce qui fait qu'elle est évaluée à (bool)true, ce qui retourne la branche
// 'vraie' de la seconde expression ternaire.
?> 

 

Opérateur de contrôle d'erreur

PHP supporte un opérateur de contrôle d'erreur : c'est @. Lorsque cet opérateur est ajouté en préfixe d'une expression PHP, les messages d'erreur qui peuvent être générés par cette expression seront ignorés.

Si vous avez défini un gestionnaire d'erreurs personnalisé avec la fonction set_error_handler(), alors il sera toujours appelé, mais ce gestionnaire d'erreurs peut (et doit) appeler la fonction error_reporting() qui devra retourner 0 lorsque l'appel qui a émis l'erreur était précédé d'un @.

Si l'option track_errors est activée, les messages d'erreurs générés par une expression seront sauvés dans la variable globale $php_errormsg. Cette variable sera écrasée à chaque erreur. Il faut alors la surveiller souvent pour pouvoir l'utiliser.

<?php
/* Erreur intentionnelle (le fichier n'existe pas): */
$mon_fichier = @file ('non_persistent_file') or
    die ("Impossible d'ouvrir le fichier : L'erreur est : '$php_errormsg'");

// Cela fonctionne avec n'importe quelle expression, pas seulement les fonctions
  $value = @$cache[$key];
// la ligne ci-dessus n'affichera pas d'alerte si la clé $key du tableau n'existe pas

?> 

Note: L'opérateur @ ne fonctionne qu'avec les expressions. La règle générale de fonctionnement est la suivante : si vous pouvez prendre la valeur de quelque chose, vous pouvez le préfixer avec @. Par exemple, vous pouvez ajouter @ aux variables, fonctions, à include, aux constantes, etc. Vous ne pourrez pas le faire avec des éléments de langage tels que les classes, if et foreach, etc.

Avertissement :

En fait, l'opérateur "@" va aussi désactiver les rapports d'erreurs critiques, qui stoppent l'exécution du script. Entre autres, si vous utilisez "@" pour supprimer les erreurs de certaines fonctions, et que cette fonction n'existe pas, ou qu'elle a été mal orthographiée, vous n'aurez aucune indication.




Vous êtes ici :
Accueil Cours Programmations La base du langage PHP Les opérateurs