Chapitre 10
Les bases de la programmation - Conditions et boucles

Seconde et dernière partie de l'introduction à la programmation. Précédemment, nous avons vu les différents types de variables. Certains sont primitifs, représentant des nombres, des chaînes de caractères ou des collections de données. Le développeur peut aussi créer ses propres types pour représenter le métier de l'entreprise.

Nous avons rapidement évoqué le concept de fonction : un algorithme est appliqué sur des données en entrée pour fournir des données en sortie.

function additionner(a: number, b: number): number {
    return a + b
}

Ici, nous allons apprendre les éléments de base qui composent cet algorithme : les conditions et les boucles.

La théorie est assez simple. Ce sont ces fondamentaux et ces façons de raisonner qui sont maintenant appris dans les écoles dès le plus jeune âge. On verra que la pratique réserve quelques surprises !

Les conditions

Si ceci est vrai, fais ci, sinon, fais ça.

Une condition est un ensemble d'instructions dont le résultat est évalué en vrai ou faux :

• Est-ce que mon âge est inférieur à 35 ans ?
• Est-ce que mon frigo est vide ?
• Est-ce que mon téléphone est un Android ?

Les mots-clés utilisés dans la plupart des langages sont if (si), elseif (sinon si) et else (sinon).
Exemple : S'il fait beau, je vais au parc, sinon, je passe la journée devant Netflix.

if (meteo === 'soleil') {
    sortirAuParc()
} else {
    allumerNetflix()
}

Les instructions peuvent s'enchainer à l'aide d'opérateurs logiques :

• NON, écrit NOT ou "!". C'est pour évaluer une condition inverse.
  
  Exemple : S'il ne pleut pas, je vais au parc.
• ET, écrit AND ou "&&". Les deux parties doivent être vraies pour que l'ensemble soit vrai.
  
  Exemple : Si j'aime la bière ET que ma réservation pour mon voyage en Belgique se passe bien, alors : j'irais visiter une brasserie.
  
  Le piège du ET, c'est que dès qu'une partie est fausse, on sait que l'ensemble est faux, le reste n'est donc pas exécuté.
  Dans l'exemple, on pensait écrire "j'ai une réservation en Belgique, puisqu'en plus j'aime la bière, alors je vais visiter une brasserie". Là on a plutôt écrit "puisque j'aime la bière, alors je fais une réservation en Belgique et je vais visiter une brasserie". La réservation du voyage ne se fera pas pour quelqu'un qui n'aime pas la bière.
  
  Attention donc à l'ordre dans la condition !
• OU, écrit OR ou "||". Une seule des parties a besoin d'être vraie pour que l'ensemble soit vrai.
  
  Exemple : Si j'ai actuellement moins de 1000€ sur mon compte OU qu'après m'être payé j'ai moins de 2000€ sur mon compte, alors : je pioche dans ma réserve secrète.
  
  Le piège du OU, c'est que dès qu'une partie est vraie, on sait que l'ensemble est vrai, le reste n'est donc pas exécuté.
  Dans l'exemple, si l'action "après m'être payé" provoque l'action "me payer", elle risque de ne pas s'exécuter et je me retrouve sans salaire.
• OU EXCLUSIF, écrit "XOR" ou "^". Une seule des parties doit être vraie pour que l'ensemble soit vrai.
  
  Exemple : Si SEULEMENT Anne OU SEULEMENT Ben est là, alors la soirée sera cool. Sinon, ce sera bizarre car ils ne s'entendent pas.
• Plus rares en programmation, il existe aussi des variations : NON ET, NON OU, NON OU EXCLUSIF.

Dans le chapitre précédent, nous avons parlé du type qui représente des valeurs "vraies" ou "fausses" : les booléens. Ce nom vient du mathématicien George Boole, créateur de l'algèbre de Boole, qui a jeté les bases de la théorie des circuits numériques et de l'informatique moderne. L'algèbre de Boole est une branche des mathématiques concernant les opérations sur les booléens. Les développeurs s'en servent quotidiennement !

Quelques exemples :

• Double négation : le contraire du contraire de "il fait beau" est "il fait beau".
• Commutativité : il fait "beau" et "chaud" revient au même qu'il fait "chaud" et "beau".
• Associativité : je bois du Café OU Thé OU Eau = (Café OU Thé) OU Eau = Café OU (Thé OU Eau)

C'est évident avec des petits exemples comme ça mais c'est parfois un vrai casse tête sur des cas métiers complexes.

Un autre mathématicien, De Morgan, a formalisé des lois sur les négations qui nous aident beaucoup pour ne pas nous emmêler les pinceaux et simplifier des conditions :
NON(A ET B) = NON(A) OU NON(B)
NON(A OU B) = NON(A) ET NON(B)

Exemple 1 : l'inverse de "je suis développeur web et freelance" : NON(développeur web ET freelance) =
Soit je ne suis pas "développeur web", soit pas "freelance" : NON(développeur) OU NON(freelance).

Exemple 2 : l'inverse de "je bois du café ou du thé" : NON(café OU thé) =
Je ne bois ni de café, ni de thé : NON(café) ET NON(thé).


Cet algèbre de Boole ne peut fonctionner que si le résultat des instructions autour des opérateurs logiques est un booléen. Sauf que ce n'est pas toujours le cas... Certaines instructions sont des appels de fonctions qui peuvent retourner n'importe quel type de valeur. L'interpréteur du langage doit donc implicitement convertir ces données en booléen. La règle est simple : ce qui n'est pas faux, est vrai.

La plupart des langages assimilent comme faux : le chiffre 0, une chaîne de caractères vide, une collection vide, une variable non initialisée.

On profite de ce comportement notamment pour tester l'existence de quelque chose.

mesLivres = chercherLesLivresDansLaBibliotheque()

if (mesLivres) {
    // Il y a des livres dans la bibliothèque.
} else {
    // La bibliothèque est vide.
}

Les conditions font partie de la gymnastique quotidienne des développeurs. Les cas complexes avec de multiples variantes les obligent à réorganiser leur code afin de maintenir une bonne compréhension et éviter des bugs.

Les boucles

Exécute ceci tant que cela est vrai.

Une boucle est un moyen d'exécuter plusieurs fois le même code. Il en existe plusieurs types :

• Tant que cette condition est vraie.
  Exemple : tant que j'ai faim, je continue de manger. Les mots-clés principaux sont "while" et "for".
• Pour chaque élément de cette collection.
  Exemple : envoie la newsletter à chaque abonné. Mot-clé : foreach.

while (!leVerreEstVide) {
    boire()
}

listeCourses = ["Pommes", "Bananes"]

listeCourses.forEach((article) => {
    acheter(article)
})

La récursivité

Une fonction récursive est une fonction qui se rappelle elle-même. Tout comme les boucles, c'est un moyen d'exécuter plusieurs fois le même code. C'est utile pour parcourir une hiérarchie d'éléments imbriqués dans d'autres éléments et pour appliquer le même traitement sur toute la chaine.

Exemple : je veux connaître le nombre de descendants d'une personne. On va parcourir récursivement toutes les branches de son arbre généalogique.

function compterDescendants(personne) {
    enfants = trouverLesEnfants(personne)

    nombreDescendants = enfants.length

    enfants.forEach((enfant) => {
        nombreDescendants += compterDescendants(enfant)
    })

    return nombreDescendants
}

Certaines récursivités sont moins directes. Une fonction 1 appelle une fonction 2 qui rappelle la fonction 1. Une mauvaise conception peut facilement générer une boucle infinie, consommer toutes les ressources de la machine et ainsi tuer la production.
Prudence donc !



C’est la fin de cette initiation à la programmation.
Tu as maintenant tous les outils de base pour commencer à écrire de petits algorithmes et approfondir la programmation par toi-même.