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


JavaScript 1 - Introduction
JavaScript 2 - Commentaires et instructions
JavaScript 3 - Variables
JavaScript 4 - Types de variables
JavaScript 5 - Variables et chaines
JavaScript 6 - Les fonctions
JavaScript 7 - Les fonctions à paramètre unique
JavaScript 8 - Les fonctions à paramètres multiples
JavaScript 9 - L'instruction RETURN dans une fonction
JavaScript 10 - Appel d'une fonction dans une autre fonction
JavaScript 11 - Les variables locales ou globales
JavaScript 12 - Quelques opérateurs mathématiques
JavaScript 13 - ???
JavaScript 14 - L'instruction IF, pour les conditions
JavaScript 15 - L'instruction IF... ELSE..., pour les conditions à deux sorties
JavaScript 16 - Les IF imbriqués et fonction aléatoire
JavaScript 17 - Les conditions complexes
17.1 JS : Les conditions complexes avec AND, OR et NOT
17.2 JS : Ordre de priorité ou précédence des opérateurs
17.3 JS : Récapitulatif : ordre de priorité ou précédence des opérateurs
17.4 JS : Opérateurs inconnus
17.8 JS : exercices sur les conditions complexes
17.9 JS : un test sur les conditions complexes
JavaScript 18 - L'instruction SWITCH, en cas de choix multiples
JavaScript 19 - La boucle FOR
JavaScript 20 - La boucle WHILE
JavaScript 21 - Les événements dans la programmation
JavaScript 22 - Quelques événements : onMouseOver onLoad etc.
JavaScript 23 - Les objets
JavaScript 24 - Créer ses propres objets
JavaScript 25 - Appliquer des méthodes à ses objets
JavaScript 26 - Les tableaux
JavaScript 27 - Différentes façons de créer des tableaux
JavaScript 28 - Propriétés et méthodes applicables aux tableaux
JavaScript 29 - Les méthodes applicables aux tableaux
JavaScript 30 - Méthodes de tris pour tableaux SORT, REVERSE et PUSH
JavaScript 31 - Ajouter des éléments à un tableau en utilisant une boucle
JavaScript 32 - Tecnique pour imprimer les éléments d'un tableau
JavaScript 33 - Lecture de bases de données
JavaScript 34 - Les objets mathématiques
JavaScript 35 - Les objets relatifs aux dates
JavaScript 36 - Les formulaires JS sont des objets
JavaScript 37 - Accès aux éléments d'un formulaire
JavaScript 38 - Validation des entrées d un formulaire
JavaScript 39 - Graphisme et JavaScript

JavaScript 50 - Calculateur d'emprunt
JavaScript 51 - Calendrier perpétuel et options diverses
JavaScript 99 - Documentation


 
 

 
Avec un peu de JavaScript,
n'oubliez pas de rendre vos pages
plus dynamiques et plus interactives.
 

 
 

 
Notre volonté est de rendre cette formation de JavaScript,
disponible le plus rapidement possible.
Le lecteur excusera l'imperfection de ce travail en cours de construction
et pourrait nous informer des défauts rencontrés.

  MERCI
 

 

 

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)