Admin/Dev

22
Févr.
2019

Les bases de la programmation - Partie 3

Publié par sky

Suite à la publication des articles dédiés à l'écriture d'un MasterMind en Javascript, je me dis qu'il était enfin temps de donner une suite aux articles sur les bases de la programmation, publié, il y a 14 ans de cela. Reprenons, exactement ou nous nous étions arrêté. Avec les deux premiers articles, les variables n'avaient plus de secret pour nous, quel que soit leur type, numérique, texte, liste ou matrice.

Attaquons une partie très importante de la programmation, avec des instructions, qui sont exécutées des milliards de fois par seconde sur l'ensemble des programmes actuellement en action.

Il est possible grâce à l'instruction if de faire tester une condition, afin d'exécuter, ou non, des instructions spécifiques.

La condition, peut être toute simple, avec une simple vérification numérique ou un comparateur de chaîne, mais aussi plus complexe, avec l'utilisation d'une fonction.

Dans tous les cas, l'instruction ne sera exécuté que si la condition est vérifiée.

Par exemple, imaginons, une variable numérique a, et réalisons des tests.

a = 5;
if (a == 0)
alert("a est egal a 0");
if (a == 5)
alert("a est egal a 5");
if (a == 'test')
alert("a est egal a test");

En executant ce code, vous devriez obtenir une seule et unique alerte, vous indiquant que a est égal à 5.

Comme vous pouvez le voir, pour vérifier qu'une valeur est égale à une autre, nous utilisons un signe double égal. Car le simple égal permet d'assigner une valeur, mais pas de tester.

Sur les numériques, vous pouvez utiliser tous les signes mathématiques : ==, <, >, >=, <=.

Pour les chaînes de caractères, seul le double égal est disponible afin de vérifier si une chaîne est égale à une autre.

a = 'test';
if (a == 0)
alert("a est egal a 0");
if (a == 5)
alert("a est egal a 5");
if (a == 'test')
alert("a est egal a test");

Cela devrait vous envoyer une alerte, vous confirmant que a est égal à "test".

Pour les listes, c'est un peu plus compliqué. Vous pouvez comparer l'intégralité de la liste ou seulement l'une des valeurs. Dans ce dernier cas, il faudra appliquer une condition compatible avec le type de la valeur.

a = new Array(4, 5);
if (a[0] == 4)
alert("la premiere valeur de a est bien 4");
if (a[1] == 5)
alert("la seconde valeur de a est bien 5");
if (a[1] == 4)
alert("la seconde valeur de a n est pas 4");
if (a[2] == 4)
alert("la troisieme valeur de a n existe pas, et ne peut donc pas etre 4");

Evidemment, il est possible de comparer les valeurs entre elles.

a = 5;
b = 4;
if (a == b)
alert("a est egal a b");
if (a < b)
alert("a est inferieur a b");
if (a > b)
alert("a est superieur a b");
if (a == b + 1)
alert("a est egale a b + 1");
b = b + 1; if (a == b)
alert("a est egal a b apres mise a jour");

Cette fois, les deux dernières conditions vont se vérifier, et vous devriez avoir les deux alertes.

Il est possible d'ajouter, avec l'instruction else, une instruction lorsque la condition ne se vérifie pas.

a = 5;
b = 4;
if (a == b)
alert("a est egal a b");
else alert("a n est pas egale a b");

Comme a n'est pas égal à b, vous devriez obtenir le message correspondant.

Il est possible d'insérer plusieurs instructions dans un if, ou dans un else. Pour cela, il suffit, comme avec les fonctions, de mettre le lot d'instructions entre accolades.

a = 5;
if (a == 5) {
b = 4; alert("comme a est egal a 5, b a ete defini a 4");
} else {
b = 5; alert("comme a n est pas egal a 5, b a ete defini a 5");
}

Et comme je suis sûr que vous trouvez ça trop simple, nous allons fois qu'il est possible de combiner des if et des else pour enchainer les vérifications de conditions.

a = 5;
b = 4;
if (a == b)
alert("a est egal a b");
else if (a < b)
alert("a est inferieur a b");
else if (a > b)
alert("a est superieur a b");

Quelle différence, avec le code vu précédemment ? La différence est subtile, et néanmoins très importante. En effet, le code lorsqu'il a trouvé une condition qui est vraie, ne prend plus le temps de vérifier les autres conditions. Cela permet d'optimiser la vitesse d'exécution, puisqu'une ou plusieurs vérifications ne sont plus faites. C'est sûr, qu'à notre niveau, la différence ne sera pas remarquable, mais imaginez, avec des milliers ou millions de lignes de code à exécuter, cela peut faire une petite différence.

Il faut cependant faire attention, car il est parfois nécessaire d'effectuer tous les tests.

a = 5;
b = 5;
if (a == b)
alert("a est egal a b");
else if (a <= b)
alert("a est inferieur ou egal a b, mais ne sera jamais affiche");
else if (a >= b)
alert("a est superieur ou egal a b, mais ne sera jamais affiche");

Dans cet exemple, les 3 conditions sont vérifiées, cependant, seules les instructions de la premières seront exécutées.

Je le disais au début, il est aussi possible d'utiliser des fonctions directement dans les conditions. Si ces fonctions renvoient un numérique, il est alors possible d'utiliser les conditions vues au dessus. De même pour une fonction renvoyant une chaine.

fonction moyenne(x, y) {
return (x+y)/2;
} a = 4; b = 6; if (moyenne(a,b) > a)
alert("a fait baisser la moyenne");

Si la fonction se suffit à elle, en tant que condition, elle devra renvoyer true ou false.

fonction estCinq(x) {
return (x == 5);
} a = 5; b = 6; if (estCinq(a))
alert("a est egal a 5");
if (estCinq(b))
alert("b est egal a 5");

Au final, nous n'avons fait que déplacer la condition depuis l'instruction if vers la fonction. La grande différence est que la fonction peut être plus complexe que cela, et intégré bien plus d'instructions. Ce qui est bien plus facile à gérer que de tout mettre dans une seule condition.

D'ailleurs, rien n'empêche cette fonction de contenir elle-même des instructions if, else ou d'autres fonctions.

Maintenant que vous pensiez maîtriser les conditions, voyons comment il est possible de vérifier plusieurs conditions à la fois.

Pour vérifier la valeur de a ET la valeur de b, actuellement nous ferions

a = 5;
b = 6;
if (a == 5) {
if (b == 6) {
alert("a est bien egal a 5, et b a 6");
}
}

Il est possible de rassembler les deux tests en une seule condition, et ainsi réduire la taille du script tout en en augmentant la lisibilité.

Ce ET se traduit par un "and" en anglais. Malheureusement, javascript n'est pas très sympa à ce niveau, et le note &&.

Voici le même code modifié

a = 5;
b = 6;
if (a == 5 && b == 6)
alert("a est bien egal a 5, et b a 6");

Plus subtil, il est aussi possible de tester un OU, en anglais "or". Ainsi si l'un ou l'autre des deux tests de la condition se vérifie, la condition est remplie, et les instructions s'exécutent. Le or est représenté par un double pipe, noté ||. Sur Mac, ce caractère s'obtient, avec la combinaison de touches option+majuscule+L.

a = 5;
b = 4;
if (a == 5 || b == 6)
alert("a est bien egal a 5, mais b n est pas egal a 6");

Attention, comme pour le else vu précédemment, un seul des tests vérifié est nécessaire, l'exécution du code ne fera pas les autres tests.

Nous pouvons le vérifier de la manière suivante

fonction test1() {
alert("execution du test 1"); return true;
} fonction test2() {
alert("execution du test 2"); return true;
} if (test1() || test2())
alert("verification effectuee");

Vous aurez ici deux alertes, la première pour le test 1, et la seconde indiquant la vérification de la condition. Vous pouvez faire le test par vous même, en mettant un "and", au lieu du "or", vous aurez les 3 alertes.

Le "and" aura l'effet inverse, au premier test raté, la condition s'arrêtera et n'exécutera pas les autres. Si vous êtes aussi sceptique que moi, vous voudrez le tester.

fonction test1() {
alert("execution du test 1"); return false;
} fonction test2() {
alert("execution du test 2"); return true;
} if (test1() || test2())
alert("verification effectuee avec succes");
else alert("verification effectuee avec un echec");

test1 renvoyant faux directement, nous n'irons pas dans test2, peut importe ce qu'il y avait dedans, cela ne sera pas exécuté à ce moment là.

Il n'y a pas de limite au nombre de tests que vous pouvez mettre dans une condition. Si multiplier les "and" ou les "or" n'est vraiment pas un soucis, mélanger les deux peut s'avérer beaucoup plus complexe. Pour cela, il sera peut être nécessaire de faire comme en mathématique, et d'ajouter des parenthèses afin de prioritiser les tests.

a = 5;
b = 4;
if ((a == b && a == 4) || (a == 5 && b == 4))
alert("c est complexe mais cela se verifie");

Pour finir sur cette partie, il reste une chose à voir : la négation. Il est possible de retourner une condition pour demander l'inverse. Par exemple, pour vérifier que a n'est pas égal à b.

a = 5;
b = 4;
if (!(a == b))
alert("a est different de b");

Il est possible d'inverser toutes les conditions, y compris les fonctions. A savoir, lorsqu'il s'agit de la vérification d'une différence, il est possible de contracter la négation et le double égal pour obtenir le signe différent, tel que

a = 5;
b = 4;
if (a != b)
alert("a est different de b");

Prochaine étape ? Nous verrons comment gérer les boucles pour faire des programmes toujours plus complexes.

 
Sommaire de la série
 
 
Commentaires
Aucun commentaire pour le moment.

 

Poster un commentaire
En postant sur skymac.org, je m'engage à être courtois et à ce que mon message soit pertinent avec le sujet de l'article.
En outre, j'accepte, sans condition, que mon message soit refusé et supprimé si ces règles ne sont pas appliquées.
Les cookies assurent le bon fonctionnement de nos services. En continuant, vous acceptez leur utilisation sur notre site internet.
Accepter