Informatique


Evaluations booléennes

Remédiation Remédiation

Pourquoi est-ce si important?

Les structures conditionnelles et itératives sont pilotées par des conditions, celles-ci évaluent les valeurs booléennes d'une expression ou du contenu d'une variable.
La maîtrise de ce chapitre est donc indispensable à votre survie dans le monde de la programmation.


Evaluation booléenne d'une expression variable ou littérale

Les valeurs "falsy"

Une variable est évaluée à false pour les valeurs suivantes:

  • 0
  • 0.0
  • null
  • "" (une chaîne de caractères vide)
  • false
  • undefined (si la variable n'a pas été initialisée)
  • NaN

Les valeurs "truthy"

Pour toutes les autres valeurs, l'évaluation booléenne renvoie true

Les valeurs "false" et "0", chaîne de caractères renvoient true.

Démo
<script>
	var val;
	val="15";
	document.write(val + " de type "+ typeof val+"<br>");
	
	//Conversion vers boolean
	val=Boolean(val);
	document.write(val + " de type "+ typeof val);
</script>

Evaluation booléenne d'une expression logique

Les opérateurs && et || renvoient la valeur d'un des opérandes spécifiés.

Donc:
  • expr1 && expr2 renvoie expr1 si cette expression peut être convertie en false, sinon renvoie expr2.
  • expr1 || expr2 renvoie expr1 si cette expression peut être convertie en true, sinon renvoie expr2.
    Lorsqu'il est utilisé avec des valeurs booléennes, || renvoie true si au moins un des deux opérandes est true. Si les deux valent false, il renvoie également false.
  • !expr renvoie false si son opérande unique peut être converti en true, sinon il renvoie true.
Comme l'analyse se fait de gauche à droite, la notion de "circuit court" existe selon les deux règles suivantes:
  • l'évaluation de false && "quelque chose" est court-circuitée en false
  • l'évaluation de true || "quelque chose" est court-circuitée en true
Notons que la partie "quelque chose" n'a pas besoin d'être évaluée, et d'ailleurs elle ne le sera pas!
 

Pour savoir si une expression peut être convertie en true ou en false il faut se référer à l'évaluation booléenne d'une variable.


Exemples avec &&

Cas 1

Entre types booléens.

Démo
<script>
	var res, v1, v2, v3, v4;
	v1=1;
	v2=2;
	v3=3;
	v4=4;
	res=v1<v2 && v3>v4;
	console.log(res); 
</script>

Ici pas de soucis, on a dans l'ordre:

  • l'exécution des 2 conditionnelles, on a: res=true && false;
    Donc: expr1 ne peut pas être évalué à false donc on renvoie expr2
  • à l'exécution du && on a: res=false;

Cas 2
Démo
<script>
	var res, v1, v2, v3;
	v1=1;
	v2=2;
	v3=3;
	res=v1<v2 && v3;
	console.log(res);
</script>
  • l'exécution de la conditionnelle, on a: res=true && v3;
    Donc: expr1 ne peut pas être évalué à false donc on renvoie expr2
  • à l'exécution du && on a: res=3;
Cas 3
Démo
<script>
	var res, v1, v2;
	v1=1;
	v2=2;
	res=v1 && v2;
	console.log(res); 
</script>

L'exécution du && donne: res=2;
Donc: expr1 ne peut pas être évalué à false donc on renvoie expr2

Cas 4
Démo
<script>
	var res, v1, v2;
	v1=null;
	v2=2;
	res=v1 && v2;
	console.log(res); 
</script>

L'exécution du && donne: res=null;
Donc: expr1 peut être évalué à false donc on renvoie expr1


Exemples avec ||

Cas 1

Entre types booléens.

Démo
<script>
	var res, v1, v2, v3, v4;
	v1=1;
	v2=2;
	v3=3;
	v4=4;
	res=v1<v2 || v3>v4;
	console.log(res); 
</script>
  • l'exécution des 2 conditionnelles, on a: res=true || false;
    Donc: expr1 peut être évalué à true donc on renvoie expr1
  • à l'exécution du || on a: res=true;
Cas 2
Démo
<script>
	var res, v1, v2, v3;
	v1=1;
	v2=2;
	v3=3;
	res=v1<v2 || v3;
	console.log(res);
</script>
  • l'exécution de la conditionnelle, on a: res=true || v3;
    Donc: expr1 peut être évalué à true donc on renvoie expr1
  • à l'exécution du ||; on a: res=true;
Cas 3
Démo
<script>
	var res, v1, v2;
	v1=1;
	v2=2;
	res=v1 || v2;
	console.log(res); 
</script>

L'exécution du || donne: res=1;
Donc: expr1 peut être évalué à true donc on renvoie expr1

Cas 4
Démo
<script>
	var res, v1, v2;
	v1=null;
	v2=2;
	res=v1 || v2;
	console.log(res); 
</script>

L'exécution du || donne: res=2;
Donc: expr1 ne peut pas être évalué à true donc on renvoie expr2


Exemples avec !

Cas 1

Entre types booléens.

Démo
<script>
	var res, v1;
	v1="Fichtre!";
	res=!v1;
	console.log(res); 
</script>

Donc: expr peut être évalué à true donc on renvoie false
A l'exécution du ! on a: res=false;

Cas 2
Démo
<script>
	var res, v1;
	v1="";
	res=!v1;
	console.log(res); 
</script>

Donc: expr ne peut pas être évalué à true donc on renvoie true
A l'exécution du ! on a: res=true;


En résumé

Pour le &&

a1 = true  && true      // t && t renvoie true
a2 = true  && false     // t && f renvoie false
a3 = false && true      // f && t renvoie false
a4 = false && (3 == 4)  // f && f renvoie false
a5 = "Yip" && "Yop"     // t && t renvoie "Yop"
a6 = false && "Yop"     // f && t renvoie false
a7 = "Yop" && false     // t && f renvoie false
Pour le ||

a1 = true  || true       // t || t renvoie true
a2 = false || true       // f || t renvoie true
a3 = true  || false      // t || f renvoie true
a4 = false || (3 == 4)   // f || f renvoie false
a5 = "Yip" || "Yop"      // t || t renvoie "Yip"
a6 = false || "Yip"      // f || t renvoie "Yip"
a7 = "Yip" || false      // t || f renvoie "Yip"
Pour le !

n1 = !true              // !t renvoie false
n2 = !false             // !f renvoie true
n3 = !"Yop"             // !t renvoie false