Exercices
Questions à choix multiple

Leçon N° 03 : Opérateurs

Introduction
Opérateurs d'incrémentation/décrémentation
Opérateurs d'affectation
Opérateurs arithmétiques
Opérateurs de comparaison
Opérateurs binaires
Opérateurs de décalage de bits
Opérateurs logiques
Opérateurs sur du texte
L'opérateur ? :
Ordre d'exécution des opérateurs
Opérateur de contrôle d'erreur
Opérateur d'introduction de commentaires
Opérateur de suppression d'interpolation
Testez un opérateur
Notes de page

Introduction

Un opérateur est un symbole qui indique à PHP qu'il doit effectuer une opération. Cette opération, réalisée souvent à l’aide d’une ou de plusieurs variables peut être de deux sortes:
    Soit l’opération modifie la valeur de la ou des variables, soit elle ne les modifie pas.
  1. La valeur des variables est modifiée
  2. La valeur des variables n’est pas modifiée
  3. Autres
PHP dispose des opérateurs classiques du C ainsi que d'autres inspirés du Perl.

Opérateurs d'incrémentation/décrémentation

OpérateurNomRésultat
++$aPré-incrément Incrémente $a d'un, puis renvoie $a.
$a++Post-incrément Renvoie $a, puis incrémente $a de un.
--$aPré-décrément Décrémente $a d'un, puis renvoie $a.
$a--Post-décrément Renvoie $a, puis décrémente $a d'un.
PHP supporte les opérateurs d'incrémentation/décrémentation issus du langage C :.
L'incrémentation (mais pas la décrémentation) fonctionne aussi avec des lettres ou des valeurs lettres/chiffres :
<?php
$x = "A";
$x++;
echo $x; // va retourner B (et ainsi de suite..)
?>
Exemples et exercices avec ++ ou --
Nom du fichier : exercises_03/lesson_03_increment.php

Opérateurs d'affectation

OpérateurSignification
=affectation simple
+=addition puis affectation
-=soustraction puis affectation
*=multiplication puis affectation
/=division puis affectation
%=modulo puis affectation
|=ou puis affectation
&=et puis affectation
=>associe une valeur à une clé dans un tableau (voir leçon 5)
->réalise un appel de méthode (voir leçon 8)
Exemple : Soient les opérations successives sur $n
<?php $n = 3; $n += 2; // équivaut à $n = $n + 2 --> $n vaut 5 $n *= 6; // équivaut à $n = $n * 6 --> $n vaut 30 $n %= 5; // équivaut à $n = $n % 5 --> $n vaut 0 car 30 est divisible par 5. ?>
Autre exemple sur les opérateurs d'affectation
Nom du fichier : exercises_03/lesson_03_affectation.php

Opérateurs arithmétiques

OpérateurOpération
+addition
-soustraction
/division
*multiplication
%modulo
++incrément
(voir paragraphe "incrémentation/décrémentation ci-après)
--décrément
(voir paragraphe "incrémentation/décrémentation ci-après)
L'opérateur modulo (%) est très utilisé en PHP , principalement pour réaliser des tableaux d'éléments. Le principe est simple : si l'on veut imprimer un tableau de 200 éléments dur 4 colonnes, on va provoquer un renvoi à la ligne à chaque fois que le N° de l'élément que l'on imprime est divisible par 4, donc chaque fois que (N° de l'élément° % 4 = 0).
Exercice sur l'opérateur "Modulo"
Nom du fichier : exercises_03/lesson_03_modulo.php

Opérateurs de comparaison

Les opérateurs de comparaison sont utilisés dans les tests. Vous trouverez ci-dessous, une liste d’opérateurs vous permettant de faire des tests de toutes sortes, notamment sur des variables.
Remarque 1 : Un test est une opération permettant d’obtenir la valeur ‘vrai ’ ou ‘faux’ à une proposition, ce qui est très utile. En fonction de la réponse fournie par le test, vous pouvez définir dans votre programme la marche à suivre que vous souhaitez.
Par exemple, la réponse ‘vrai’ entraînera l’affichage d’un message, et la réponse ‘faux’ entraînera l’ouverture d’une nouvelle page. Le chapitre suivant ‘Structures de contrôle ‘ reprendra en détail cette idée.
ExempleNomRésultat
$a == $bEgalVrai si les valeurs de $a et $b sont égales
Noter les DEUX signes "égale" à la suite : $a = = $b
$a === $bIdentiqueVrai si $a == $b et si $a et $b sont de même type.
Noter les TROIS signes "égale" à la suite : $a = = = $b (PHP 4)
$a != $bNon égalVrai si $a n'est pas égal à $b.
$a <> $bNon égalVrai si $a n'est pas égal à $b.
$a !== $bNon identiqueVrai si $a n'est pas égal à $b,
ou si $a et $b sont de types différents (PHP 4).
$a < $bPlus petit queVrai si $a est plus petit que $b.
$a > $bPlus grand queVrai si $a est plus grand que $b.
$a <= $bPlus petit ou égal àVrai si $a est plus petit ou égal à $b
$a >= $bPlus grand ou égal àVrai si $a est plus grand ou égal à $b.
Exemples :

<?php
if ($a == $b)
{
    echo " $a et $b sont égaux" ;
}
?>
<?php
if ($a === $b)
{
    echo " $a et $b sont égaux et du même type" ;
}
?>
Remarque 2 : On utilise ‘if‘ pour évoquer la possibilité. Si la proposition qui se trouve entre parenthèses après le ‘if’ est vraie, alors l’action décrite entre crochets est exécutée, si elle n’est pas vraie il ne se passe rien (‘else’ n’apparaît pas dans le programme).
Remarque 3 : Bien que, en principe on puisse insérer des espaces partout dans le code PHP, on ne peut pas insérer d'espace entre les différents caractères qui composent un opérateur.
Exercice sur les opérateurs de comparaison
Nom du fichier : exercises_03/lesson_03_compair_string.php
Exercice sur les opérateurs de comparaison (lié à la casse)
Nom du fichier : exercises_03/lesson_03_compair_case.php
Cas de contenu de même valeur mais de type différent
Nom du fichier : exercises_03/lesson_03_compair_type.php

Opérateurs binaires

Nous utilisons habituellement le système décimal, c'est-à-dire de base 10. Par exemple 863 peut s’écrire (8)x(10exp2) + (6)x(10exp1) + (3)x(10exp0), soit 800+60+3. Le système binaire n’utilise que le 0 ou le 1, prenons 010, ce nombre s’écrit aussi (0)x(2exp2) + (1)x(2exp1) + (0)x(2exp0), soit 0+2+0.

Définitions : dans un système binaire et pour un ordinateur on a 1 = vrai (= oui), 0 = faux(=non). De plus la négation de 0 est 1 et la négation de 1 est 0.
OpérateurAnglaisFrançaisRésultats
&ANDETMultiplication : 1&1=1; 1&0=0; 0&1=0; 0&0=0;
|OROUAddition : 1|1=1; 1|0=1; 0|1=1; 0|0=0;
^XOROU EXCLUSIFAddition : 1^1=0; 1^0=1; 0^1=1; 0^0=0;
~NOTNONNégation : ~1=0 ; ~0=1;
Effectuent des opérations "bit à bit" entre deux valeurs converties en binaire:
<?php
echo 3 & 6 ; // 0011 ET 0110 résultat : 0010 --> 2
echo ~ 3 ;   // NOT 3 => 3 en binaire = 011 si on inverse on obtient 100, et comme on inverse
		     // aussi le signe, on obtient  -4
echo 12 ^ 9; // donne '5' 
		 // 12 = 01100
		 // ^9 = 01001
		 // -----------
		 //      00101 = 5 
echo "12" ^ "9"; // donne le caractère Backspace (ascii 8)
		 // ('1' (ascii 49)) ^ ('9' (ascii 57)) = #8
		 //    1 1 0 0 0 1
		 // ^ 1 1 1 0 0 1
		 //----------------
		 //   0 0 1 0 0 0
?>
Exercices sur les opérateurs binaires
Nom du fichier : exercises_03/lesson_03_binary.php

Opérateurs de décalage de bit

Les opérateurs de décalage de bit (Bit shifting operators) semblent, au moins en PH4, préserver le signe, (le signe n'est pas affecté par le décalage), sauf que un 1 qui se décale vers le bit de signe (c'est à dire vers la gauche, de plus de 30 positions à partir de la droite) rend le nombre négatif, par contre il n' a pas de dépassement vers la droite, les "débordements" vers la droite sont sans effet.
OpérateurSignificationExempleSignification
<< Décalage vers la gauche 1 << 2 Décale la valeur 1 de 2 vers la gauche
>> Décalage vers la droite-3 >> 1 Décale la valeur -3 de 1 vers la droite
Exemples
<?php
echo ( 1 << 2 ); // 1 = 001
// 1 << 2 équivaut à 100 = 4
echo ( -1 << 2 ); // Renvoie -4
echo ( -3 >> 1 ); // Renvoie -2
echo ( 1 << 31 ); // Renvoie -2147483648 car on est allé jusqu'au bit de signe
<?php
L'opération de décalage à gauche est "rotative" (ce qui ressort de gauche ré-entre à droite) Mais l'opération de décalage à droite ne l'est pas
<?php
echo ( 1 << 0 ); // Renvoie 1
echo ( 1 << 4 ); // Renvoie 16
echo ( 1 << 32 ); // Renvoie 1
echo ( 1 << 36 ); // Renvoie 16 [36 = 32 + 4]
echo ( 3 >> 1 ); // Renvoie 1
echo ( 3 >> 2 ); // Renvoie 0
?>
Opérateurs de décalage de bit
Nom du fichier : exercises_03/lesson_03_bit_shift.php

Opérateurs logiques

Définition : pour être "vraie" une variable doit être non vide et différente de 0
Les opérateurs logiques peuvent être utilisés dans une proposition en utilisant deux variables. Dans ce genre d'opérations, on ne retient que l'état vrai ou faux des variables $a et $b.

Remarque 4 : Les fonctions ‘if’ et ‘else’, s’utilisent aussi avec les propositions logiques.
ExempleNom Résultat
$a and $b AndVrai si $a et $b sont vrais
S'exécute après le =
$a or $bOrVrai si $a, ou $b, ou les deux, sont vrais
S'exécute après le =
$a xor $bXorVrai si un et un seul parmi $a ou $b est vrai
! $a NotVrai si $a est faux
$a && $bAndVrai si $a et $b sont vrais.
S'exécute avant le =
$a || $bOrVrai si $a, ou $b, ou les deux, sont vrais
S'exécute avant le =
Exemples :
<?php if ($a and $b) // sous-entendu (($a and $b)==true) { echo " $a et $b sont tous les deux vrais (pas vides, différents de 0)" ; } ?>
Note: on voit que les opérateurs and et && d'une part, or et || d'autre part semblent avoir la même signification, en fait ils sont rarement interchangeables car ils n'ont pas le même rang dans l'ordre d'exécution des opérateurs :
Exemple avec "||" et "ou" donnant un résultat différent
Nom du fichier : exercises_03/lesson_03_priority.php

Opérateurs sur du texte

L'opérateur de concaténation . (le point) est utilisable sur les chaînes.
<?php $chaîne= "Votre nom est" ;
$nom= "Toto";
echo $chaîne . " " . $nom; // affiche "Votre nom est Toto"
?>
L'opérateur de concaténation et affectation .= (point et égale) est aussi utilisable sur les chaînes.
<?php
$a = "Hello ";
$a .= "World!"; /* va maintenant contenir "Hello World!"
et est équivalent à : $a = $a."World!" */
?>
L'art de la concaténation
Nom du fichier : exercises_03/lesson_03_text.php

L'opérateur ? :

L'opérateur ? : s'appelle aussi opérateur de test "trinaire".
Sa syntaxe est
[test logique] ? [expression si vrai] : [expression si faux]
<?php
$a= $b =1;
( $a == $b ) ? $c= 10 : $c = 20; // effectue $c = 10;
?>
On peut également l'utiliser pour compacter les séquence de test / affectations
<?php
$réponse = ( $a == $b ) ? "a égal b" : "a différent de b" ;
echo $réponse; // affiche "a égal b" car le test ( $a == $b ) renvoie vrai
?>
Note : Ne pas utiliser 'echo' mais 'print' après le ?
L'opérateur de test trinaire
Nom du fichier : exercises_03/lesson_03_trinary.php

Ordre d'exécution des opérateurs (operators precedence)

La préséance entre plusieurs opérateurs spécifie l'ordre dans lequel ces opérateurs s'exécutent.
Ainsi * s'exécute avant + donc 1 + 5 * 3 renvoie 16 et non 18. D'une façon générale les opérateurs de multiplication s'exécutent avant les additions et les "et" avant les "ou".
Associativité : Propriété d'une opération qui permet d'en regrouper les termes sans en changer le résultat.
Par convention, 9+5+2 est équivalent à (9+5)+2 et 9-5-2 est équivalent à (9-5)-2. Quand un opérande comme 5 a des opérateurs à sa gauche et à sa droite, des conventions sont nécessaires pour décider quel opérateur agit sur cet opérande. On dit que l'opérateur + est associatif à gauche car un opérande avec des signes plus de chaque côté est traité par l'opérateur situé à sa gauche. Dans la plupart des langages de programmation, les quatre opérateurs arithmétiques, addition, soustraction, multiplication et division, sont associatifs à gauche. Quelques opérateurs usuels comme l'exponentiation sont associatifs à droite. Mais en PHP il n'y a pas d'opérateur pour l'exponentiation, mais une fonction: pow
<?php
<?php
$a = 2 ;
$c = 4 ;
$d = pow($a,$c) ;
echo $d; // renvoie 16
?>
Ex : $a*$b*$c est équivalent à $a*($b*$c) et à ($a*$b)*$c
Il est recommandé d'utiliser plutôt les parenthèses pour "forcer" la priorité, sachant que dans tous les cas c'est le niveau le plus "intérieur" des parenthèses qui va s'exécuter en premier.
Ex: ((1 + 5) * 3) renverra 18.
Ex: (1 + (5 * 3)) renverra 16.

Priorité des opérateurs (Operator Precedence)

De la priorité la plus élevée à la priorité la moins élevée :

AssociativitéOpérateurs
non-associatifnew
droite[
droite! ~ ++ -- (int) (float) (string) (array) (object) @
gauche* / %
gauche+ - .
gauche<< >>
non-associatif< <= > >=
non-associatif== != === !==
gauche&
gauche^
gauche|
gauche&&
gauche||
gauche? :
gauche= += -= *= /= .= %= &= |= ^= ~= <<= >>=
droiteprint
gaucheand
gauchexor
gaucheor
gauche,

Opérateur de contrôle d'erreur

PHP supporte un opérateur de contrôle d'erreur : le symbole @ Quand une expression commence par ce symbole, aucune erreur générée par cette expression n'apparaîtra Si la mémorisation des erreurs est validée, elle sera néanmoins recensée dans la variable $php_errormsg., mais chaque nouveau message effacera l'ancien
<?php
/* on provoque volontairement une erreur */
$my_file = @file ('non_existent_file') or
die ("Fichier impossible à ouvrir, erreur : '$php_errormsg'");
// ceci fonctionne pour n'importe quelle expression, pas seulement pour les fonctions:
//l'expression suivante ne provoquera pas d'erreur, même si la cléf n'existe pas
$value = @$cache[$key];
?>
Note: Règle pour savoir si @ va fonctionner :
Si l'on peut "intercepter la valeur" d'un élément de code , on peut penser que sur cet élément de code, @ va pouvoir fonctionner
Donc cela fonctionne pour les variables, les fonctions, les include() Il ne fonctionne pas pour les définitions de classes ou de fonction, les structures conditionnelles, les boucles de programmes for, while...
Attention :
Le l'opérateur de contrôle d'erreur @ ne va supprimer que l'indication de l'erreur, pour les erreurs critiques, le script va s'arrêter brutalement sans aucune indication d'erreur, donc l'erreur sera très difficile à identifier.

Opérateur d'introduction de commentaires : <<<

Voir chapitre 1 (here docs)
Chapitre 01 : Here docs

Opérateur de suppression d'interpollation : { et }

Voir leçon sur les tableaux
Chapitre 05 : Tableaux et chaînes de caractères

Tester un opérateur :

Tester les opérateurs d'affectation
Tester les opérateurs arithmetiques
Tester les opérateurs binaires
Tester les opérateurs de comparaison
Tester les opérateurs de décalage de bit
Tester les opérateurs d'incrémentation/décrémentation
Tester les opérateurs logiques
Liste de tous les opérateurs

Tous droits réservés. 2005-2008