La programmation et les algorithmes

Un algorithme est une séquence finie et non ambiguë d'instructions ou d'opérations claires et précises, permettant de résoudre un problème donné ou d'accomplir une tâche spécifique. Imaginez une recette de cuisine : elle vous donne des étapes précises (mélanger les ingrédients, cuire à telle température pendant tant de temps) pour obtenir un plat. Un algorithme, c'est la même chose pour un ordinateur.

Key Concepts:

• Définition d'un algorithme : C'est une procédure systématique et finie pour résoudre un problème. Il doit être compréhensible par celui qui l'exécute (humain ou machine) et doit toujours aboutir à un résultat.
• Séquence d'instructions : Les étapes doivent être ordonnées logiquement. L'ordre est crucial ; changer l'ordre peut donner un résultat complètement différent ou aucun résultat.
• Résolution de problèmes : Le but ultime d'un algorithme est de transformer des données d'entrée en données de sortie désirées, en résolvant un problème.
• Exemples quotidiens : Nous utilisons des algorithmes sans le savoir tous les jours :
  • Prendre le bus : vérifier l'heure, trouver l'arrêt, attendre le bus, monter, payer, descendre.
  • Chercher un mot dans un dictionnaire : ouvrir au milieu, si le mot est avant, aller à gauche, sinon aller à droite, répéter jusqu'à trouver.
  • Calculer une moyenne : additionner toutes les notes, diviser par le nombre de notes.

Un algorithme est la "logique" derrière un programme informatique. Avant d'écrire du code, on pense à l'algorithme.

Concevoir un algorithme est un processus structuré qui permet de s'assurer que la solution est robuste et efficace.

Key Concepts:

• Analyse du problème : C'est la première et la plus importante étape. Il faut comprendre précisément ce que l'on attend de l'algorithme.
  • Quelles sont les données d'entrée (inputs) ?
  • Quels sont les résultats attendus (outputs) ?
  • Quelles sont les contraintes (taille des données, temps d'exécution, etc.) ?
  • Exemple : Calculer la moyenne de notes. Entrées : une liste de notes. Sortie : la moyenne. Contraintes : les notes sont entre 0 et 20.
• Conception de l'algorithme : Une fois le problème bien compris, on élabore la séquence d'instructions.
  • On décompose le problème en sous-problèmes plus petits et plus faciles à résoudre.
  • On utilise des techniques comme le pseudo-code ou les organigrammes pour structurer les idées.
• Test et validation : Après avoir écrit l'algorithme (ou l'avoir transformé en code), il est crucial de le tester.
  • On utilise des jeux de données de test (entrées connues avec des sorties attendues) pour vérifier que l'algorithme se comporte comme prévu.
  • On cherche les erreurs (bugs) et on les corrige.
  • Exemple : Tester la moyenne avec des notes toutes identiques, avec des 0, avec des 20, avec une seule note.
• Optimisation : Une fois que l'algorithme fonctionne correctement, on peut chercher à l'améliorer.
  • Rendre l'algorithme plus rapide (moins d'opérations).
  • Rendre l'algorithme plus efficace (moins de mémoire utilisée).
  • Rendre le code plus lisible et maintenable.
  • L'optimisation ne doit être envisagée qu'après avoir validé la correction de l'algorithme. Un algorithme rapide mais faux n'a aucun intérêt.

Pour exprimer un algorithme, il existe plusieurs méthodes, chacune ayant ses avantages.

Key Concepts:

• Pseudo-code : C'est une description de l'algorithme qui ressemble à du code de programmation, mais sans respecter une syntaxe stricte d'un langage particulier. Il utilise des mots clés courants (SI, ALORS, SINON, TANT QUE, POUR) et est facilement compréhensible par un humain. C'est la méthode la plus utilisée en terminale.
  • Avantages : Indépendant de tout langage de programmation, facile à écrire et à lire.
  • Exemple :

    DEBUT Algorithme CalculMoyenne
        LIRE nombreNotes
        sommeNotes = 0
        POUR i ALLANT DE 1 A nombreNotes FAIRE
            LIRE note
            sommeNotes = sommeNotes + note
        FIN POUR
        moyenne = sommeNotes / nombreNotes
        AFFICHER "La moyenne est : ", moyenne
    FIN Algorithme
    

• Organigrammes (flowcharts) : C'est une représentation graphique de l'algorithme, utilisant des symboles standardisés pour représenter les différentes étapes et les flux de contrôle.
  • Avantages : Visuel, facile à suivre pour des algorithmes simples.
  • Inconvénients : Peut devenir très complexe et difficile à lire pour des algorithmes sophistiqués.
  • Les symboles courants incluent :
    • Ovale : Début/Fin
    • Parallélogramme : Entrée/Sortie de données
    • Rectangle : Traitement/Opération
    • Losange : Décision/Condition (oui/non)
    • Flèche : Sens du flux
• Langage naturel structuré : Utilise des phrases claires et concises avec une structure logique pour décrire les étapes. C'est moins formel que le pseudo-code.
  • Avantages : Très facile à comprendre pour les non-initiés.
  • Inconvénients : Peut manquer de précision et d'uniformité, rendant la traduction en code plus difficile.
  • Exemple :
    1. Demander à l'utilisateur le nombre de notes.
    2. Initialiser la somme des notes à zéro.
    3. Pour chaque note, demander à l'utilisateur de saisir la note et l'ajouter à la somme.
    4. Calculer la moyenne en divisant la somme par le nombre de notes.
    5. Afficher la moyenne calculée.

Une variable est un espace de stockage nommé en mémoire qui peut contenir une valeur. Pensez à une boîte étiquetée : l'étiquette est le nom de la variable, et la boîte contient une valeur.

Key Concepts:

• Déclaration de variables : C'est le processus par lequel on donne un nom à une variable et on lui attribue un type de données. Dans certains langages, c'est explicite (ex: int age;), dans d'autres, c'est implicite (ex: age = 18).
• Types numériques :
  • Entiers (Integer) : Nombres sans partie décimale (ex: 5, -10, 0). Souvent notés int ou entier.
  • Réels (Float ou Double) : Nombres avec une partie décimale (ex: 3.14, -0.5, 10.0). Souvent notés float ou réel.
• Types textuels (Chaînes de caractères - String) : Séquences de caractères (lettres, chiffres, symboles). Elles sont généralement délimitées par des guillemets.
  • Ex: "Bonjour le monde", "123 rue de la Paix". Souvent noté string ou chaîne.
• Types booléens (Boolean) : Ne peuvent prendre que deux valeurs : Vrai (True) ou Faux (False). Ils sont essentiels pour les décisions logiques.
  • Ex: estMajeur = Vrai. Souvent noté bool ou booléen.

Le type d'une variable détermine le genre de données qu'elle peut stocker et les opérations que l'on peut effectuer dessus.

Les opérateurs sont des symboles qui représentent des actions ou des calculs à effectuer sur des valeurs (appelées opérandes).

Key Concepts:

• Opérateurs arithmétiques : Pour les calculs mathématiques.
  • + : Addition (ex: 5 + 3 donne 8)
  • - : Soustraction (ex: 10 - 4 donne 6)
  • * : Multiplication (ex: 2 * 6 donne 12)
  • / : Division (ex: 15 / 3 donne 5, ou 7 / 2 donne 3.5)
  • % : Modulo (reste de la division entière, ex: 7 % 2 donne 1)
• Opérateurs de comparaison : Pour comparer des valeurs, ils retournent toujours un résultat booléen (Vrai ou Faux).
  • <mark> : Égal à (ex: 5 </mark> 5 est Vrai)
  • != : Différent de (ex: 10 != 7 est Vrai)
  • < : Inférieur à (ex: 3 < 8 est Vrai)
  • > : Supérieur à (ex: 12 > 9 est Vrai)
  • <= : Inférieur ou égal à (ex: 4 <= 4 est Vrai)
  • >= : Supérieur ou égal à (ex: 6 >= 5 est Vrai)
• Opérateurs logiques : Utilisés pour combiner ou modifier des expressions booléennes.
  • ET (AND) : Retourne Vrai si toutes les conditions sont Vraies.
    • Ex: (âge > 18) ET (permis == Vrai)
  • OU (OR) : Retourne Vrai si au moins une condition est Vraie.
    • Ex: (jour <mark> "Samedi") OU (jour </mark> "Dimanche")
  • NON (NOT) : Inverse la valeur booléenne.
    • Ex: NON (estMajeur) (si estMajeur est Vrai, NON (estMajeur) est Faux)

Les opérateurs logiques sont fondamentaux pour construire des conditions complexes.

Les structures conditionnelles permettent à un algorithme de prendre des décisions et d'exécuter différentes séquences d'instructions en fonction de si une condition est Vraie ou Fausse.

Key Concepts:

• Si... Alors... Sinon (If... Then... Else) : C'est la structure conditionnelle de base.

  SI condition ALORS
      // Instructions exécutées si la condition est Vraie
  SINON
      // Instructions exécutées si la condition est Fausse
  FIN SI
  

  • Le bloc SINON est facultatif. Si la condition est Fausse et qu'il n'y a pas de SINON, l'algorithme continue simplement après la structure SI.
  • Exemple :

    SI temperature > 25 ALORS
        AFFICHER "Il fait chaud !"
    SINON
        AFFICHER "La température est agréable."
    FIN SI
    

• Conditions imbriquées : On peut placer une structure conditionnelle à l'intérieur d'une autre.

  SI condition1 ALORS
      SI condition2 ALORS
          // Instructions si condition1 ET condition2 sont Vraies
      SINON
          // Instructions si condition1 est Vraie ET condition2 est Fausse
      FIN SI
  SINON
      // Instructions si condition1 est Fausse
  FIN SI
  

  • Elles permettent de gérer des scénarios plus complexes mais peuvent rendre le code difficile à lire si elles sont trop nombreuses.
• Expressions booléennes : La condition dans un SI est toujours une expression qui évalue à Vrai ou Faux (une expression booléenne). Elle peut utiliser des opérateurs de comparaison et/ou logiques.
  • Ex: age >= 18 ET nationalite == "Française"

Les boucles permettent de répéter un bloc d'instructions plusieurs fois. Elles sont essentielles pour traiter des collections de données ou pour des tâches répétitives.

Key Concepts:

• Boucle Tant que (While) : Répète un bloc d'instructions tant qu'une condition donnée reste Vraie.
  • La condition est testée avant chaque exécution de la boucle. Si la condition est Fausse dès le début, le bloc ne sera jamais exécuté.

  TANT QUE condition EST VRAIE FAIRE
      // Instructions à répéter
  FIN TANT QUE
  

  • CRITIQUE : Il faut s'assurer que la condition finira par devenir Fausse, sinon on a une boucle infinie !
  • Exemple :

    compteur = 0
    TANT QUE compteur < 5 FAIRE
        AFFICHER "Compteur : ", compteur
        compteur = compteur + 1
    FIN TANT QUE
    // Affichera "Compteur : 0" à "Compteur : 4"
    

• Boucle Pour (For) : Répète un bloc d'instructions un nombre de fois prédéfini ou pour chaque élément d'une collection.
  • Elle est souvent utilisée quand on connaît le nombre d'itérations à l'avance.

  POUR variable DE debut A fin FAIRE
      // Instructions à répéter
  FIN POUR
  

  • Exemple :

    POUR i DE 1 A 10 FAIRE
        AFFICHER "Itération numéro ", i
    FIN POUR
    // Affichera "Itération numéro 1" à "Itération numéro 10"
    

  • Il existe aussi des boucles Pour chaque (ForEach) pour parcourir des collections.
• Boucles imbriquées : Une boucle peut contenir une autre boucle.
  • Utile par exemple pour parcourir des tableaux à deux dimensions (matrices) ou pour des problèmes nécessitant des itérations multiples.
  • Exemple : Afficher une table de multiplication.

    POUR i DE 1 A 3 FAIRE
        POUR j DE 1 A 3 FAIRE
            AFFICHER i, " x ", j, " = ", i * j
        FIN POUR
    FIN POUR
    

    Attention à la complexité des boucles imbriquées, elles peuvent être coûteuses en temps d'exécution.

Une fonction est un sous-programme, c'est-à-dire un bloc d'instructions qui a un nom, peut prendre des données en entrée (appelées paramètres ou arguments) et peut renvoyer une valeur en sortie (appelée valeur de retour).

Key Concepts:

• Modularité du code : Découper un grand programme en petites fonctions permet de le structurer. Chaque fonction gère une partie spécifique du problème. C'est comme construire un Lego pièce par pièce.
• Réutilisabilité : Une fois qu'une fonction est écrite et testée, elle peut être appelée plusieurs fois dans le même programme ou même dans d'autres programmes sans avoir à réécrire son code.
  • Exemple : Une fonction calculer_carré(nombre) peut être utilisée chaque fois que vous avez besoin de calculer le carré d'un nombre.
• Abstraction : Quand vous utilisez une fonction, vous n'avez pas besoin de savoir comment elle fonctionne en interne, mais seulement ce qu'elle fait et comment l'utiliser. C'est comme conduire une voiture : vous n'avez pas besoin de comprendre le moteur pour l'utiliser.
• Découpage du problème : Les fonctions facilitent l'approche "diviser pour régner". Un problème complexe est divisé en sous-problèmes plus simples, chacun résolu par une fonction.
  • Cela rend le développement et le débogage beaucoup plus faciles.

Pour utiliser une fonction, il faut d'abord la déclarer (la définir), puis l'appeler (l'exécuter).

Key Concepts:

• Déclaration de fonctions : C'est l'endroit où vous écrivez le code de la fonction.
  • Elle inclut son nom, la liste de ses paramètres (avec leurs types si nécessaire) et le type de sa valeur de retour.

  FONCTION NomDeLaFonction (parametre1: Type1, parametre2: Type2) : TypeDeRetour
      // Corps de la fonction : instructions
      // ...
      RETOURNER valeur
  FIN FONCTION
  

  • Exemple :

    FONCTION CalculerSomme (a: ENTIER, b: ENTIER) : ENTIER
        resultat = a + b
        RETOURNER resultat
    FIN FONCTION
    

• Paramètres d'entrée : Ce sont les données que la fonction reçoit pour travailler. Ils agissent comme des variables locales à la fonction.
• Valeur de retour : C'est le résultat que la fonction renvoie à l'endroit où elle a été appelée. Une fonction peut retourner une seule valeur, aucune valeur (voir procédures), ou parfois plusieurs valeurs (selon le langage).
  • Le mot-clé RETOURNER (ou return) est utilisé pour spécifier la valeur de sortie et terminer l'exécution de la fonction.
• Signature de fonction : C'est le nom de la fonction, le nombre et les types de ses paramètres, et le type de sa valeur de retour. Elle définit l'interface de la fonction.
• Appel de fonctions : C'est l'exécution de la fonction. On l'appelle par son nom, en lui passant les valeurs des paramètres.

  // Appel et stockage du résultat
  maSomme = CalculerSomme(5, 3) // maSomme vaudra 8
  
  // Appel et utilisation directe du résultat
  AFFICHER CalculerSomme(10, 20) // Affichera 30
  

• Portée des variables (locale/globale) :
  • Une variable locale est déclarée à l'intérieur d'une fonction et n'est accessible qu'à l'intérieur de cette fonction. Elle est "détruite" à la fin de l'exécution de la fonction.
  • Une variable globale est déclarée en dehors de toute fonction et est accessible depuis n'importe quelle partie du programme, y compris les fonctions.
  • Il est généralement préférable de limiter l'utilisation des variables globales pour éviter des effets de bord inattendus et rendre le code plus facile à maintenir.

La distinction entre procédure et fonction est parfois floue et dépend du langage de programmation. En général, on retient ceci :

Key Concepts:

• Fonction : Un sous-programme qui retourne une valeur. Son but principal est de calculer et de fournir un résultat.
  • Exemple : CalculerSomme(a, b) retourne la somme.
• Procédure : Un sous-programme qui n'a pas de valeur de retour explicite. Son but principal est d'exécuter une série d'actions ou de produire un effet de bord.
  • Absence de valeur de retour : Souvent, une procédure n'utilise pas le mot-clé RETOURNER ou retourne une valeur "vide" (ex: None en Python, void en C++/Java).
  • Effets de bord : Une procédure modifie l'état du programme (ex: afficher quelque chose à l'écran, modifier une variable globale, écrire dans un fichier).
  • Exemple :

    PROCEDURE AfficherMessage (message: CHAINE)
        AFFICHER message
    FIN PROCEDURE
    
    // Appel :
    AfficherMessage("Bienvenue !") // Affiche le message, ne retourne rien
    

• Utilisation spécifique :
  • Utilisez une fonction lorsque vous avez besoin d'un calcul ou d'une transformation de données qui doit produire un résultat utilisable ailleurs.
  • Utilisez une procédure lorsque vous avez besoin d'exécuter une action qui modifie l'état du programme ou interagit avec l'utilisateur, sans forcément produire une valeur à réutiliser directement.

Un tableau (ou liste dans certains langages) est une collection ordonnée d'éléments du même type (ou de types différents dans certains langages dynamiques), stockés de manière contiguë en mémoire.

Key Concepts:

• Définition d'un tableau : C'est une structure qui permet de stocker plusieurs valeurs sous un seul nom de variable.
  • Ex: notes = [12, 15, 10, 18]
• Indexation : Chaque élément d'un tableau est identifié par un indice (ou index), qui est un nombre entier.
  • Dans la plupart des langages de programmation, l'indexation commence à 0. Le premier élément est à l'indice 0, le deuxième à l'indice 1, etc.
  • Ex: Dans notes = [12, 15, 10, 18], notes[0] est 12, notes[1] est 15.
• Parcours de tableau : C'est l'action de visiter chaque élément du tableau, généralement à l'aide d'une boucle.

  tableau = [10, 20, 30]
  POUR i DE 0 A (taille(tableau) - 1) FAIRE // ou POUR CHAQUE element DANS tableau
      AFFICHER tableau[i]
  FIN POUR
  

• Tableaux à une dimension : Ce sont les tableaux les plus simples, représentant une suite linéaire de données.
  • On peut aussi avoir des tableaux à plusieurs dimensions (ex: matrices pour représenter des images ou des grilles de jeu), mais ils sont plus complexes.

Plusieurs opérations sont fréquemment effectuées sur les tableaux.

Key Concepts:

• Ajout/Suppression d'éléments :
  • Ajout : On peut ajouter un élément à la fin du tableau (ajouter(tableau, element)) ou à une position spécifique.
  • Suppression : On peut supprimer un élément par son indice ou par sa valeur.
  • Ces opérations peuvent être coûteuses en performance si le tableau est grand et que les éléments doivent être décalés.
• Recherche d'un élément : Trouver si un élément existe dans le tableau et, si oui, à quel indice.
  • Recherche linéaire : Parcourir le tableau élément par élément jusqu'à trouver la valeur.
  • Recherche dichotomique : Plus efficace pour les tableaux triés (divise le tableau en deux à chaque étape).
• Tri d'un tableau : Réorganiser les éléments du tableau dans un ordre spécifique (croissant ou décroissant).
  • Il existe de nombreux algorithmes de tri (tri à bulles, tri par sélection, tri rapide, tri fusion, etc.), chacun avec ses propres avantages et inconvénients en termes de performance.
• Taille d'un tableau : Obtenir le nombre d'éléments contenus dans le tableau.
  • Ex: taille(notes) pour [12, 15, 10, 18] donnerait 4.

Une chaîne de caractères est une séquence ordonnée de caractères. En programmation, elles sont souvent traitées comme des tableaux de caractères.

Key Concepts:

• Chaînes comme tableaux de caractères : Chaque caractère dans une chaîne a un indice, comme dans un tableau.
  • Ex: Pour mot = "Bonjour", mot[0] est 'B', mot[1] est 'o'.
• Opérations sur les chaînes :
  • Concaténation : Joindre deux ou plusieurs chaînes pour en former une nouvelle.
    • Ex: "Bonjour" + " " + "le monde" donne "Bonjour le monde".
  • Découpage (substring/slice) : Extraire une partie d'une chaîne.
    • Ex: Extraire les trois premiers caractères de "Bonjour" donne "Bon".
  • Longueur : Obtenir le nombre de caractères dans la chaîne.
    • Ex: longueur("Bonjour") donne 7.
• Méthodes de manipulation de chaînes : La plupart des langages fournissent des fonctions ou méthodes intégrées pour manipuler les chaînes.
  • Mettre en majuscules/minuscules, remplacer un caractère/mot, vérifier si une chaîne commence/finit par un certain motif, etc.
  • Les chaînes sont immuables dans de nombreux langages : une opération de modification crée souvent une nouvelle chaîne au lieu de modifier l'originale.

La POO vise à modéliser le monde réel en créant des entités logicielles qui encapsulent à la fois des données et le comportement associé.

Key Concepts:

• Objet : Une instance d'une classe. C'est une entité concrète qui possède un état (ses attributs) et un comportement (ses méthodes).
  • Ex: Une voiture spécifique (ma Clio bleue) est un objet.
• Classe : Un plan ou un modèle pour créer des objets. Elle définit la structure (les attributs) et le comportement (les méthodes) que tous les objets de ce type auront.
  • Ex: La classe Voiture définit qu'une voiture a des roues, une couleur, une vitesse, et qu'elle peut démarrer, accélérer, freiner.
• Attributs : Ce sont les caractéristiques ou les données qui décrivent l'état d'un objet. Ce sont des variables associées à la classe.
  • Ex: Pour la classe Voiture, les attributs pourraient être couleur, vitesseActuelle, nombreDePortes.
• Méthodes : Ce sont les actions ou les fonctions qu'un objet peut effectuer. Ce sont des fonctions associées à la classe.
  • Ex: Pour la classe Voiture, les méthodes pourraient être demarrer(), accelerer(quantite), freiner().

La POO permet de mieux organiser le code, de le rendre plus modulaire et plus facile à maintenir.

Pour utiliser des objets en POO, il faut d'abord les créer à partir de leur classe, puis interagir avec eux.

Key Concepts:

• Instanciation : C'est le processus de création d'un objet à partir d'une classe. On dit qu'on "instancie" une classe. Le nouvel objet est une "instance" de cette classe.

  // Création d'une instance de la classe Voiture
  maVoiture = NOUVELLE Voiture()
  saVoiture = NOUVELLE Voiture()
  

  • maVoiture et saVoiture sont deux objets distincts de la classe Voiture.
• Accès aux attributs : Une fois l'objet créé, on peut accéder à ses attributs pour lire ou modifier leur valeur. On utilise généralement la notation point (.).

  maVoiture.couleur = "bleue"
  maVoiture.nombreDePortes = 5
  AFFICHER "Ma voiture est de couleur ", maVoiture.couleur
  

• Appel de méthodes : On peut appeler les méthodes d'un objet pour lui faire exécuter une action.

  maVoiture.demarrer()
  maVoiture.accelerer(50) // la vitesse actuelle de maVoiture passe à 50
  

  • Les méthodes peuvent modifier les attributs de l'objet sur lequel elles sont appelées.

L'encapsulation est l'un des principes fondamentaux de la POO. Elle consiste à regrouper les données (attributs) et les méthodes qui opèrent sur ces données au sein d'une même unité (la classe), et à cacher les détails internes de l'objet.

Key Concepts:

• Visibilité (publique/privée) :
  • Attributs/méthodes publiques : Accessibles de l'extérieur de la classe. N'importe quel autre code peut les utiliser.
  • Attributs/méthodes privées : Accessibles uniquement depuis l'intérieur de la classe elle-même. Ils sont cachés de l'extérieur et ne peuvent pas être directement modifiés ou appelés.
  • L'encapsulation se fait souvent en rendant les attributs privés et en fournissant des méthodes publiques (appelées getters et setters) pour interagir avec eux de manière contrôlée.
• Protection des données : En rendant les attributs privés, on empêche qu'ils soient modifiés de manière incorrecte ou inattendue depuis l'extérieur. On garantit ainsi l'intégrité de l'état de l'objet.
  • Ex: Pour une Voiture, on pourrait avoir un attribut vitesseActuelle privé. La modification se ferait uniquement via les méthodes accelerer() et freiner(), qui peuvent contenir des contrôles (ex: ne pas dépasser la vitesse maximale).
• Interfaces : Les méthodes publiques d'une classe constituent son interface. C'est la seule façon pour les autres parties du programme d'interagir avec l'objet. L'implémentation interne peut changer sans affecter le code qui utilise l'objet, tant que l'interface reste la même.
  • L'encapsulation favorise la robustesse, la maintenabilité et la réutilisabilité du code.

Il existe plusieurs catégories d'erreurs que l'on peut rencontrer lors de la programmation.

Key Concepts:

• Erreurs de syntaxe : Ce sont des erreurs qui violent les règles grammaticales du langage de programmation. Le programme ne peut pas être compilé ou interprété.
  • Ex: Oublier une parenthèse, une virgule, une accolade, mal orthographier un mot-clé (functoin au lieu de function).
  • Ces erreurs sont généralement détectées par le compilateur ou l'interpréteur du langage et sont souvent les plus faciles à corriger car le message d'erreur indique la ligne et la nature du problème.
• Erreurs d'exécution (runtime errors) : Ces erreurs surviennent pendant l'exécution du programme, après qu'il a été compilé ou interprété avec succès. Le programme plante ou se comporte de manière inattendue.
  • Ex: Division par zéro ($10 / 0$), accès à un indice de tableau inexistant (tableau[10] alors que le tableau n'a que 5 éléments), tentative d'ouvrir un fichier qui n'existe pas.
  • Ces erreurs peuvent être plus difficiles à détecter car elles ne se manifestent que sous certaines conditions d'exécution.
• Erreurs logiques : Le programme s'exécute sans planter, mais il ne produit pas le résultat attendu. L'algorithme lui-même est incorrect.
  • Ex: Calculer la moyenne en divisant par le nombre de notes + 1, utiliser un opérateur de comparaison incorrect (< au lieu de <=), une boucle qui ne s'arrête pas ou qui ne s'exécute pas assez de fois.
  • Ce sont les erreurs les plus difficiles à trouver et à corriger, car le programme "semble" fonctionner, mais il est faux. Elles nécessitent une compréhension approfondie de l'algorithme et des tests rigoureux.

Le débogage est le processus de localisation et de correction des erreurs (bugs) dans un programme.

Key Concepts:

• Affichage de variables (print debugging) : C'est la technique la plus simple et la plus courante. On insère des instructions d'affichage (AFFICHER, print, console.log) à différents endroits du code pour voir la valeur des variables à des moments clés de l'exécution.
  • Utile pour suivre le flux d'exécution et l'état des données.
• Utilisation d'un débogueur (debugger) : Un débogueur est un outil puissant intégré à la plupart des environnements de développement (IDE). Il permet de contrôler l'exécution du programme.
• Points d'arrêt (breakpoints) : On peut définir des points d'arrêt à des lignes spécifiques du code. Lorsque le programme atteint un point d'arrêt, son exécution est suspendue.
• Exécution pas à pas (step-by-step execution) : Une fois le programme en pause à un point d'arrêt, le débogueur permet d'exécuter le code instruction par instruction, en observant l'évolution des variables et le cheminement du programme.
  • On peut "passer par-dessus" (step over) une fonction (exécuter la fonction entièrement sans entrer dans son code) ou "entrer dans" (step into) une fonction (exécuter le code de la fonction pas à pas).
  • Le débogueur est un outil indispensable pour les erreurs complexes, surtout les erreurs logiques.

Les tests sont des procédures visant à vérifier si un programme ou une partie de programme répond aux exigences spécifiées.

Key Concepts:

• Tests unitaires : Ils consistent à tester de manière isolée les plus petites unités de code (généralement des fonctions ou des méthodes) pour s'assurer qu'elles fonctionnent correctement.
  • Chaque test unitaire se concentre sur une fonctionnalité spécifique et est indépendant des autres.
  • Ils sont automatisés et exécutés fréquemment (après chaque modification de code).
• Jeux de données de test : C'est un ensemble d'entrées spécifiques avec leurs sorties attendues.
  • Il est crucial de créer des jeux de données variés pour couvrir différents scénarios.
• Cas limites (edge cases) : Ce sont des valeurs d'entrée extrêmes ou inhabituelles qui peuvent révéler des bugs.
  • Ex: Pour une fonction qui prend un nombre entier, tester avec 0, des nombres négatifs, le plus grand/plus petit nombre possible, etc.
  • Pour un tableau, tester avec un tableau vide, un tableau à un seul élément, un tableau très grand.
• Validation des résultats : Pour chaque test, il faut non seulement exécuter le code, mais aussi vérifier que le résultat obtenu correspond au résultat attendu.
  • Cela se fait souvent par des assertions (assert) dans les tests automatisés, qui vérifient si une condition est Vraie. Si elle est Fausse, le test échoue.
  • Un bon ensemble de tests permet de détecter les erreurs tôt, de garantir la qualité du code et de faciliter les futures modifications.