Variable dans Scratch : définition et fonctionnement simple

Variable dans Scratch: définition et fonctionnement simple

Cette valeur peut être modifiée pendant l’exécution du programme, puis réutilisée dans une condition, un calcul, un affichage ou un message.

C’est le point qui rapporte souvent des points en algorithmique au collège: tu ne dois pas seulement placer un bloc « mettre à ». Tu dois montrer que tu sais quelle information la variable mémorise, à quel moment elle est initialisée et comment sa valeur évolue. Une variable mal nommée ou remise à zéro au mauvais endroit suffit à produire un programme qui semble fonctionner, mais dont le résultat est faux.

Une variable Scratch, c’est quoi exactement?

Imagine une petite boîte portant une étiquette. L’étiquette est le nom de la variable; la valeur placée dans la boîte peut changer au cours du programme.

Si tu crées une variable appelée score, elle peut d’abord contenir 0, puis 10, puis 25. La variable reste la même: c’est son contenu qui évolue.

Dans Scratch, une variable simple ne contient qu’une seule valeur à un instant donné. Elle peut enregistrer:

• un nombre: 0, 12, 3,5;
• un texte: un prénom, une réponse ou un message;
• une valeur utilisée dans un calcul;
• une information qui permet de prendre une décision.

Par exemple, dans un jeu:

• score mémorise le nombre de points;
• vies mémorise le nombre de tentatives restantes;
• temps mémorise la durée écoulée;
• nom mémorise le nom saisi par l’utilisateur.

Une variable ne remplace donc pas une liste. Si tu veux conserver plusieurs éléments ordonnés, par exemple les réponses successives d’un joueur, tu dois utiliser le bloc Scratch consacré aux listes. Une variable simple garde uniquement la valeur actuelle.

Une variable n’est pas une réponse automatique: c’est une mémoire que ton programme doit initialiser, modifier et lire au bon moment.

À quoi sert une variable dans Scratch?

Sans variable, un programme peut déplacer un lutin, changer son apparence ou répéter une action. Dès que le programme doit compter, comparer, mémoriser ou suivre une évolution, la variable devient nécessaire.

Compter des points

Le cas le plus direct est celui du score. Au début de la partie, tu places la variable à zéro. Lorsqu’un joueur réussit une action, tu ajoutes un nombre de points.

La logique est alors simple:

1. Au démarrage, score vaut 0.

2. Le joueur réalise une action correcte.

3. Le programme ajoute, par exemple, 1 à score.

4. La nouvelle valeur est affichée ou utilisée pour déterminer la victoire.

Le bloc « ajouter à [score] » est particulièrement utile ici. Il modifie la valeur existante. Si score vaut 7, le bloc « ajouter 1 à score » donne 8.

Attention à ne pas confondre deux actions:

• « mettre score à 1 » remplace directement la valeur précédente;
• « ajouter 1 à score » conserve la valeur précédente et l’augmente.

Si tu utilises « mettre score à 1 » à chaque bonne réponse, ton score restera bloqué à 1. Le programme exécute bien les blocs, mais il ne compte pas réellement.

Gérer un nombre de vies

Une variable peut aussi suivre les tentatives restantes. Tu peux initialiser vies à 3, puis retirer une unité lorsqu’une erreur est commise.

La condition peut ensuite vérifier:

• si vies = 0, la partie est terminée;
• si vies > 0, le joueur peut continuer.

Le nom choisi doit correspondre à la fonction réelle. Une variable vies qui augmente après une erreur rend le programme difficile à relire et signale probablement une inversion dans le raisonnement.

Mémoriser une réponse

Une variable peut contenir du texte. Dans une activité de mathématiques, tu peux demander une réponse, puis enregistrer cette réponse dans reponse.

La valeur peut ensuite être comparée avec la réponse attendue. Dans ce cas, le programme ne compte pas seulement: il conserve une information fournie par l’utilisateur.

La même logique s’applique pour:

• enregistrer un prénom;
• mémoriser un niveau de difficulté;
• garder le dernier message saisi;
• stocker le nom d’un objet sélectionné.

Faire fonctionner un chronomètre

Pour créer un chronomètre simple, une variable comme temps peut être mise à zéro au début, puis augmentée régulièrement pendant l’exécution.

Tu dois alors observer précisément la place de chaque bloc:

• l’initialisation doit être faite une seule fois au démarrage;
• l’augmentation doit se trouver dans une boucle;
• l’arrêt du chronomètre doit être lié à une condition claire.

Si tu places le bloc « mettre temps à 0 » dans la boucle, le compteur repartira sans cesse à zéro. Visuellement, le programme s’exécute, mais la valeur affichée ne progresse pas. C’est une erreur classique de placement.

Créer une variable dans Scratch

La création se fait dans la palette « Variables ». Scratch ne crée pas automatiquement une nouvelle variable parce qu’un script utilise un nom. Tu dois d’abord passer par le bouton « Créer une variable ».

Étape 1: choisir un nom précis

Clique sur « Créer une variable », puis donne-lui un nom qui décrit l’information mémorisée.

Privilégie:

• score plutôt que nombre1;
• nombreEssais plutôt que compteurA;
• reponse plutôt que valeur;
• tempsRestant plutôt que variable2.

Un nom précis t’aide à relire le programme et facilite la rédaction d’une démonstration. Si le correcteur voit une variable cote, il comprend immédiatement qu’elle représente probablement la longueur d’un côté. Si le programme contient seulement a, b et c, tu dois fournir davantage d’explications pour éviter toute ambiguïté.

Étape 2: choisir la portée

Scratch propose deux possibilités:

Une variable globale, créée « pour tous les lutins », convient lorsque plusieurs personnages doivent lire ou modifier la même valeur. Dans un jeu à plusieurs lutins, score peut être partagé par le joueur, l’arbitre et l’écran final.

Une variable locale, créée « pour ce lutin uniquement », est préférable lorsque l’information ne concerne qu’un personnage. Par exemple, chaque lutin peut avoir sa propre vitesse ou son propre compteur d’animations.

Ne choisis pas une variable globale par habitude. Une portée trop large permet à plusieurs scripts de modifier la même donnée, parfois sans que tu t’en rendes compte. Le programme devient alors plus difficile à vérifier.

Étape 3: observer les blocs disponibles

Après la création, Scratch ajoute des blocs associés à la variable. Les plus importants sont:

• « mettre [variable] à »;
• « ajouter à [variable] »;
• le bloc de lecture de la valeur, portant le nom de la variable;
• « montrer la variable »;
• « cacher la variable ».

Un projet Scratch démarre généralement avec une variable globale appelée « ma variable ». Tu peux la renommer si elle correspond à ton besoin, ou la supprimer pour éviter de conserver un élément inutile dans la scène.

Initialiser, modifier et lire: les trois gestes essentiels

Pour comprendre un programme à variables, repère toujours trois moments: la valeur de départ, les modifications et les utilisations.

1. Initialiser la variable

Initialiser signifie donner une valeur de départ. Pour un score, écris généralement « mettre score à 0 ». Pour un nombre d’essais, tu peux choisir la valeur prévue par l’énoncé.

Cette instruction doit être placée avant la première utilisation de la variable. Le plus souvent, elle se trouve sous le bloc « quand le drapeau vert est cliqué ».

Si tu ne fais pas cette initialisation, le programme peut reprendre une valeur laissée par une exécution précédente. Ton résultat dépend alors de l’historique du projet au lieu de dépendre uniquement des consignes.

2. Modifier la valeur

Une modification peut remplacer la valeur ou la faire évoluer.

Utilise « mettre à » lorsque tu veux fixer une valeur précise:

• remettre le score à zéro;
• donner le niveau choisi;
• enregistrer une réponse;
• fixer le nombre de vies à trois.

Utilise « ajouter à » lorsque tu veux conserver la valeur précédente et lui appliquer une variation:

• ajouter des points;
• retirer une vie en ajoutant -1;
• augmenter un compteur;
• faire progresser un chronomètre.

Cette distinction est au cœur de la méthode. Avant de placer le bloc, pose-toi la question suivante: la nouvelle valeur dépend-elle de l’ancienne? Si oui, « ajouter à » est souvent le bon choix.

3. Lire la valeur

Le bloc portant le nom de la variable permet d’utiliser sa valeur dans une autre instruction.

Tu peux l’insérer dans:

• une condition « si… alors »;
• une opération mathématique;
• une question posée par le lutin;
• une phrase affichée dans une bulle;
• un message envoyé à un autre lutin.

Par exemple, une condition peut vérifier si score est supérieur ou égal à 10. Le programme ne regarde pas le nom de la variable: il lit la valeur qu’elle contient à cet instant.

Construire un exemple simple de variable dans Scratch

Prenons une activité de calcul mental. Le lutin pose une question et attribue un point si la réponse est correcte.

Tu peux organiser le programme ainsi:

1. Quand le drapeau vert est cliqué, mettre score à 0.

2. Poser une question à l’utilisateur.

3. Si la réponse est correcte, ajouter 1 à score.

4. Dire la valeur actuelle de score.

5. Si score est supérieur ou égal à l’objectif, annoncer la réussite.

Ce scénario montre bien le rôle de la variable: elle ne pose pas la question et ne décide pas seule de la réussite. Elle mémorise le nombre de réponses correctes, tandis que les conditions et les blocs de dialogue utilisent cette information.

Pour vérifier ton programme, exécute-le plusieurs fois avec des réponses différentes. Observe la valeur affichée après:

• une réponse correcte;
• une réponse incorrecte;
• un redémarrage complet;
• plusieurs bonnes réponses successives.

Le score doit repartir de zéro au redémarrage, augmenter uniquement après une bonne réponse et conserver sa valeur entre deux questions. Si l’un de ces résultats est faux, reviens au premier endroit où la valeur change.

Pour déboguer une variable, ne regarde pas seulement le résultat final: observe la valeur juste après chaque modification.

L’affichage de la variable: un outil de vérification

Scratch permet d’afficher une variable sur la scène. Cet affichage n’est pas uniquement décoratif. Il sert à contrôler le déroulement du programme.

La valeur peut apparaître sous trois formes:

• l’affichage normal, avec le nom de la variable;
• le grand affichage, qui met surtout la valeur en évidence;
• le potentiomètre, ou curseur, qui permet de régler une valeur directement sur la scène.

Le mode normal est pratique pendant la mise au point: tu vois immédiatement que la variable score vaut 4, ou que tempsRestant est passé à 0.

Le grand affichage convient mieux à une présentation destinée à un utilisateur. Le curseur peut être utile pour tester un programme avec plusieurs valeurs, mais il faut comprendre qu’il permet une modification manuelle. Si ton résultat change alors que tu n’as exécuté aucun bloc, vérifie si le mode potentiomètre est actif.

Afficher temporairement, cacher dans la version finale

Pendant le débogage, montre les variables qui t’aident à suivre les calculs. Une fois le programme vérifié, tu peux les cacher si elles n’ont pas de rôle pour le joueur.

Tu peux donc distinguer:

• les variables utiles au fonctionnement visible du projet;
• les variables techniques utilisées uniquement pour contrôler le programme.

Cette distinction donne un projet plus lisible. Elle évite aussi de montrer au joueur des informations qui n’ont aucun sens dans l’activité.

Variable globale ou variable locale: faire le bon choix

Le choix de la portée devient important dès que ton projet contient plusieurs lutins.

Une variable pour tous les lutins

Choisis « Pour tous les lutins » lorsque plusieurs scripts doivent partager la même valeur.

Exemples:

• un score général;
• un compte à rebours commun;
• un niveau de jeu;
• le nombre total de réussites.

Si le lutin du joueur ajoute des points et si le lutin de l’écran final affiche le score, la variable doit être accessible aux deux.

Une variable pour un seul lutin

Choisis « Pour ce lutin uniquement » lorsqu’un seul personnage doit gérer l’information.

Exemples:

• la position personnelle d’un lutin;
• son nombre d’animations;
• sa vitesse;
• le nombre de fois où il a changé de costume.

Une variable locale évite les modifications involontaires par un autre script. Elle rend aussi le projet plus facile à organiser lorsque plusieurs personnages ont des comportements semblables.

Tableau de décision rapide

Ne déduis pas la portée à partir du seul nom de la variable. Une variable appelée vitesse peut être globale dans une course collective, ou locale si chaque lutin avance à une vitesse différente. C’est le fonctionnement du projet qui décide.

Les erreurs fréquentes avec les variables Scratch

Les erreurs de variables sont souvent faciles à corriger, à condition de les repérer dans l’ordre.

Remettre la variable à zéro dans une boucle

Tu veux compter les tours d’une action, mais tu places « mettre compteur à 0 » à l’intérieur d’une boucle. À chaque répétition, le compteur est effacé avant d’être augmenté.

Pour corriger ce problème, trace mentalement le parcours du programme. L’initialisation doit se produire avant la boucle; la modification doit se produire à l’intérieur.

Utiliser « mettre à » au lieu de « ajouter à »

Un score qui reste toujours égal à 1 révèle souvent cette confusion. Le bloc « mettre à » remplace la valeur. Le bloc « ajouter à » la fait progresser.

Lis le bloc comme une phrase complète. « Mettre score à 1 » ne signifie pas « gagner un point ». Cela signifie « score vaut maintenant 1 ».

Oublier de réinitialiser une variable

Si une partie recommence avec le score précédent, la variable n’est pas réinitialisée au lancement.

Place la remise à zéro dans le script déclenché par le drapeau vert, avant les actions de jeu. Si plusieurs scripts démarrent en même temps, vérifie qu’un seul d’entre eux initialise la variable, sauf raison particulière.

Donner le même rôle à plusieurs variables

Deux variables portant des noms proches, comme score et scores, peuvent provoquer une mauvaise lecture. Tu risques de modifier l’une et d’afficher l’autre.

Choisis un vocabulaire stable et supprime les variables inutilisées. Dans un exercice noté, cette discipline rend ton algorithme plus compréhensible et facilite la justification.

Modifier une variable depuis plusieurs scripts

Deux scripts peuvent changer la même variable sans que tu l’aies prévu. Le résultat dépend alors de l’ordre dans lequel les blocs s’exécutent.

Pour trouver l’origine du problème:

1. affiche la variable sur la scène;

2. repère chaque bloc qui la modifie;

3. désactive temporairement les scripts secondaires;

4. relance le programme;

5. ajoute les scripts un par un en observant la valeur.

Ne corrige pas au hasard en ajoutant des blocs « attendre ». Ce délai peut modifier l’ordre apparent sans résoudre la cause. Commence par identifier quel script écrit quelle valeur.

Variables et géométrie dans Scratch

Les variables sont très utiles pour les activités de construction et de repérage spatial. Elles peuvent mémoriser une longueur, un angle, un nombre de côtés ou le nombre de répétitions d’une boucle.

Pour tracer un polygone régulier, tu peux utiliser:

• une variable cote pour la longueur du déplacement;
• une variable nombreCotes pour le nombre de répétitions;
• une variable angle pour la rotation;
• une variable compteur pour compter les côtés déjà tracés.

Dans ce type d’activité, la variable ne remplace pas le raisonnement géométrique. Elle permet de rendre le programme adaptable. Si tu modifies nombreCotes, le même script peut produire une autre figure; si tu modifies cote, la taille change sans que tu doives reconstruire tous les blocs.

Avant d’exécuter, observe la cohérence entre les valeurs:

• le nombre de répétitions doit correspondre au nombre de côtés;
• la rotation doit être adaptée à la figure;
• la longueur du déplacement doit rester positive et cohérente;
• le compteur doit progresser une seule fois par côté.

La vérification visuelle est alors rapide: la figure doit se fermer, les côtés doivent suivre le même modèle et le lutin doit retrouver une orientation cohérente à la fin. Si la figure reste ouverte, ne recommence pas tout le programme. Vérifie d’abord la variable qui contrôle le nombre de répétitions et celle qui contrôle l’angle.

Une méthode de brouillon pour les exercices notés

Avant de placer les blocs, écris le rôle de chaque variable en une phrase. Cette étape prend peu de temps et rapporte souvent davantage qu’un programme compliqué mais mal expliqué.

Tu peux utiliser ce tableau de préparation:

Ensuite, réponds à quatre questions:

1. Quelle est la valeur de départ?

2. Quel bloc modifie la variable?

3. À quel moment cette modification se produit-elle?

4. Où la valeur est-elle réutilisée?

Si tu ne peux pas répondre à l’une de ces questions, ton programme n’est pas encore suffisamment défini.

Dans une copie, écris une justification directement liée aux blocs. Par exemple, explique que la variable est initialisée avant la boucle afin que le comptage commence à la valeur prévue, puis qu’elle est augmentée à chaque répétition. Cette phrase montre le lien entre l’algorithme et son résultat.

Vérifier un programme avant de le rendre

Un programme Scratch doit être testé avec plusieurs situations, pas seulement avec le cas qui fonctionne du premier coup.

Fais au minimum les vérifications suivantes:

• lance le projet depuis le drapeau vert;
• regarde si chaque variable prend sa valeur initiale;
• exécute une seule action et observe la modification;
• répète l’action plusieurs fois;
• teste une valeur nulle ou minimale lorsqu’elle est autorisée;
• vérifie le cas où une condition devient vraie;
• arrête puis relance le programme pour contrôler la réinitialisation.

Pour suivre une variable, écris quelques lignes de trace sur ton brouillon:

Cette trace t’aide à localiser l’erreur. Si la valeur attendue est 2 mais que Scratch affiche 1, tu sais que le problème se trouve entre la première et la deuxième modification. Tu n’as pas besoin de relire tous les blocs indistinctement.

Contrôler la portée

Si une variable ne réagit pas comme prévu, vérifie aussi sa portée. Un lutin peut utiliser une variable locale qui porte le même nom qu’une variable appartenant à un autre lutin. Dans ce cas, les deux valeurs ne sont pas forcément partagées.

Observe le panneau « Variables » de chaque lutin et demande-toi: cette information doit-elle être commune ou personnelle? La réponse permet souvent de corriger un programme qui affiche une valeur différente selon le personnage actif.

Ce qu’il faut retenir pour la rédaction

Une bonne réponse sur les variables ne se limite pas à une définition. Tu dois relier trois éléments:

• la donnée mémorisée;
• les blocs qui la font évoluer;
• le résultat obtenu dans le programme.

Tu peux rédiger ainsi, en adaptant les noms à ton exercice: la variable compteur mémorise le nombre d’actions réalisées. Elle est initialisée à 0 au lancement du programme, puis le bloc « ajouter 1 à compteur » est exécuté à chaque répétition. Sa valeur indique donc le nombre d’actions déjà effectuées.

Cette formulation est courte, mais elle contient la justification attendue. Elle explique ce que fait le programme et pourquoi la valeur finale a un sens.

La précision des verbes compte: initialiser, ajouter, remplacer, lire, comparer, afficher. Évite d’écrire que la variable « fait le calcul » ou « commande le lutin ». Elle mémorise une information; les autres blocs utilisent cette information pour agir.

En résumé, une variable bien utilisée

Pour réussir un exercice sur les variables dans Scratch, avance dans cet ordre:

1. Identifie l’information qui doit être conservée.

2. Choisis un nom qui décrit clairement cette information.

3. Crée la variable dans la palette « Variables ».

4. Sélectionne sa portée selon les lutins qui doivent l’utiliser.

5. Donne-lui une valeur initiale avant sa première utilisation.

6. Choisis entre « mettre à » et « ajouter à » selon le rôle de la modification.

7. Affiche temporairement sa valeur pour contrôler le programme.

8. Teste plusieurs exécutions et note les valeurs obtenues.

9. Justifie dans ta rédaction le lien entre la variable, les blocs et le résultat.

Une variable Scratch est donc une mémoire simple, mais sa gestion demande une méthode précise. Tu dois savoir ce qu’elle contient, quand cette valeur change et quel script la lit. En suivant cette trace, tu gagnes en clarté dans le programme comme dans la copie.

Le détail de rédaction qui rapporte le plus est celui-ci: nomme la valeur initiale, indique le bloc de modification et explique à quel moment il s’exécute. Ton correcteur ne cherchera pas seulement à voir que la figure se trace ou que le score s’affiche; il cherchera à comprendre pourquoi ton algorithme produit ce résultat.