JavaScript : la conditionnelle simple (ch. 2 ex. 1)

 Objectifs 

  1. Ce chapitre va te permettre d'approfondir ta connaissance des fonctions et de leur syntaxe;
  2. Il va surtout te faire découvrir la structure conditionnelle simple et sa mise en œuvre.

 Les fonctions, suite... 

Nous avons vu dans le chapitre précédent l'utilisation de fonctions avec arguments. Toutefois, certaines fonctions peuvent être dépourvues d'arguments car elles n'en ont pas besoin, leurs tâches sont immuables, quel que soit l'état de leur environnement. Cet exercice contiendra une fonction de ce genre.

Que faire alors ? Hé bien, tout simplement, on n'indique rien après l'appel de la fonction. MAIS la paire de parenthèses vides reste obligatoire. La fonction du robot lanceur de pièce de cet exercice s'écrira donc lancePiece ();

Pourquoi une majuscule à Piece ? Pour la compréhension du code, on appelle les fonctions par des noms « qui veulent dire quelque chose ». Avoir un script avec une vingtaine de fonctions appelées a, A, B, c, C0,... deviendrait rapidement incompréhensible même pour la personne qui l'a écrit. On essaie donc de nommer les fonctions par des noms aussi proches que possibles de leurs actions. Il est de coutume, en JavaScript, d'écrire ces noms en minuscules mais, lorsque la compréhension suggère d'utiliser plusieurs mots accolés, chaque nouveau mot prend une majuscule afin de faciliter la lecture. Par exemple, il est plus facile de lire attrapeLaPiece (); que attrapelapiece ();.

On y va ???

 Ton défi, ta tâche 

Le robot lanceur de pièce

Réalise ton code pour que le robot affiche le bon côté de la pièce.

Le robot est capable de lancer une pièce en l'air, de la rattraper et d'afficher si la face visible est Pile ou Face.

Pour pouvoir effectuer cela, il est capable de traiter une structure conditionnelle, à savoir un système qui lui permet d'observer la pièce, de tester une condition et, en fonction du résultat de ce test, d'afficher le bon côté de la pièce observé. Voici la description de cette structure.

 La structure de contrôle conditionnelle 

Dans la vie courante, nous devons parfois tester certaines conditions avant d'agir. C'est le cas quand nous voulons sortir de chez nous, notre mécanisme mental est alors le suivant :

  • si (le résultat du test « il pleut » est true)
    • prends ton parapluie

Nous voyons que, dans ce cas, le fait que la condition renvoie un résultat true provoque une action, mais si le résultat est false, rien ne se passe, la vie suit son cours.

En revanche, il y a des circonstances dans lesquelles le résultat false de la condition devra entraîner une autre action. C'est le cas par exemple lorsque nous devons jeter un déchet. Ce qui se passe dans notre esprit est le mécanisme suivant :

  • si (le résultat du test « le déchet est recyclable » est true)
    • jette le déchet dans le sac à recyclage
  • sinon
    • jette le déchet dans le sac à déchets non recyclables

Comme on peut s'en apercevoir en examinant cette structure de plus près, quel que soit le résultat du test, nous accomplirons une des deux actions, mais jamais les deux en même temps.

Si le résultat du test est true, nous allons accomplir l'action qui suit directement le test. Arrivé au sinon, nous allons « sauter » l'action qui s'y trouve pour poursuivre le code après celle-ci.

En revanche, si le résultat du test est false, nous allons « sauter » l'action qui suit le test pour aller directement à celle qui se trouve dans le sinon et ensuite poursuivre le restant du code.

Mais, s'il y a plusieurs actions, comment savoir le nombre d'actions à « sauter » ? On part du principe qu'il n'y aura jamais qu'une action unique dans le si et une action unique dans le sinon (qui est facultatif). S'il y a plusieurs actions, elles seront regroupées en une seule en les entourant d'accolades « { » et « } ». Ces accolades sont donc facultatives si l'action est unique et obligatoires si le si ou le sinon contient plusieurs actions à réaliser.

 Et en JavaScript, ça donne quoi ? 

Voici la syntaxe en JavaScript des différents cas possibles :

  • if (test)
    • instructionUnique;

Remarque : la structure suivante est correcte...

  • if (test) {
    • instructionUnique;
    }
  • if (test) {
    • instruction1;
    • instruction2;
    • instruction3;
    }
  • if (test)
    • instructionUnique;
  • else {
    • instruction1;
    • instruction2;
    }
  • if (test) {
    • instruction1;
    • instruction2;
    }
  • else
    • instructionUnique;
  • if (test) {
    • instruction1;
    • instruction2;
    }
  • else {
    • instruction3;
    • instruction4;
    }

Il est à remarquer que l'indentation (la mise en retrait) des instructions contenues dans la conditionnelle n'a aucune importance au niveau de l'exécution du code, mais c'est une bonne pratique à acquérir pour faciliter la lecture des scripts.

 Les fonctions disponibles 

Chaque robot sera doté de fonctions particulières selon ses spécifités. Fondamentalement, toutes ces fonctions se ressemblent et ont le même rôle, exécuter ce qu'on leur demande de faire. Nous allons toutefois attirer ton attention sur deux formes de résultats possibles :

  1. Les fonctions d'actions qui vont commander au robot d'effectuer une action bien précise;
  2. Les fonctions de tests qui vont demander au robot de tester une condition et qui vont « retourner » un résultat soit true soit false.

Les fonctions disponibles dans l'exercice qui suit sont les suivantes :

  1. La fonction d'action lancePiece (); sans argument : le robot lance la pièce en l'air et la rattrape;
  2. La fonction d'action signale ('cote'); avec l'argument 'cote' qui devra être soit 'pile', soit 'face' : le robot affichera le résultat en fonction de la chaîne de caractères que tu mentionneras;
  3. La fonction de test cotePile (); qui « renverra » true si la face visible de la pièce rattrapée est bien « pile » ou false si ce n'est pas le cas.

Bon travail, mets bien en pratique tout ce que tu viens de lire ci-dessus.

Retour