La base de toute condition : les booléens

Dans ce chapitre, nous allons aborder les conditions, mais pour cela il nous faut tout d'abord revenir sur un type de variable dont nous vous avions parlé au chapitre précédent : les booléens.

À quoi vont-ils nous servir ? À obtenir un résultat comme true (vrai) ou false (faux) lors du test d'une condition.

Pour ceux qui se posent la question, une condition est une sorte de « test » afin de vérifier qu'une variable contient bien une certaine valeur. Bien sûr les comparaisons ne se limitent pas aux variables seules, mais pour le moment nous allons nous contenter de ça, ce sera largement suffisant pour commencer.

Tout d'abord, de quoi sont constituées les conditions ? De valeurs à tester et de deux types d'opérateurs : un logique et un de comparaison.

Les opérateurs de comparaison

Comme leur nom l'indique, ces opérateurs vont permettre de comparer diverses valeurs entre elles. En tout, ils sont au nombre de huit, les voici :

Opérateur	Signification
==	égal à
!=	différent de
===	contenu et type égal à
!==	contenu ou type différent de
>	supérieur à
>=	supérieur ou égal à
<	inférieur à
<=	inférieur ou égal à

Nous n'allons pas vous faire un exemple pour chacun d'entre eux mais nous allons au moins vous montrer comment les utiliser afin que vous puissiez essayer les autres :

Code : JavaScript

var number1 = 2, number2 = 2, number3 = 4, result;

result = number1 == number2; // Au lieu d'une seule valeur, on en écrit deux avec l'opérateur de comparaison entre elles

alert(result); // Affiche « true », la condition est donc vérifiée car les deux variables contiennent bien la même valeur

result = number1 == number3;

alert(result); // Affiche « false », la condition n'est pas vérifiée car 2 est différent de 4

result = number1 < number3;

alert(result); // Affiche « true », la condition est vérifiée car 2 est bien inférieur à 4

Comme vous le voyez, le concept n'est pas bien compliqué, il suffit d'écrire deux valeurs avec l'opérateur de comparaison souhaité entre les deux et un booléen est retourné. Si celui-ci est true alors la condition est vérifiée, si c'est false alors elle ne l'est pas.

Lorsqu'une condition renvoie true on dit qu'elle est vérifiée.

Sur ces huit opérateurs, deux d'entre eux peuvent être difficiles à comprendre pour un débutant : il s'agit de === et !==. Afin que vous ne soyez pas perdus, voyons leur fonctionnement avec quelques exemples :

Code : JavaScript

var number = 4, text = '4', result;

result = number == text;

alert(result); // Affiche « true » alors que « number » est un nombre et « text » une chaîne de caractères

result = number === text;

alert(result); // Affiche « false » car cet opérateur compare aussi les types des variables en plus de leurs valeurs

Vous comprenez leur principe maintenant ? Les conditions « normales » font des conversions de type pour vérifier les égalités, ce qui fait que si vous voulez différencier le nombre 4 d'une chaîne de caractères contenant le chiffre 4 il vous faudra alors utiliser le triple égal ===.

Voilà tout pour les opérateurs de comparaison, vous avez tous les outils dont vous avez besoin pour faire quelques expérimentations. Passons maintenant à la suite.

Les opérateurs logiques

Pourquoi ces opérateurs sont-ils nommés comme étant « logiques » ? Car ils fonctionnent sur le même principe qu'une table de vérité en électronique. Avant de décrire leur fonctionnement, il nous faut d'abord les lister, ils sont au nombre de trois :

Opérateur	Type de logique	Utilisation
&&	ET	valeur1 && valeur2
\|\|	OU	valeur1 \|\| valeur2
!	NON	!valeur

L'opérateur ET

Cet opérateur vérifie la condition lorsque toutes les valeurs qui lui sont passées valent true. Si une seule d'entre elles vaut false alors la condition ne sera pas vérifiée. Exemple :

Code : JavaScript - Sélectionner

var result = true && true;

alert(result); // Affiche : « true »

result = true && false;

alert(result); // Affiche : « false »

result = false && false;

alert(result); // Affiche : « false »

L'opérateur OU

Cet opérateur est plus « souple » car il renvoie true si une des valeurs qui lui est soumise contient true, qu'importent les autres valeurs. Exemple :

Code : JavaScript

var result = true || true;

alert(result); // Affiche : « true »

result = true || false;

alert(result); // Affiche : « true »

result = false || false;

alert(result); // Affiche : « false »

L'opérateur NON

Cet opérateur se différencie des deux autres car il ne prend qu'une seule valeur à la fois. S'il se nomme « NON » c'est parce que sa fonction est d'inverser la valeur qui lui est passée, ainsi true deviendra false et inversement. Exemple :

Code : JavaScript

var result = false;

result = !result; // On stocke dans « result » l'inverse de « result », c'est parfaitement possible

alert(result); // Affiche « true » car on voulait l'inverse de « false »

result = !result;

alert(result); // Affiche « false » car on a inversé de nouveau « result », on est donc passé de « true » à « false »

Combiner les opérateurs

Bien, nous sommes presque au bout de la partie concernant les booléens, rassurez-vous, ce sera plus simple sur le reste de ce chapitre. Toutefois, avant de passer à la suite, il faudrait s'assurer que vous ayez bien compris que tous les opérateurs que nous venons de découvrir peuvent se combiner entre eux.

Tout d'abord un petit résumé (lisez attentivement) : les opérateurs de comparaison acceptent chacun deux valeurs en entrée et renvoient un booléen, tandis que les opérateurs logiques acceptent plusieurs booléens en entrée et renvoient un booléen. Si vous avez bien lu, vous comprendrez que nous pouvons donc coupler les valeurs de sortie des opérateurs de comparaison avec les valeurs d'entrée des opérateurs logiques. Exemple :

Code : JavaScript

var condition1, condition2, result;

condition1 = 2 > 8; // false

condition2 = 8 > 2; // true

result = condition1 && condition2;

alert(result); // Affiche « false »

Il est bien entendu possible de raccourcir le code en combinant tout ça sur une seule ligne, dorénavant toutes les conditions seront sur une seule ligne dans ce tutoriel :

Code : JavaScript

1 2	var result = 2 > 8 && 8 > 2; alert(result); // Affiche « false »

Voilà tout pour les booléens et les opérateurs conditionnels, nous allons enfin pouvoir commencer à utiliser les conditions comme il se doit.

Créé avec HelpNDoc Personal Edition: Produire des livres Kindle gratuitement