Cpm Affiliation : la régie publicitaire au Cpm

Les opérateurs : partie II

Pour l'instant, vous avez vu six opérateurs : l'opérateur d'affectation et les cinq opérateurs arithmétiques.
Mais le PHP est bien fourni, et il en reste beaucoup à voir. Il doit en rester plus d'une quarantaine.

Je ne vais pas tous les détailler, je vais même en omettre quelques-uns pour le moment, mais vous les verrez tous, promis !

Opérateurs arithmétiques d'affectation et opérateurs d'incrémentation

Dans le chapitre précédent, on a vu ce qu'étaient les opérateurs arithmétiques et à quoi ils servaient.
Si vous avez eu la bonne idée de vous amuser à tester un peu tout et n'importe quoi, vous êtes sans doute arrivés à ce genre de code :

Code PHP : 

<?php
$var = 5;
$var = $var + 5;
var_dump($var);

Rien de compliqué pour vous : on déclare une variable en lui affectant la valeur 5, et puis on réaffecte à cette variable sa valeur plus 5. Seulement, vous devez sans doute vous rendre compte que c'est lourd et plutôt embêtant de devoir écrire plusieurs fois $var.

C'est pourquoi le PHP met à disposition des opérateurs qui sont un mix des opérateurs arithmétiques et de l'opérateur d'affectation. En termes simples, ces opérateurs permettent d'utiliser la valeur d'une variable dans une expression et d'affecter le résultat de cette expression à cette variable.

L'opérateur arithmétique d'addition et d'affectation est +=.

Reprenons le code précédent en utilisant ce nouvel opérateur :

Code PHP :

<?php

$var = 5;
$var += 5;
var_dump($var);

Le résultat est strictement le même, mais c'est un peu plus court à écrire. Au passage, rappelez-vous ce qu'est une expression. Si votre mémoire est bonne, vous avez sans doute deviné que $var += 5 est une expression. On peut donc l'utiliser comme n'importe quelle expression ; exemple :

Code PHP :

<?php

$var = 5;
var_dump(6 + $var += 3);

INFORMATION : Cet opérateur a le même niveau de priorité que l'opérateur d'affectation (=).
Mais n'oubliez jamais que l'on peut forcer la priorité en utilisant des parenthèses.

Évidemment, ce n'est qu'un opérateur parmi d'autres. Tous les opérateurs arithmétiques ont un équivalent en opérateur d'affectation ; exemple :

Code  PHP :

<?php

$a = 4;
var_dump($a /= 2);
$b = 10;
var_dump($b *= 3);
$c = 7;
var_dump($c -= 4);
$d = 9;
var_dump($d %= 2);
$e = 18;
var_dump($e += 1);

INFORAMTION : Ces quatre opérateurs ont également la même priorité que l'opérateur d'affectation.

A priori, rien de bien particulier dans ce code, et pourtant… une notion importante en PHP, comme dans bien des langages, y apparaît : l'incrémentation.

Mais qu'est-ce que l'incrémentation ? Incrémenter une variable, c'est lui affecter sa valeur plus 1 (bien qu'en réalité, on peut dire qu'incrémenter une valeur, c'est lui ajouter quelque chose). Puisque rien ne vaut un bon exemple :

Code PHP :

<?php

$a = 5;
$a++;
var_dump($a);

L'opérateur d'incrémentation est le double plus (++). 5 plus 1, ça donne 6 : le résultat est bien celui que l'on attend. Mais je vais vous emmêler les pinceaux, regardons ce code :

Code PHP :

<?php

$a = 5;
var_dump($a++);

Plutôt curieux, non ? Au lieu d'avoir 6, comme on pouvait le supposer, le résultat est 5. Vous venez de faire les frais de la différence entre la post-incrémentation et la pré-incrémentation. Des mots compliqués, ça rend toujours mieux  .
Pour incrémenter une variable, on a fait comme ça :

Code PHP :

<?php

$a = 5;
$a++;
var_dump($a);

Mais on peut également le faire ainsi :

Code PHP :

<?php

$a = 5;
++$a;
var_dump($a);

Ces deux codes produiront le même résultat ; la seule différence, c'est que dans le premier je fais une post-incrémentation, et dans le second, une pré-incrémentation. La différence est très simple à comprendre. La pré-incrémentation incrémente la variable avant que sa valeur ne soit utilisée, alors que la post-incrémentation incrémente la variable après que sa valeur a été utilisée. Vous allez comprendre :

Code PHP :

<?php

$a = 5;
var_dump($a++);
$b = 5;
var_dump(++$b);

Le premier var_dump() affiche que la variable prend la valeur 5 et le second la valeur 6. Second code :

Code PHP :

<?php
$a = 5;
var_dump($a++);
var_dump($a);
$b = 5;
var_dump(++$b);
var_dump($b);
?>

Le premier et le troisième var_dump() affichent la même chose que la dernière fois. Mais le second et le quatrième, eux, affichent la même chose. Avec cette histoire de post et pré-incrémentation, vous devriez pouvoir expliquer pourquoi. Mais je vais quand même le faire.
Voici ce que fait l'interpréteur PHP : on déclare $a et on lui affecte la valeur 5, il affiche les infos sur $a avant d'incrémenter $a. On affiche à nouveau les infos de $a. On déclare $b et on lui affecte la valeur 5, il affiche les infos de $b après avoir incrémenté $b. On affiche à nouveau les infos de $b.

Tout ce que vous devez retenir sur la post/pré-incrémentation, c'est que dans le cas de la pré-incrémentation, on incrémente d'abord la variable et ensuite l'instruction est exécutée tandis que dans le cas de la post-incrémentation, l'instruction est d'abord exécutée puis la valeur est incrémentée

Vous vous en doutez peut-être, il existe l'inverse de l'incrémentation : la décrémentation. L'opérateur de décrémentation est le double moins (--), et il fonctionne de la même façon que l'opérateur d'incrémentation (ça vaut aussi pour l'histoire de post/pré-décrémentation).

Opérateurs de comparaison

Quel que soit le langage de programmation que vous pouvez utiliser, vous avez toujours besoin de pouvoir faire des comparaisons. Par exemple, si vous voulez faire un espace membre, pour s'y connecter, il faudra vérifier que le mot de passe que l'utilisateur donne est le même que celui qu'il a donné à son inscription : on va devoir les comparer.

En PHP, il existe en tout et pour tout neuf opérateurs de comparaison. Ça va du simple test d'égalité au test de différence de type. Les opérateurs arithmétiques retournaient la valeur du calcul et donnaient soit un type int, soit un type float en fonction de la valeur du calcul. Les opérateurs de comparaison renvoient des booléens. Souvenez-vous, j'en ai parlé dans le chapitre sur les variables.

Les booléens peuvent prendre deux valeurs : true (vrai) et false (faux). Les opérateurs de comparaison renvoient true si la comparaison est vraie et false si elle est fausse. Pas très compliqué. Voici un tableau des différents opérateurs de comparaison :

Opérateur

Fonction

== Retourne true si les valeurs des expressions à gauche et à droite sont égales.
=== Retourne true si les valeurs des expressions à gauche et à droite sont égales et du même type.
!= Retourne true si les valeurs des expressions à gauche et à droite sont différentes.
!== Retourne true si les valeurs des expressions à gauche et à droite sont différentes ou sont de types différents.
<> Voir l'opérateur !=.
> Retourne true si la valeur de l'expression de gauche est strictement plus grande que la valeur de l'expression de droite.
>= Retourne true si la valeur de l'expression de gauche est plus grande ou égale à la valeur de l'expression de droite.
< Retourne true si la valeur de l'expression de gauche est strictement plus petite que la valeur de l'expression de droite.
<= Retourne true si la valeur de l'expression de gauche est plus petite ou égale à la valeur de l'expression de droite.

Maintenant que la théorie est là, faisons place à la pratique, vérifions que 5 est strictement plus petit que 6 :

Code PHP :

<?php

$var = 5 < 6;
var_dump($var);

INFORMATION : 5 < 6 est une expression, on aurait donc pu juste écrire var_dump(5 < 6) au lieu d'utiliser inutilement une variable.

Quelques tests en vrac :

Code PHP :

<?php

$a = 5;
var_dump($a == 5);
$b = '7';
var_dump($b == 7);
var_dump($b === 7); // 7 est de type int, alors que $b est de type string. L'opérateur == ne vérifiant pas le type, il retourne true, vu que les deux valeurs sont les mêmes. Mais comme l'opérateur vérifie également le type, et comme les valeurs des deux expressions ne sont pas de même type, il retourne false.
$c = 'meuh';
var_dump($c !== 'meuh');
var_dump($c == $d = 'meuh');
// etc.

ATTENTION : Tous les opérateurs de comparaison ont un niveau de priorité inférieur à n'importe lequel des opérateurs arithmétiques. Parmi les opérateurs de comparaison, il y a deux groupes : >, >=, <, <= et ==, ===, !=, !==, <>. Dans chacun de ces groupes, le niveau de priorité est constant. Le niveau de priorité du premier groupe est supérieur à celui du second.
Enfin, les deux groupes ont un niveau de priorité supérieur au niveau de priorité du groupe d'opérateurs suivant : =, +=, -=, *=, /=, %=.

Pour l'instant, ces opérateurs ne servent à rien, sauf peut-être à vérifier que l'interpréteur PHP sait compter ; mais ils serviront beaucoup dans le prochain chapitre.

Opérateurs logiques

Après ces quelques opérateurs, faisons une courte pause. Je vous ai fait comprendre qu'il y avait en tout cinquante-deux opérateurs en PHP. On en a vu vingt-deux (cinq arithmétiques, six d'affectation, neuf de comparaison, un d'incrémentation et un de décrémentation). Il en reste donc trente.
Je ne vais pas tous les détailler ici. Certains étant pour le moment totalement superflus, on les verra petit à petit tout en avançant dans l'apprentissage de la syntaxe du PHP.
Mais avant de vous laisser tranquilles avec les opérateurs, on va encore en voir six : les opérateurs logiques (en réalité, il n'y en a que quatre, mais il y en a qui ont la même fonction avec une priorité différente !).

Dans la partie précédente, on a vu comment faire des comparaisons. Mais maintenant, qu'écririez-vous si je vous demandais de vérifier que 22 est plus grand que 6 et plus petit que 52 ?
Vous arriveriez sans doute, après un peu de réflexion, à ceci :

Code PHP :

<?php

$a = 22 > 6;
$b = 22 < 52;
$test = $a == $b; // ce qui vaut true
// on peut condenser ce code en :
$test = 22 > 6 == 22 < 52; // > et < ayant un niveau de priorité plus grand que == (relisez la partie précédente), on n'est pas obligés de mettre des parenthèses, mais je les mettrai quand même pour améliorer la lisibilité du code.

Il faut cependant l'avouer : ce n'est pas naturel. Vérifier si le résultat des deux tests est le même, il faut y penser. Et si vous avez besoin de faire plus de tests, ça devient vite extrêmement pénible. C'est pour ça que le PHP met les opérateurs logiques à notre disposition. En voici la liste et leur rôle respectif (ils renvoient aussi true ou false, comme les opérateurs de comparaison) :

Opérateur

Fonction

&& Retourne true si les valeurs des expressions à gauche et à droite sont égales à true.
|| Retourne true si la valeur de l'expression à gauche est égale à true ou si la valeur de l'expression à droite est égale à true.
AND Voir l'opérateur &&.
OR Voir l'opérateur ||.
XOR Retourne true si la valeur de l'expression à gauche est égale à true ou que la valeur de l'expression à droite est égale à true MAIS si les valeurs des expressions à droite et à gauche ne sont pas toutes les deux égales à true.
! Retourne true si la valeur de l'expression de droite vaut false.

 

Les deux opérateurs « doublons » sont faciles à trouver . Comme je l'ai dit, la seule différence est le niveau de priorité. Voici d'ailleurs les six opérateurs dans l'ordre décroissant de leur niveau de priorité : !, &&, ||, AND, XOR, OR. Ils ont tous des niveaux de priorité différents. Mais tous les opérateurs logiques ont un niveau de priorité inférieur au plus faible des opérateurs arithmétiques.

Maintenant que l'on maîtrise ces opérateurs, reprenons l'exercice précédent :

Code PHP :

<?php

$test = 22 > 6 && 22 < 52;
var_dump($test);

Vous êtes fin prêts pour faire des comparaisons rocambolesques.
Un petit exemple : je veux vérifier que 18 est compris entre 10 et 30 (compris), mais est différent de 20. Si c'est le cas, le code doit afficher true.

Code PHP :

<?php
var_dump(18 >= 10 && 18 <= 30 && 18 != 20);
?>


Vu que tous les opérateurs fonctionnent de la même façon, je ne vais pas m'attarder là-dessus. Par contre, je vais dire un petit mot sur l'opérateur logique !.

Si les cinq autres opérateurs logiques utilisent deux expressions (une de chaque côté de l'opérateur), celui-ci, comme les opérateurs d'incrémentation et de décrémentation, n'utilise qu'une expression. Un exemple de son utilisation :

Code PHP :

<?php
$test = 5 == 8; // vaut false
var_dump(!$test); // affiche true
$test = 4 % 2 === 0; // vaut true
var_dump(!$test); // affiche false
?>

On peut bien sûr réduire ce code, mais faites bien attention à la priorité des opérateurs. D'ailleurs, comme on en a déjà vu pas mal, voici un cadeau : une liste des opérateurs triés par ordre décroissant de niveau de priorité (les opérateurs d'une même ligne ont la même priorité).

  • ++, --
  • *, /, %
  • +, -
  • >, >=, <, <=
  • ==, ===, !=, !==, <>
  • &&
  • ||
  • =, +=, -=, /=, *=, %=
  • AND
  • XOR
  • OR

Et bien entendu, n'oubliez pas qu'on peut toujours forcer la priorité en utilisant des parenthèses. D'ailleurs, utilisez-les… Regardez un peu cette instruction : $test = 4 % 2 === 0;.
N'est-elle pas plus compréhensible ainsi : $test = ((4 % 2) === 0); ?
Il ne faut évidemment pas tomber dans l'excès, c'est à vous de juger de ce qui est nécessaire pour que votre code soit lisible mais pas trop chargé.

Les opérateurs, c'est fini !
Qu'en pensez-vous ? Avec tout ça et les prochains chapitres, vous pourrez bientôt faire de grandes choses avec le PHP.
Si vous êtes toujours avec moi, c'est parti pour le chapitre sur les structures de contrôle, on y verra toute la puissance de l'association des opérateurs de comparaison et des opérateurs logiques.

 



 

 

Infos Plan Partenaires
À propos Webmasters
C.G.U Services Gratuits Annuaire de sites web
Bannières Forum Ionoa

 

Aipoweb est un site édité par ASMOH NetWork  ©

Créer un site gratuit avec e-monsite - Signaler un contenu illicite sur ce site