Premiers pas en JavaScript
17.1 opérateurs logiques, conditions complexes
cuy copyleft
  See You Why?  

 


test relatif aux conditions imbriquées (16.9) | | opérateurs : ordre de précédence (17.2)

Contenu

 

 

I. Condition complexe

Dans la programmation, il s'avère souvent nécessaire d'effectuer des instructions que si une ou plusieurs conditions sont remplies. Dans les chapitres 14 et 15, nous vous avons présenté d'une part, l'action ou les actions à exécuter si une condition est remplie (IF), d'autre part, l'action ou les actions à exécuter si une condition est remplie et celles à exécuter dans le cas contraire (IF... ELSE...).

Dans le chapitre 16, nous vous avons montré que les IF imbriqués permettaient de tester plusieurs conditions... mais quelle lourdeur d'écriture après quelque temps.

Dans ce chapitre, nous avons l'intention de vous présenter des conditions complexes ou multiples. Qu'appelle-t-on conditions complexes ? On appelle conditions complexes les conditions qui consistent en un ensemble de deux ou plusieurs conditions plus simples, indépendantes l'une de l'autre et reliées par des opérateurs logiques ET, OU et NON.

Ainsi, une école pourrait souhaiter engager un nouveau prof,
qui soit de sexe masculin ET âgé de plus de 25 ans [discrimination illégale, je sais... sauf pour les profs d'éducation physique] ;
qui soit régent en sciences économiques OU en math, etc...

Lorsque vous cherchez une destination de vacances sur Internet, vous vous fixez aussi de conditions acceptables :
- la destination finale du vol ;
- la compagnie aérienne ;
- le prix du vol ;
- la date du vol ;
- l'heure du vol ;
- le nombre d'escales ;
- le temps d'attente pour chaque escale ; etc.

Et vous n'accepterez de faire le voyage que si :
- la destination finale du/des vol/s : "Tucson, Arizona, USA" ;
- la compagnie aérienne : peu importe ;
- le prix du vol : A-R inférieur à 1000  ;
- la date du vol : départ entre le 15 et le 18 juillet ;
- l'heure du vol : peu importe ;
- le nombre d'escales : maximum 2 ;
- le temps d'attente pour chaque escale : pas plus de 10 heures par escale, etc.

Et vous ne prendrez le vol que si 6 de ces conditions sont remplies... dont les cinq premières... votre critère complexe pourrait s'écrire ainsi :

[ (destination = "Tucson, Arizona, USA")  ET
(compagnie aérienne = "peu importe") ET
(prix A-R < 1000 €) ET
(15/8/2012 <départ< 18/8/2012) ET
(heure départ vol = "peu importe") ET
(    (nbre escales < 2) OU (attente par escale < 10h) ) ]

 

En JS, nous avons vu que la syntaxe à suivre pour n'exécuter certaines instructions que si une condition est vérifiée, est :

if (condition à vérifier) {
        faire_si_oui();
        //la liste des instructions à exécuter si la condition est vraie
}

Ensuite, nous avons vu la syntaxe pour exécuter certaines instructions si une condition est vérifiée et dans le cas contraire :

if (condition à vérifier) {
        faire_si_oui();
        //la liste des instructions à exécuter si la condition est vraie
} else {
        faire_si_non();
        //la liste des instructions à exécuter si la condition n'est pas vérifiée
}

Les conditions imbriquées nous ont ensuite permis d'introduire plusieurs conditions pour arriver à la solution attendue.

Ce chapitre nous permettra de poser de multiples conditions, liées entre elles par des ET et des OU, voire même des SI PAS. Pas de panique, nous ne sommes pas là pour refaire la démonstration logique de "Si Luc est l’auteur de ce bruit, il est stupide ou dépourvu de principes. Luc n’est ni stupide ni dépourvu de principes. Donc Luc n’est pas l’auteur de ce bruit."... quoique...

 

A. l'opérateur ET, AND noté &&

La logique booléenne parle de conjonction ou de multiplication logique. Selon les langages informatiques, on utilisera la notation
^ : mathématiques, APL...
. :
AND : Pascal, Fortran, PHP, Ada, Python...
& ou && : Perl, C, PHP, JavaScript...
; : Prolog...

Le "ET" logique, sert à tester la véracité de deux assertions logiques en même temps. Pour que le test retourne la valeur "true" (soit vrai en fait), il faut que les deux assertions soient vraies. Si l'une d'elles est fausse, le teste renverra la valeur "faux" (false en anglais). Par exemple :

Variable1 = 10;
Variable2 = 10;
Variable3 = 20;
Variable4 = 20;
// teste si la condition est vraie :
if ((Variable1 == Variable2) && (Variable3 == Variable4)){
    alert("Les deux assertions sont vraies");
   
// message si condition vraie
} else {
    alert("L'une des deux assertions est fausse, ou les deux");
    // message si condition fausse
}

Le "ET logique" n'est vrai (TRUE) que si les deux assertions sont toutes les deux vraies (TRUE).
Table de vérité de AND (=ET) noté &&
condAcondBcondA && condB
truetruetrue
falsetruefalse
truefalsefalse
falsefalsefalse

Dans ce cas, si l'une des propositions (assertions) est fausse, ou si les deux sont fausses, le test est faux.
Pour qu'il soit juste, les deux doivent être vraies. Remarquez que chaque assertion (on dit aussi les "opérandes") sont placées chacune entre parenthèses.
Ce n'est pas une obligation, et ici, ça aurait très bien marché sans ça.
Mais lors de l'écriture de propositions complexes, certaines prennent le pas sur d'autres (on dit qu'elles ont des ordres de "préséance"), surtout si dedans, il y a des signes mathématiques comme par exemple :

if (((Variable1 * 2) >= (Variable3 / 2)) && ((Variable2 * 2) >= (Variable4 / 2))) {
// ce qui est vrai !!
// puisque (((10 * 2) >= (20 / 2)) && ((10 * 2) >= (20 / 2)))
// ou (((20) >= (10)) && ((20) >= (10)))

Si JS doit évaluer plusieurs conditions liées par un opérateur &&, JS les évaluera de gauche à droite, mais court-circuitera son évaluation dès qu'il rencontrera une des assertions (ou conditions) qui soit fausse. Ainsi,

a = 10;
b = 20;
c = 30;
if (a==10 && b==15 && c==20) {...}

JS vérifiera que la première condition est vérifiée,
testera donc la deuxième qui s'avère être fausse... il ne vérifiera pas la 3e condition, puisque l'une des 3 est fausse, donc leur conjonction est fausse.

 

B. l'opérateur OU, OR noté ||

Avant tout, où trouve-t-on cette double barre ?
Sur un clavier belge,
   sur la touche du & commercial, qui en "shift" ou majuscules donne '1' et avec l'aide de la touche 'AltGr' donne '|' ;
sur un clavier français,
   sur la touche du -, qui en "shift" ou majuscules donne '6' et avec l'aide de la touche 'AltGr' donne '|'.

La logique booléenne parle de disjonction (ou d'addition logique) et même plus précisément, de disjonction inclusive. Selon les langages informatiques, on utilisera la notation
v : mathématiques, APL...
+ :
OR : Pascal, Fortran, PHP, Ada, Python...
!! : Perl, C, PHP, JavaScript...
, : Prolog...

Le "OU" logique inclusif, sert à tester la véracité de deux assertions logiques aussi. Pour que le test retourne la valeur "vrai" (soit vrai en fait), il faut que l'une des deux assertions soit vraie.
JavaScript ne dispose pas de l'opérateur logique "OU" exclusif, parfois noté XOR [qui lui n'est vrai que si une seule des deux assertions est vraie, mais pas les deux... mais si JS ne connait pas le XOR logique, il connait le XOR binaire]. Si l'une d'elles est vraie (éventuellement les deux), le test renverra la valeur "vrai" (true en anglais). Par exemple :

Variable1 = 10;
Variable2 = 10;
Variable3 = 20;
Variable4 = 20;
// teste si la condition est vraie :
if ((Variable1 == Variable2) || (Variable3 < Variable4)){
    alert("L'une des deux assertions est vraie, éventuellement les deux");
   
// message si condition vraie
} else {
    alert("Aucune des deux assertions n'est vraie");
    // message si condition fausse
}

Le "OU logique inclusif" n'est faux (FALSE) que si les deux assertions sont toutes les deux fausses (FALSE).
Table de vérité de OR (=OU) noté ||
condA condB condA || condB
true true true
false true true
true false true
false false false

Dans ce cas, si l'une des propositions (assertions) est vraie, ou si les deux sont vraies, le test est vrai.
Pour qu'il soit juste, l'un des deux doit être vrai. Remarquez ici aussi que chaque assertion (on dit aussi les "opérandes") doit être placée entre parenthèses.
Ce n'est pas une obligation, et ici, ça aurait très bien marché sans ça.
Mais lors de l'écriture de propositions complexes, certaines prennent le pas sur d'autres (on dit qu'elles ont des ordres de "préséance", de "précédence" ou de "priorité"), surtout si dedans, il y a des signes mathématiques comme par exemple :

if (((Variable1 * 2) >= (Variable3 / 2)) || ((Variable2 * 2) < (Variable4 / 2))) {
// ce qui est vrai !!
// puisque (((10 * 2) >= (20 / 2)) || ((10 * 2) < (20 / 2)))
// ou (((20) >= (10)) ||((20) < (10)))

Si JS doit évaluer plusieurs conditions liées par un opérateur ||, JS les évaluera de gauche à droite, mais court-circuitera son évaluation dès qu'il rencontrera une des assertions (ou conditions) qui soit vraie. Ainsi,

a = 10;
b = 20;
c = 30;
if (a==10 || b==15 || c==20) {...}

JS vérifiera que la première condition est vérifiée,
plus besoin de tester la 2e, ni la 3e condition, puisque l'une des 3 est vraie... leur disjonction sera vraie.

 

C. l'opérateur NON, NOT noté !

Le "NON logique" sert à inverser la véracité d'une assertion logique. La logique booléenne l'appelle négation.

Cet opérateur NOT, nous l'avons déjà partiellement rencontré dans la condition "différent de" qui s'écrit en fait "non égal à" en utilisant le signe ! (point d'exclamation) devant le signe = (égal).
C'est la négation logique, c'est-à-dire le "non quelque chose". Tout ce qui n'est pas ce quelque chose, n'importe quoi, mais surtout pas le quelque chose en question.
Nous le verrons souvent employé lorsque l'on veut tester la non existence d'une valeur ou d'une propriété.

Par exemple :
"devient égal à" s'écrit = ,
"est égal à" s'écrit == dans une condition,
et "est non égal à" ou "est différent de" s'écrira !=.

En fait, il serait plus exact de dire que l'opérateur "non" (souvent dit NOT en anglais) teste si une condition renvoie la valeur logique "False" (faux).
En clair, si = est vrai, donc renvoie la valeur "true" (vrai en anglais), != (non égal) renverra la valeur vrai seulement si = est faux.

Le "NON logique" d'une expression inverse la valeur logique de l'expression... il rend FAUX une expression vraie et rend VRAI une expression fausse.
En cas de pluie, la proposition "il pleut" est vraie, donc
la proposition "il est faux de dire qu'il pleut" est fausse ;
En cas de pluie, la proposition "il ne pleut pas" est fausse, donc
la proposition "il est faux de dire qu'il ne pleut pas" est vraie ;
Table de vérité de NOT (=NON) noté !
condA !condA
true false
false true

Comme vous le voyez, cela semble très facile, mais l'expérience me dit que ça n'est pas aussi simple que ça en a l'air. Vous avez peut-être connu des spécialistes de l'emploi de doubles négations. Mais avec un peu d'habitude, on s'y fait très bien. Par exemple :

(10 == 10) // possède la valeur logique "true" (vrai) car c'est vrai ;
(10 != 10) // possède la valeur logique "false" (faux) car c'est faux ;
!(10 == 10) // possède la valeur logique "false" (faux) elle nie une valeur logique vraie ;
!(10 != 10) // possède la valeur logique "true" (vrai), elle nie une valeur logique fausse.

On verra que ce genre d'expression est souvent utilisé pour tester l'existence d'un objet dans un document.

D. opérateurs combinés

Les trois opérateurs décrits ci-dessus sont les seuls utilisables par JS. La combinaison de ceux-ci permet de multiples possibilités. Voyez vous-mêmes :

 

Vrai ou faux ? ((4 >= 6) || ("vin" != "rouge")) && !(((12 * 2) == 144) && true)

On peut donc imaginer des combinaisons du type
(( condition1 || condition2 ) && ! (condition3 && condition4)),
pour preuve :

((4 >= 6) || ("vin" != "rouge")) && !(((12 * 2) == 144) && true)

( False      ||       True       )     &&   !(       False              && True)

(             True                 )     &&   !(               False                  )

(             True                 )     &&   (               True                  )

(                                      True                                     )

Ce qui signifie que si l'on écrit
if (((4 >= 6) || ("vin" != "rouge")) && !((12 * 2 == 144)&& true)) {... ,
la condition sera vérifiée,
et les instructions qui suivront ce IF seront exécutées.

Attention cependant au nombre de parenthèses ouvertes et fermées... on ne peut pas fermer plus de portes que l'on n'en a ouvertes...

 

 

II. Ordre de précédence des opérateurs

voir suite >>>

 

III. Récapitulatif de l'ordre de précédence des opérateurs

voir suite >>>

 

IV. Opérateurs inconnus jusqu'ici

voir suite >>>

 

VIII. Exercices relatifs aux conditions complexes

voir suite >>>

 

 

IX. Test relatif aux conditions complexes

voir suite >>>

 

 


test relatif aux conditions imbriquées (16.9) | | opérateurs : ordre de précédence (17.2)