Appeler un sous-programme

En une phrase

Appeler un sous-programme, c'est écrire le nom du bloc (par exemple « carré ») dans ton programme. Aussitôt, toutes les instructions de ce bloc s'exécutent. Et tu peux l'appeler autant de fois que tu veux : chaque fois, le bloc refait tout son travail.

Comprendre

Une fois que tu as défini un bloc (par exemple « carré »), tu sais qu'il ne fait rien tout seul. Pour le faire fonctionner, tu dois l'appeler. Appeler un sous-programme, c'est tout simplement écrire son nom dans ton programme principal.

Dès que le lutin arrive sur la ligne « carré », il va exécuter toutes les instructions que tu as placées sous « définir carré », l'une après l'autre, puis il revient continuer le programme. Écrire « carré », c'est donc lancer d'un coup tout le contenu du bloc. Le gros avantage, c'est que tu peux appeler le même bloc autant de fois que tu veux, sans réécrire ses instructions.

Si tu veux tracer trois carrés, tu écris trois fois « carré » (en déplaçant le lutin entre chaque, par exemple), et le bloc refait son tracé complet à chaque appel. C'est comme un bouton : appuyer une fois lance toute l'action ; appuyer dix fois la lance dix fois. C'est cette possibilité d'appeler un bloc plusieurs fois qui rend les sous-programmes si utiles : on définit une seule fois, et on réutilise à volonté.

Il faut bien distinguer les deux étapes : « définir carré » crée le bloc une fois pour toutes ; « carré » écrit dans le programme l'appelle et déclenche son exécution.

Le cours

Appeler un sous-programme consiste à utiliser le bloc qu'on a défini en écrivant son nom dans le programme. Dans Scratch, une fois le bloc « carré » défini, il apparaît dans la palette ; pour l'appeler, on le glisse dans le script et on écrit ainsi « carré ». Lorsque l'exécution du programme atteint cette instruction, l'ordinateur exécute la totalité des instructions placées sous « définir carré », dans l'ordre, puis reprend le programme à la suite de l'appel.

Un appel déclenche donc l'exécution complète du sous-programme. L'intérêt majeur est la réutilisation : on peut appeler le même bloc autant de fois qu'on le souhaite, sans jamais recopier ses instructions. Pour tracer plusieurs carrés, il suffit d'écrire plusieurs fois « carré » (en intercalant par exemple des déplacements du lutin), et chaque appel reproduit fidèlement le tracé.

On peut aussi appeler un bloc à l'intérieur d'une boucle pour le répéter automatiquement. Il est essentiel de ne pas confondre définir et appeler : définir crée le bloc et décrit son contenu sans rien exécuter ; appeler, c'est écrire son nom pour le faire réellement fonctionner. Maîtriser l'appel d'un sous-programme, c'est comprendre qu'un seul mot (le nom du bloc) suffit à relancer toute une suite d'instructions, autant de fois que nécessaire.

Les erreurs fréquentes

Pour exécuter un sous-programme, il faut recopier toutes ses instructions à chaque endroit où on en a besoin.

Non : il suffit d'écrire le nom du bloc (« carré »). Cet appel exécute à lui seul toutes les instructions du sous-programme, sans avoir à les recopier.

Un sous-programme ne peut être appelé qu'une seule fois dans un programme.

On peut appeler le même bloc autant de fois qu'on veut : chaque appel ré-exécute toutes ses instructions. C'est justement ce qui rend les sous-programmes utiles.

Tu maîtrises la notion si…

• Décrire l'appel : écrire le nom d'un bloc dans le programme exécute toutes ses instructions.
• Interpréter qu'un appel déclenche le contenu complet du sous-programme, puis rend la main au programme.
• Savoir qu'on peut appeler un même bloc plusieurs fois pour répéter son action sans le recopier.