Saisir une entrée en javascript par une boîte de dialogue

Pour saisir un entrée dans un programme et stocker l'entrée dans une variable la syntaxte est la suivante :

var x = prompt ("Entrer x");

Structure conditionelle

Le code de la strucure conditionelle est donnée ci-dessous :

if (condition) {
  traitement à réaliser
}

où condition est une expression à valeur booléenne. Attention les parenthèses autour de condition font partie de la syntaxe et sont donc obligatoires.

Lors du traitement de cette expression, condition est évaluée. Si elle vaut true alors le code de traitement à réaliser est exécutée, sinon rien ne se passe.

Expression d'alternatives

Dans les situations rencontrées ci-dessus un traitement "particulier" est réalisé si une condition est vérifiée et dans le cas contraire on passe à loa suite sans aucun traitement complémentaire. On rencontre cependant fréquemment la situation dans laquelle un autre traitement doit être réalisé lorsque la condition n'est pas vérifiée (càd vaut false). Il est possible de programmer un tel comportement en complétant la structure conditionnelle if par un bloc exprimant l'alternative et identifié par le mot-clé else. La syntaxe est alors :

if (condition) {
  traitement_vrai (à réaliser si condition vaut true)
}
else {
  traitement_faut (à réaliser si condition vaut false)
}

La sémantique d'une expression est la suivante : lors du traitement de cette expression, condition est évaluée. Si elle vaut true alors le code traitement_vrai est exécutée, sinon, c'est-à-dire si condition est évaluée à false, c'est le code traitement_faux qui est exécutée.

On retrouve la forme de phrases du langage courant telles que "Si c'est pile je gagne sinon je perds."

Attention

Il est important de noter et de prendre conscience que l'expression

if (condition) {
   traitement_vrai
}
else {
   traitement_faux
}

n'est pas équivalente à la séquence

if (condition) {
   traitement_vrai
}; 
if (! condition) {
   traitement_faux
}

contrairement à ce que l'on peut peut-être penser dans une première impulsion qui s'avère fausse. On est éventuellement d'autant plus susceptible de commettre cette erreur logique que dans certains cas le comportement de ces deux expressions sont identiques. Ainsi les résultats des deux codes suivants sont équivalents :

var alea = Math.random();                      var alea = Math.random();
var resultat;                                  var resultat;
if (alea < 0.5) {                              if (alea < 0.5) {
  resultat = "pile";                              resultat = "pile";
}                                              };                   
else {				    	       if (alea >= 0.5) {
  resultat = "face";		    	          resultat = "face";
}	               		    	       }	            

Ce n'est cependant pas toujours le cas.

La fonction de Collatz est une fonction qui prend pour paramère un entier n et dont le résultat dépend de la parité de n. Ce résultat est 3*n+1 si n est impair et n/2 si n est pair.

On propose les deux codes suivants pour cette fonction :

var n = parseInt(window.prompt("Fournissez un entier positif"));
if (n%2 == 1) {
  n = 3*n +1;
} 
else {
  n = n/2;
}
document.writeln("la valeur de Collatz pour l'entier fourni est "+n);

et

var n = parseInt(window.prompt("Fournissez un entier positif"));
if (n%2 == 1) {
  n = 3*n +1;
} 
if (n%2 ==0) {
  n = n/2;
}
document.writeln("la valeur de Collatz pour l'entier fourni est "+n);

Des conditions en cascade

Les expressions conditionnelles permettent donc de distinguer deux situations différentes et d'exécuter alors deux traitements différents. La composition de plusieurs expressions conditionnelles permet alors de traiter les situations où il existe plus de deux cas qui diffèrent.

Prenons maintenant l'exemple de ce jeu dans lequel un joueur choisit secrètement un nombre que doit deviner un autre joueur. Pour cela ce dernier propose un nombre et le premier lui indiqué s'il a trouvé le nombre secret ou si sa proposition lui est supérieur ou inférieur. On le constate trois cas de figure sont possibles. Si on appelle nombreSecret la variable dont la valeur est le nombre secret choisi et proposition la variable dont la valeur est le nombre proposé, la portion de code suivante permet alors de fixer la valeur d'une variable resultat en fonction de chacune des trois situations :

if (proposition == nombreSecret) {
   resultat = "trouve";
} 
else {                      // proposition n'est pas égale à nombreSecret
  if (proposition < nombreSecret) {
     resultat = "trop petit";
  }
  else {
     resultat = "trop grand";		     
  }
}

La solution consiste à considérer plusieurs fois des alternatives entre deux situations. Ici, on teste d'abord si la proposition est ou non égale au nombre secret, puis dans le second cas on teste si elle est ou non plus petite. Comme on sait déjà qu'elle n'est pas égale, le cas false correspond nécessairement à une valeur trop grande.

Instruction switch...case

L'instruction switch permet de faire plusieurs tests de valeurs sur le contenu d'une même variable. Ce branchement conditionnel simplifie beaucoup le test de plusieurs valeurs d'une variable, car cette opération aurait été compliquée (mais possible) avec des if imbriqués. Sa syntaxe est la suivante :

switch (Variable) {
 case Valeur1:
 Liste d'instructions;
 break;
 case Valeur2:
 Liste d'instructions;
 break;
 case ValeurX:
 Liste d'instructions;
 break;
 default: 
 Liste d'instructions;
 break;
}

Les parenthèses qui suivent le mot clé switch indiquent une expression dont la valeur est testée successivement par chacun des case. Lorsque l'expression testée est égale à une des valeurs suivant un case, la liste d'instruction qui suit celui-ci est exécuté. Le mot clé break indique la sortie de la structure conditionnelle. Le mot clé default précède la liste d'instructions qui sera exécutée si l'expression n'est jamais égale à une des valeurs.
Exemple :

var day=new Date().getDay();
switch (day)
{
case 0:
  x="Today it's Sunday";
  break;
case 1:
  x="Today it's Monday";
  break;
case 2:
  x="Today it's Tuesday";
  break;
case 3:
  x="Today it's Wednesday";
  break;
case 4:
  x="Today it's Thursday";
  break;
case 5:
  x="Today it's Friday";
  break;
case 6:
  x="Today it's Saturday";
  break;
}

Boucle FOR

Le code de la strucure itérative est donnée ci-dessous :

for (compteur; condition; modification du compteur) {
 liste d'instructions
}

Par exemple :

for (i=1; i<6; i++) {
 Alert(i)
}

il faudra toujours vérifier que la boucle a bien une condition de sortie (i.e le compteur s'incrémente correctement) une instruction Alert(i); dans votre boucle est un bon moyen pour vérifier la valeur du compteur pas à pas! il faut bien compter le nombre de fois que l'on veut faire exécuter la boucle:

for(i=0;i<10;i++) exécute 10 fois la boucle (i de 0 à 9)

for(i=0;i<=10;i++) exécute 11 fois la boucle (i de 0 à 10)

for(i=1;i<10;i++) exécute 9 fois la boucle (i de 1 à 9)

for(i=1;i<=10;i++) exécute 10 fois la boucle (i de 1 à 10)

Boucle WHILE

L'instruction while représente un autre moyen d'exécuter plusieurs fois la même série d'instructions. La syntaxe de cette expression est la suivante :

while (condition réalisée) {
  liste d'instructions
}

Cette instruction exécute la liste d'instructions tant que (while est un mot anglais qui signifie tant que) la condition est réalisée. La condition de sortie pouvant être n'importe quelle structure conditionnelle, les risques de boucle infinie (boucle dont la condition est toujours vraie) sont grands, c'est-à-dire qu'elle risque de provoquer un plantage du navigateur!

Saut inconditionnel

Il peut être nécessaire de faire sauter à la boucle une ou plusieurs valeurs sans pour autant mettre fin à celle-ci. La syntaxe de cette expression est "continue;" (cette instruction se place dans une boucle!), on l'associe généralement à une structure conditionnelle, sinon les lignes situées entre cette instruction et la fin de la boucle seraient obsolètes. Exemple: Imaginons que l'on veuille imprimer pour x allant de 1 à 10 la valeur de 1/(x-7) ... il est évident que pour x=7 il y aura une erreur. Heureusement, grâce à l'instruction continue il est possible de traiter cette valeur à part puis de continuer la boucle!

x=1;
while (x<=10) {
 if (x == 7) {
    Alert('division par 0');
    x++;
    continue;
 }
a = 1/(x-7);
Alert(a);
x++;
}