Chapitres "Les conditions" et "Les boucles"
Les booléens
Chapitre "Les conditions"
Nous avons déjà parlé de deux types de variables : les
nombres et les
chaînes de caractères.
Mais nous allons maintenant avoir besoin d'un troisième type de variables : les
booléens. Ces variables ont deux valeurs possibles : vrai (
true), ou faux (
false).
Voyons comment ça marche et à quoi ça sert...
Comparer des nombres
On peut obtenir des booléens en
comparant des valeurs.
En effet, on dispose d'
opérateurs de comparaison, qui sont au nombre de 6 :
- opérateur d'égalité, == (attention, il y a bien deux signes "égal") ...
- ... son inverse, l'opérateur "est différent de", qui se note !=
- l'opérateur "strictement plus grand que", > ...
- ... de même, on a "strictement plus petit que", <
- et pour terminer, "plus grand ou égal à", >= ...
- ... ainsi que "plus petit ou égal à", <=.
Petit exemple : une variable
est_majeur qui contient
vrai uniquement si l'âge saisi par l'utilisateur est plus grand ou égal à 18.
Code : JavaScript1
2 | var age = prompt("Quel age avez-vous ?");
var est_majeur = (age >= 18);
|
Notez que les parenthèses autour de la condition servent à bien la distinguer (elles ne sont pas obligatoires, libre à vous de les mettre ou non).
Opérations sur les booléens
Nous avons vu qu'on peut additionner ou multiplier des nombres et concaténer des chaînes de caractères.
Eh bien il existe aussi des opérations sur les booléens, au nombre de trois :
- la négation, notée ! (si a est vrai, !a est faux, et inversement)
- le ET logique, &&. On a a && b qui est vrai si et seulement si a et b sont vrais
- le OU logique, || : a || b est vrai si et seulement si au moins l'une des deux valeurs est vraie.
Les conditions
Chapitre "Les conditions" (si si !!)
IF ... ELSE ...
On peut effectuer un test, pour exécuter des instructions différentes selon la valeur d'un booléen.
Voici la syntaxe :
Code : JavaScript1
2
3
4 | if(booleen)
// instruction a executer si le booleen est vrai
else
// instruction a effectuer s'il est faux
|
Avec cette écriture, on ne peut mettre qu'une instruction dans chaque "membre".
Si on a plusieurs instructions, il suffit de les placer entre accolades, { et }.
Le
else n'est d'ailleurs pas obligatoire, on peut n'écrire que :
Code : JavaScript1
2 | if(booleen)
// instruction a effectuer si le booleen est vrai
|
Comme d'habitude, un exemple :
Code : JavaScript1
2
3
4
5
6
7
8 | var age = prompt("Quel age avez-vous ?");
if(age >= 18)
{
alert("Vous êtes majeur.");
alert("Mais il n'est jamais trop tard pour apprendre à programmer :D");
}
else
alert("Tu es mineur");
|
On peut bien sûr effectuer des tests les uns à l'intérieur des autres (imbriqués).
IF avec autre chose qu'un booléen
Et si on met autre chose qu'un booléen dans le if ?
Dans ce cas, JS va essayer de "convertir" la chose en booléen.
Le résultat sera
false uniquement dans les cas suivants :
- 0 (zéro)
- "" ou '' (chaîne de caractères vide)
- undefined (variable déclarée mais non définie)
- null (mot-clé utilisé pour des objets "vides")
- S'il manque des cas, ce sont des cas similaires
SWITCH
Mais il arrive qu'on ait besoin de tester plusieurs valeurs pour une même variable.
Dans ce cas, il est possible d'utiliser plusieurs tests :
if ... else if ... else if ... else ....
Mais il existe une syntaxe moins lourde.
Voyez plutôt : on va distinguer plusieurs cas concernant le nombre d'enfants de l'utilisateur.
Code : JavaScript 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 | var nb = prompt("Combien avez-vous d'enfants ?");
switch(nb)
{
case 0: // si le nombre est 0...
alert("Au moins, vous êtes tranquilles :p"); // ... on affiche un message...
break; // ... et on arrete le "switch" ici
case 1: // si le nombre est 1
alert("Oh il est tout seul...");
break;
case 2:
case 3:
// s'il y en a 2 ou 3
alert("Il doit y avoir de l'ambiance chez vous ^^");
break;
case 4:
alert("Jolie famille !");
break;
default: // si c'est aucune des valeurs precedentes
alert("Plus de 4 enfants ?! Waow...");
break;
}
|
En rentrant dans le
switch, l'ordinateur exécute le code à partir du
case correspondant, et quitte le
switch lorsqu'il rencontre
break.
Les boucles
Chapitre "Les boucles"...
Les boucles permettent de
répéter des instructions
tant qu'une condition est vraie.
On distingue trois types de boucles, adaptées à des situations différentes.
WHILE
La première est très classique :
Code : JavaScript1
2 | while(condition)
// action
|
On répète l'action tant que la condition est vraie.
Notez que si la condition est fausse dès le début, l'action n'est jamais effectuée.
Exemple :
Code : JavaScript1
2
3
4
5
6
7 | var i=0;
while(i<10)
{
var j = i*i;
alert("Le carré de " + i + " est " + j);
i++;
}
|
FOR
La boucle
for est une variante, plus complète, de la boucle
while.
Elle s'utilise sous cette forme :
for(initialisation ; condition ; incrémentation) :
- l'initialisation se fait une seule fois, au début de la boucle
- la boucle est exécutée tant que la condition est vraie
- à la fin de chaque tour de boucle, l'incrémentation est effectuée.
Cette boucle est très utilisée, car elle convient souvent au besoin.
Mais chaque boucle a une utilisation particulière : on choisit cette boucle avant tout parce qu'elle convient à notre problème, et non pas uniquement parce qu'elle est pratique.
Un exemple :
Code : JavaScript1
2 | for(var i=0; i<10; i++)
alert(i);
|
Ce qui est équivalent à :
Code : JavaScript1
2
3
4
5
6 | var i=0;
while(i<10)
{
alert(i);
i++;
}
|
Il faut éviter d'utiliser à l'intérieur de la boucle la variable servant de compteur (les parenthèses servent justement à regrouper tout ce qui la concerne).
Inversement, on évitera de mettre dans ces parenthèses des choses qui n'ont rien à voir avec ce compteur.
DO .. WHILE
Cette dernière boucle est un peu différente des précédentes.
En effet, la condition est évaluée
à la fin de la boucle : les instructions seront toujours exécutées
au moins une fois, même si la condition est fausse dès le départ.
Cette particularité fait qu'elle a une utilisation différente.
Sa syntaxe est la suivante :
Code : JavaScript1
2
3 | do
// instruction a repeter
while(condition);
|
Notez la présence du point-virgule à la fin.
Ceci est dû au fait que la condition est à la fin de la boucle.
Voici un exemple : on demande une chaîne de caractères à l'utilisateur tant qu'il ne clique pas sur "
Annuler".
Code : JavaScript1
2
3
4 | var msg;
do
msg = prompt("Entrez ce que vous voulez, ou cliquez sur Annuler");
while(msg);
|
On effectue ici un test avec une valeur qui n'est pas un booléen, comme ça a été expliqué quelques paragraphes plus haut.
Réaliser une affectation dans une condition
Notez qu'on peut combiner une affectation et une condition.
Autrement dit, faire quelque chose comme ceci :
Code : JavaScript1
2
3 | var msg;
while( (msg = prompt("Entrez du texte")) != null)
alert(msg);
|
Pour comprendre cette condition, on peut la séparer en deux, comme ceci :
Code : JavaScript1
2 | msg = prompt("Entrez du texte"); // c'est l'affectation, entre les parentheses
msg != null; // c'est la condition
|
Et en effectuant le test directement avec une valeur qui n'est pas booléenne, on peut écrire ceci :
Code : JavaScript1
2
3 | var msg;
while(msg = prompt("Entrez du texte"))
alert(msg);
|
Il faut bien comprendre que le signe
= est le signe d'affectation !
En décomposant la condition, ça nous donne :
Code : JavaScript1
2 | msg = prompt("Entrez du texte"); // affectation
msg; // le test, avec une valeur qui n'est pas booleenne
|
Syntaxe en JavaScript
.
.
.
.
.
.
.
ch4rles
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+