Manipulez variables, types et logique de programme

Dans le chapitre précédent, vous avez vu qu’un programme back-end reçoit des informations, les traite, puis produit un résultat. Pour écrire cette logique, vous avez besoin de quelques briques fondamentales : les variables, les types, les conditions, les boucles et les fonctions.

Ces notions existent dans tous les langages de programmation. Leur syntaxe change selon que vous utilisez Java, Python ou C#, mais leur rôle reste le même. Dans ce chapitre, vous allez donc les découvrir en pseudo-code, pour vous concentrer sur le raisonnement plutôt que sur les règles d’écriture d’un langage précis.

Stockez des informations avec des variables

Un programme manipule des informations en permanence : un nom, un prix, une quantité, un statut, un message, une date, un résultat de calcul. Pour pouvoir utiliser ces informations, il doit les stocker quelque part.

C’est le rôle d’une variable.

Une variable est un nom associé à une valeur. Vous pouvez l’imaginer comme une étiquette posée sur une information, pour pouvoir la retrouver et l’utiliser plus tard.

Par exemple :

nom_produit = "Sac à dos"
prix = 45
stock = 12

Ici, le programme garde trois informations en mémoire :

• nom_produitcontient le texte"Sac à dos";

• prixcontient le nombre45;

• stockcontient le nombre12.

Le nom de la variable doit être clair. Si vous lisezstock, vous comprenez immédiatement que cette variable représente une quantité disponible. Mais, si vous lisezx, son rôle n’est pas clair du tout.

Une variable peut aussi être utilisée dans un calcul :

prix = 45
quantité = 2
total = prix * quantité

afficher total

Dans cet exemple, le programme utilise les valeurs deprixetquantité, calcule untotal, puis affiche le résultat.

Une variable peut enfin changer de valeur pendant l’exécution du programme. C’est utile quand une information évolue.

stock = 12
stock = stock - 1

afficher stock

Au départ,stockvaut12. Ensuite, le programme enlève1. La nouvelle valeur destockdevient donc11.

Distinguez les types de données

Toutes les informations manipulées par un programme ne sont pas de même nature. Un nom, un prix, une quantité et une réponse oui/non ne se traitent pas de la même manière.

C’est ce qu’on appelle le type d’une donnée.

Voici les types de base que vous rencontrerez très souvent :

Le type est important parce qu’il influence ce que le programme peut faire avec une donnée.

Par exemple, vous pouvez additionner deux nombres :

prix = 45
frais_livraison = 5
total = prix + frais_livraison

Mais additionner un texte et un nombre n’a pas le même sens :

nom_produit = "Sac à dos"
prix = 45
résultat = nom_produit + prix

Selon le langage utilisé, cette instruction peut provoquer une erreur, produire un résultat inattendu ou nécessiter une transformation préalable. Le point important à retenir est simple : avant de manipuler une donnée, demandez-vous toujours de quel type elle est.

Les booléens sont particulièrement utiles pour exprimer des états simples :

produit_disponible = true
utilisateur_connecté = false

Ces valeurs peuvent ensuite servir dans des conditions, que vous allez découvrir maintenant.

Prenez des décisions avec des conditions

Un programme ne suit pas toujours le même chemin. Il doit souvent choisir quoi faire selon une situation.

C’est le rôle des conditions. Vous en avez déjà vu un premier exemple au début du cours avec la structureSI / SINONutilisée pour vérifier si une commande était possible.

Une condition permet de dire :

SI une situation est vraie
    faire une action
SINON
    faire une autre action
FIN SI

Reprenons l’exemple du stock :

stock = 12
quantité_demandée = 2

SI quantité_demandée <= stock
    afficher "Commande possible"
SINON
    afficher "Stock insuffisant"
FIN SI

Le programme comparequantité_demandéeetstock.

• Si la quantité demandée est inférieure ou égale au stock, il affiche"Commande possible".

• Sinon, il affiche"Stock insuffisant".

Cette comparaison utilise l’opérateur<=(inférieur ou égal à). Vous rencontrerez plusieurs opérateurs de comparaison, qui s’écrivent presque toujours de la même façon d’un langage à l’autre :

Cette logique est très fréquente en back-end. Elle permet d’appliquer des règles simples :

• si une donnée est valide, continuer ;

  • sinon, afficher une erreur ;

• si un utilisateur est connecté, autoriser une action ;

  • sinon, demander une connexion ;

• si un fichier existe, le lire ;

  • sinon, signaler qu’il manque.

Une condition peut aussi utiliser plusieurs vérifications. Par exemple :

stock = 12
quantité_demandée = 2
paiement_validé = true

SI quantité_demandée <= stock ET paiement_validé = true
    afficher "Commande confirmée"
SINON
    afficher "Commande impossible"
FIN SI

Ici, deux conditions doivent être vraies en même temps : le stock doit être suffisant, et le paiement doit être validé.

À l’inverse, on utiliseOUquand une seule des deux conditions suffit :

SI utilisateur_est_admin OU utilisateur_est_propriétaire
    autoriser la modification
SINON
    refuser la modification
FIN SI

Ici, une seule des deux vérifications a besoin d’être vraie pour que l’action soit autorisée.ETexige que toutes les conditions soient vraies ;OUaccepte qu’au moins une le soit.

Regroupez plusieurs valeurs dans un tableau ou une liste

Un programme manipule rarement une seule information à la fois. Quand vous avez plusieurs valeurs du même type — par exemple plusieurs produits, plusieurs prix ou plusieurs noms — vous pouvez les regrouper sous un seul nom. Deux notions permettent de le faire : le tableau et la liste.

Un tableau est une suite de valeurs rassemblées sous un seul nom :

prix = [12, 8, 25, 4]
plats = ["Pizza", "Salade", "Burger"]

Ici,prixcontient quatre nombres, etplatscontient trois textes. Chaque valeur reste accessible individuellement, mais toutes appartiennent au même ensemble.

Pour accéder à une valeur précise, on utilise sa position dans le tableau, appelée indice. Dans la plupart des langages, les indices commencent à0:

premier_plat = plats[0]
deuxième_plat = plats[1]

Ici,plats[0]vaut"Pizza"etplats[1]vaut"Salade".

Un tableau a une caractéristique importante : sa taille est fixe. Le nombre d’éléments qu’il peut contenir est décidé à sa création et ne change pas ensuite.

Quand vous avez besoin de faire évoluer ce nombre au fil du programme — ajouter un élément, en retirer un — vous utilisez plutôt une liste. Une liste ressemble beaucoup à un tableau, mais sa taille peut changer :

plats = ["Pizza", "Salade", "Burger"]
ajouter "Tiramisu" à plats
retirer "Salade" de plats

Après ces deux opérations,platscontient["Pizza", "Burger", "Tiramisu"]. La liste s’est adaptée toute seule.

Dans les exemples qui suivent, vous verrez que ces structures sont particulièrement utiles pour appliquer un même traitement à plusieurs éléments. C’est le rôle des boucles, que vous allez découvrir maintenant.

Répétez une action avec une boucle

Un programme doit parfois répéter la même action plusieurs fois.

Imaginez une liste de produits. Si vous voulez afficher chaque produit, vous n’allez pas écrire manuellement une instruction pour le premier produit, puis une autre pour le deuxième, puis une autre pour le troisième. Vous utilisez une boucle.

Une boucle permet de répéter une action tant qu’une situation le demande, ou pour chaque élément d’une liste.

Par exemple :

POUR CHAQUE produit DANS liste_des_produits
    afficher produit
FIN POUR

Ce pseudo-code signifie : pour chaque produit présent dans la liste, affiche ce produit.

Si la liste contient trois produits, l’action sera répétée trois fois. Si elle en contient dix, elle sera répétée dix fois. Le programme s’adapte à la quantité de données.

Les boucles sont très utiles pour :

• parcourir une liste d’éléments ;

• appliquer le même traitement à plusieurs données ;

• compter des éléments ;

• rechercher une information ;

• afficher plusieurs résultats.

Prenons un exemple un peu plus concret : imaginons que vous voulez repérer les produits à réapprovisionner.

POUR CHAQUE produit DANS liste_des_produits
    SI produit.stock = 0
        afficher produit.nom
    FIN SI
FIN POUR

Ici, le programme parcourt la liste des produits. Pour chaque produit, il vérifie si le stock vaut0. Si c’est le cas, il affiche le nom du produit pour signaler qu’il n’est plus disponible et qu’il faut peut-être le recommander.

Vous voyez ici deux notions travailler ensemble : la boucle répète l’action, et la condition décide quoi faire pour chaque élément.

Regroupez une logique avec des fonctions

Quand une suite d’instructions sert à réaliser une action précise, vous pouvez la regrouper dans une fonction.

Une fonction est un bloc de logique auquel on donne un nom. Elle permet d’éviter de répéter le même code à plusieurs endroits et de rendre le programme plus lisible.

Par exemple, imaginons une règle qui vérifie si un produit est disponible :

FONCTION vérifier_disponibilité(stock, quantité_demandée)
    SI quantité_demandée <= stock
        retourner true
    SINON
        retourner false
    FIN SI
FIN FONCTION

Cette fonction reçoit deux informations :stocketquantité_demandée. Elle compare ces deux valeurs, puis retournetrueoufalse.

On peut ensuite utiliser cette fonction ailleurs dans le programme :

disponible = vérifier_disponibilité(12, 2)

SI disponible = true
    afficher "Commande possible"
SINON
    afficher "Stock insuffisant"
FIN SI

L’intérêt est double.

D’abord, le nom de la fonction explique ce qu’elle fait :vérifier_disponibilité. Ensuite, la logique est regroupée à un seul endroit. Si la règle change plus tard, il sera plus facile de la retrouver et de l’adapter.

Quand vous lisez un code existant, repérer les fonctions peut beaucoup vous aider. Une fonction bien nommée donne un indice sur l’intention du programme : calculer un total, vérifier un stock, lire un fichier, afficher un message, transformer une donnée.

À vous de jouer

L’équipe a enrichi le menu du chapitre 2 : chaque plat a maintenant une disponibilité. Dans l’ordre — Pizza, Salade, Burger et Tiramisu — ces disponibilités sont regroupées dans une liste :

disponibilites = [true, false, true, true]

Votre mission : écrivez, en pseudo-code, une seule fonctionnb_plats_disponibles(disponibilites)qui reçoit cette liste et retourne le nombre de plats disponibles.

Pour vous guider :

1. La fonction doit prendre la liste en paramètre et retourner un nombre sans l’afficher.

2. À l’intérieur, initialisez une variable compteur à0.

3. Parcourez la liste avec une boucle.

4. Pour chaque disponibilité, utilisez une condition ; si sa valeur esttrue, incrémentez le compteur.

5. Retournez le compteur à la fin.

Vérifiez votre raisonnement à la main : avec la liste proposée, la fonction doit retourner3.

En résumé

• Une variable permet de stocker une information pour l’utiliser plus tard.

• Un type décrit la nature d’une donnée : texte, nombre, booléen, etc.

• Une condition permet à un programme de prendre une décision.

• Un tableau regroupe plusieurs valeurs sous un seul nom avec une taille fixe ; une liste fait la même chose, mais sa taille peut évoluer.

• Une boucle permet de répéter une action, souvent pour chaque élément d’un tableau ou d’une liste.

• Une fonction regroupe une logique réutilisable sous un nom clair.

• Ces notions existent dans tous les langages back-end, même si leur syntaxe change.

Vous savez maintenant manipuler les premières briques de la logique de programme. Dans le prochain chapitre, vous allez découvrir une autre façon d’organiser le code : la programmation orientée objet, avec les notions de classe, d’objet, d’attribut et de méthode.