Boucles et conditions Scratch : étapes pour vos premiers scripts

Boucles et conditions Scratch: étapes pour vos premiers scripts

La parade tient en une règle: tout test logique doit s'inscrire dans une boucle de contrôle.

Les boucles et les conditions forment l'ossature de tout algorithme interactif sous Scratch. Ces deux familles de blocs se trouvent dans le menu Contrôle (couleur orange). Elles se combinent pour produire des déplacements répétés, des détections permanentes, des tracés de figures et des prises de décision. Le présent article détaille la mécanique de chaque bloc, puis enchaîne sur la progression pédagogique du cycle 4.

Les fondamentaux du menu Contrôle: boucles et tests logiques

Trois boucles principales structurent les itérations. Deux structures conditionnelles exécutent les tests. Toutes ces briques vivent dans le même menu, reconnaissable à sa couleur orange dans l'interface.

Les trois boucles Scratch

1. « Répéter n fois »: exécute le contenu un nombre défini d'itérations. Le bloc exige une valeur numérique en entrée — constante ou variable.

2. « Répéter indéfiniment »: exécute le contenu sans condition d'arrêt automatique. Une instruction de sortie interne reste donc obligatoire (bloc « stop », condition, sortie de scène).

3. « Répéter jusqu'à ce que »: exécute le contenu tant que la condition booléenne reste fausse, puis sort dès qu'elle devient vraie. C'est l'inverse de la logique « tant que » rencontrée dans d'autres langages.

Une boucle sans condition de sortie explicite peut bloquer le programme. Prévoir systématiquement le critère d'arrêt avant l'exécution.

Les deux structures conditionnelles

1. « Si... alors »: exécute le contenu si la condition renvoie vrai.

2. « Si... alors... sinon »: exécute un premier contenu si la condition est vraie, un second contenu si elle est fausse.

Les conditions elles-mêmes sont des blocs hexagonaux à résultat booléen. Ces blocs proviennent principalement des menus Opérateurs (vert) et Capteurs (bleu clair). Aucun autre type de bloc ne s'emboîte dans l'emplacement réservé d'un test.

La logique des conditions: utiliser les blocs hexagonaux

Un bloc hexagonal produit une valeur booléenne: vrai ou faux. Scratch attend précisément ce format dans la fente d'entrée d'un « si », d'un « répéter jusqu'à ce que » ou de tout opérateur logique. Trois catégories principales alimentent les conditions.

Opérateurs arithmétiques et logiques (menu vert)

• Comparaisons numériques: <, >, =.
• Connecteurs logiques: et, ou, non.
• Arithmétique: +, -, ×, ÷, mod.

Ces blocs acceptent des valeurs numériques en entrée et renvoient un booléen pour les comparaisons. Les connecteurs et/ou acceptent eux-mêmes deux blocs booléens en entrée.

Capteurs (menu bleu clair)

• touche [couleur]: vrai si le lutin est en contact avec la couleur précisée.
• couleur [couleur] touchée?: variante avec sélecteur visuel.
• souris x, souris y: position du pointeur, comparables numériquement.
• touche [touche]: vrai si la touche précisée du clavier est pressée.

Construction typique d'une condition

Une condition combine souvent un capteur et un opérateur. Exemple concret: (touche la couleur rouge) et (ordonnée y > 100). Le bloc et accepte ici deux entrées hexagonales — l'une booléenne (capteur), l'autre issue d'une comparaison numérique (opérateur).

Les blocs hexagonaux ne s'emboîtent que dans des emplacements hexagonaux. Cette contrainte visuelle évite les erreurs de type, mais elle impose de connaître la nature de chaque bloc.

Progression pédagogique: du tracé de carré aux figures complexes

Les repères annuels de progression au cycle 4 échelonnent la difficulté en trois paliers. Chaque palier ajoute une brique conceptuelle.

Niveau 1 (fin de 5e) — boucle simple et déplacement

Le programme attendu: déplacer un lutin en boucle simple, sans condition imbriquée. Exemple type: tracer un carré.

Script pour tracer un carré:

• Bloc déclencheur: Quand drapeau vert cliqué.
• Bloc de contrôle: Répéter 4 fois (englobe les deux blocs suivants).
• Bloc mouvement: Avancer de 100.
• Bloc mouvement: Tourner de 90 degrés.

La boucle « Répéter 4 fois » encapsule deux instructions. Le lutin trace quatre segments égaux, pivotant de 90° à chaque itération. La structure de base d'un polygone régulier tient donc en deux paramètres: le nombre de répétitions et l'angle de rotation. Le tableau ci-dessous récapitule les paramètres standards.

La formule générale: angle = 360° / nombre de côtés. Ce rapport constant permet de tracer n'importe quel polygone régulier.

Niveau 2 (4e) — introduction du test conditionnel

Le programme attendu ajoute une détection. Exemple type: arrêter le tracé si le lutin touche une couleur donnée. Le test s'inscrit alors dans la boucle, en parallèle de l'incrémentation des segments.

Niveau 3 (fin de 3e) — imbrication boucles et conditions

Le programme attendu combine boucle et condition à deux niveaux. Exemple type: reproduire une rosace.

Script rosace (12 carrés en couronne):

• Bloc déclencheur: Quand drapeau vert cliqué.
• Bloc externe: Répéter 12 fois (englobe les deux blocs suivants).
• Bloc interne: Répéter 4 fois (englobe).
• Avancer de 50.
• Tourner de 90 degrés.
• Tourner de 30 degrés (rotation intermédiaire entre chaque carré).

Boucle externe: 12 itérations. Boucle interne: tracé d'un carré complet. Rotation intermédiaire de 30° entre chaque carré. Résultat: 12 carrés disposés en couronne régulière. Le nombre total d'instructions « avancer » vaut 12 × 4 = 48. Cette décomposition multiplicative constitue la base de la figure complexe.

Pièges classiques: pourquoi votre script ne détecte rien

Quatre erreurs reviennent systématiquement dans les copies d'élèves. Chacune obéit à une logique identifiable.

Erreur n°1 — test isolé sans boucle

Symptôme: le lutin réagit au premier contact, puis plus rien. Cause: le bloc « si... alors » est posé directement sous « quand drapeau vert cliqué », sans encapsulation. Le programme teste une fois, sort de la condition, termine le script. Solution: encapsuler le test dans une boucle « Répéter indéfiniment ». Le test s'exécute alors à chaque image de la scène (60 fois par seconde environ).

Erreur n°2 — boucle au mauvais endroit

Symptôme: le lutin se déplace une fois, puis la condition s'exécute sans fin. Cause: la boucle englobe tout sauf le test, ou inversement. Solution: identifier le bloc qui doit s'exécuter le plus souvent — souvent le test — et l'encapsuler dans la boucle la plus intérieure. Règle pratique: la boucle la plus englobante contient les actions les moins fréquentes.

Erreur n°3 — capteur mal paramétré

Symptôme: la condition ne se déclenche jamais, alors que le contact est visible à l'écran. Cause: couleur du capteur inexacte, ou sélecteur erroné. Solution: utiliser la pipette de Scratch (outil intégré dans le sélecteur de couleur) pour prélever la couleur exacte sur la scène. Une différence d'une teinte suffit à invalider le test.

Erreur n°4 — condition toujours vraie ou toujours fausse

Symptôme: la boucle « Répéter jusqu'à ce que » s'arrête instantanément ou, au contraire, ne s'arrête jamais. Cause: variable non initialisée, ou comparaison inversée. Solution: initialiser la variable avant la boucle, et vérifier le sens de la comparaison. Une variable égale à 0 dans un test > 0 produit immédiatement une sortie de boucle.

Une condition qui s'exécute une fois n'est pas une détection continue. Toute interaction permanente exige une boucle, sans exception.

Imbrication et structures avancées pour le cycle 4

L'imbrication consiste à insérer une structure de contrôle dans une autre. Trois cas de figure existent, avec une difficulté croissante.

Boucle dans boucle

Une boucle interne s'exécute entièrement à chaque itération de la boucle externe. L'exemple de la rosace illustre cette construction. Paramètre clé: nombre total d'itérations = produit des deux compteurs. Une boucle de 12 contenant une boucle de 4 produit donc 48 itérations de l'instruction la plus interne.

Condition dans boucle

Un test interne modifie le comportement d'une itération sans bloquer la boucle. Exemple type: un parcours avec obstacles.

Script parcours avec obstacles:

• Bloc déclencheur: Quand drapeau vert cliqué.
• Bloc principal: Répéter indéfiniment (englobe les blocs ci-dessous).
• Avancer de 10.
• Si touche la couleur rouge alors
• Tourner de 90 degrés.
• Si touche la couleur bleue alors
• Tourner de -90 degrés.

Le lutin avance en continu. À chaque contact avec une zone rouge, il pivote à droite. À chaque contact avec une zone bleue, il pivote à gauche. Le test s'exécute à chaque image grâce à la boucle englobante.

Condition dans condition

Cas rare au collège, mais présent dans certains exercices de fin de 3e. Le test interne distingue plusieurs sous-cas à l'intérieur d'une branche du test externe. Cette structure triple l'imbrication et exige une indentation visuelle rigoureuse pour rester lisible.

Vérification rapide — trois points de contrôle

Avant d'exécuter un script contenant des boucles et des conditions, trois questions doivent recevoir une réponse affirmative:

1. Chaque test est-il encapsulé dans une boucle? Sans boucle, le test s'exécute une seule fois.

2. La boucle « Répéter indéfiniment » a-t-elle une condition de sortie? Sans sortie, le programme peut boucler sans fin.

3. Les variables utilisées dans les conditions sont-elles initialisées? Une variable non initialisée contient une valeur imprévisible, souvent 0.

Un script qui passe ces trois contrôles démarre et fonctionne conformément à sa logique interne. Un script qui échoue à l'un d'eux produit l'une des quatre erreurs classiques décrites plus haut.

Synthèse opérationnelle

• Boucles: trois types disponibles. Le choix dépend du critère d'arrêt — connu d'avance, inconnu, ou conditionnel.
• Conditions: deux structures. Choisir « si... alors... sinon » dès qu'une action alternative est requise dans l'algorithme.
• Blocs hexagonaux: source unique des valeurs booléennes. Ils proviennent toujours d'Opérateurs (vert) ou de Capteurs (bleu clair).
• Progression cycle 4: boucle simple en 5e, test conditionnel en 4e, imbrication en 3e.
• Erreur n°1: test isolé sans boucle. Diagnostic immédiat: un seul déclenchement observé.

La rigueur de construction prime sur la complexité. Un script à deux boucles imbriquées, correctement encapsulé, produit un résultat fiable. Un script à une boucle mal placée produit une panne. La vérification des trois points de contrôle avant exécution suffit à éliminer la majorité des erreurs observées en classe.