# Référence de programmation &turtlelang;

Ceci est le manuel de référence du logiciel de programmation &turtlelang; de &kturtle;. Dans ce chapitre, nous verrons d'abord brièvement les différents types d'instructions. Les commandes seront alors expliquées une par une. Les conteneurs, les mathématiques, les questions et contrôleurs d'exécution seront ensuite expliqués. Enfin, nous vous montrerons comment créer vos propres commandes avec Apprends.

## Différents types d'instructions

Comme dans tout langage, &turtlelang; possède différents types de mots et de symboles. Les différences entre les types sont expliquées brièvement ici.

### Commandes

En utilisant les commandes, vous dites à la tortue ou à &kturtle; de faire quelque chose. Certaines commandes ont besoin d'une entrée.

    # avance est une commande qui nécessite une entrée, ici le nombre 100 :
    avance 100

Pour une étude détaillée de toutes les commandes gérées par &kturtle;, allez ici.

### Nombres

Vous savez probablement certaines choses sur les nombres. La façon dont ils sont utilisés dans &kturtle; n'est pas très différente de la façon dont on les utilise dans le langage parlé, ou avec les mathématiques.

Nous avons les nombres appelés nombre naturels : `0`, `1`, `2`, `3`, `4`, `5`, etc. Les nombres négatifs : `-1`, `-2`, `-3`, etc. Enfin les nombres décimaux, où nombres à virgule, par exemple : `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`.

Les nombres peuvent être utilisés dans des calculs mathématiques et dans des questions. Ils peuvent également être placés dans des conteneurs.

Les chaînes sont surlignées en rouge sombre dans l'éditeur de code.

### Chaînes

Tout d'abord un exemple :

    écris "Bonjour, je suis une chaîne."

Dans cet exemple, `écris` est une commande et `Bonjour, je suis une chaîne.` est une chaîne. Les chaînes commencent et se terminent par un symbole `"`. Grâce à ces symboles, &kturtle; sait qu'il s'agit d'une chaîne.

Les chaînes peuvent être placées dans des conteneurs. Cependant, elles ne peuvent pas être utilisées dans des calculs mathématiques ou dans des questions.

Les chaînes sont surlignées en rouge dans l'éditeur de code.

### Noms

Lorsque vous programmez en langage &turtlelang;, vous créez de nouvelles choses. Si vous écrivez un programme, vous avez probablement besoin de conteneurs, et dans certains cas vous aurez à utiliser Apprends pour créer de nouvelles commandes. Lorsque vous créez un conteneur ou une nouvelle commande avec Apprends, vous devez spécifier un nom.

Vous pouvez choisir ce que vous voulez, à partir du moment où ce nom n'a pas déjà une signification. Par exemple, vous ne pouvez pas nommer un conteneur avance puisque ce nom est déjà utilisé pour une commande, et a donc déjà un sens.

    # ici avance est utilisé comme une nouvelle commande,
    # mais il y a déjà une correspondance
    # ceci produira une erreur :
    apprendre avance {
      écris "ceci est non-valable"
    }

    # ceci fonctionne :
    apprendre monavance {
      écris "ceci est valable"
    }

Les noms peuvent seulement contenir des lettres, des chiffres et des caractères de soulignement (_). Cependant, ils doivent commencer par une lettre. Les noms des conteneurs doivent commencer avec le préfixe de conteneur ($).

    # avance est ici utilisé comme un conteneur,
    # commençant avec le préfixe $, cela ne rentrera
    # donc pas en conflit avec la commande avance
    $avance = 20
    écris $avance

Les nombres sont surlignés en pourpre et sont en gras dans l'éditeur de code.

Veuillez lire la documentation sur les conteneurs et sur la commande Apprends pour davantage d'explications et d'autres exemples.

### Affectations

Les affectations sont faites avec le symbole `=`. Dans les langages de programmation, il est conseillé de lire un `=` unique comme « devient » au lieu de « est égal à ». L'expression « est égal à » est plus approprié pour `==` qui est une question.

Les affectations sont généralement utilisées pour deux raisons : (1) pour ajouter du contenu aux conteneurs, et (2) pour modifier le contenu d'un conteneur. Par exemple :

    $x = 10
    # le conteneur x contient maintenant le nombre 10
    W = "Mon âge est :"
    # le conteneur W contient maintenant la chaîne "Mon âge est :"
    # ceci affiche le contenu des conteneurs "W" et "x" sur le canevas
    écris $W + $x

Pour d'autres exemples, voyez la section qui traite des conteneurs.

### Symboles mathématiques

&kturtle; gère tous les symboles mathématiques de base : addition (`+`), soustraction (`-`), multiplication (`*`), division (`/`) et les parenthèses (`(` et `)`).

Pour une explication complète et d'autres exemples, voyez la section mathématiques.

### Questions

Nous pouvons poser des questions simples pour lesquelles la réponse sera « vrai » ou « faux ».

L'utilisation des questions est largement décrite dans la section questions.

### Mots collants pour questions

Les questions peuvent être collées ensemble avec des « mots collants ». Les mots collants sont `et`, `ou`, et le mot collant spécial `non`.

L'utilisation des mots collants est expliquée dans la section mots collants.

### Commentaires

Les commentaires sont des lignes qui commencent par un `#`. Par exemple :

    # ceci est un commentaire !
    écris "ceci n'est pas un commentaire"
    # la ligne précédente n'est pas un commentaire, mais la ligne suivante en est un :
    # écris "ceci n'est pas un commentaire"

Vous pouvez ajouter des commentaires dans le code pour vous-même ou pour quelqu'un d'autre. Les commentaires sont utilisés pour : (1) ajouter des descriptions courtes au programme, (2) expliquer comment un morceau de code fonctionne s'il est un peu obscur, et (3) commenter des lignes de code qui doivent être (temporairement) ignorées (voir la dernière ligne de l'exemple).

Les lignes commentées sont surlignées en gris clair dans l'éditeur de code.

## Commandes

En utilisant les commandes, vous dites à la tortue ou à &kturtle; de faire quelque chose. Certaines commandes ont besoin d'une entrée, d'autres donnent une sortie. Dans ce chapitre nous expliquons toutes les commandes qui peuvent être utilisées dans &kturtle;. Remarquez que toutes les commandes de base dont nous discutons ici sont surlignées dans l'éditeur de code. Ceci peut vous aider à les distinguer.

### Déplacer la tortue

Il y a plusieurs commandes qui déplacent la tortue sur l'écran.

avance (av)

      avance X

  `avance` fait avancer la tortue sur l'écran de X pixels. Lorsque le crayon est baissé, la tortue laisse une trace (dessine une ligne). `avance` peut se contracter en `av`

recule (re)

      recule X

  `recule` fait reculer la tortue sur l'écran de X pixels. Lorsque le crayon est baissé, la tortue laisse une trace (dessine une ligne). `recule` peut se contracter en `re`.

tournegauche (tg)

      tournegauche X

  `tournegauche` dit à la tortue de se tourner vers la gauche de X degrés. `tournegauche` peut se contracter en `tg`.

tournedroite (td)

      tournedroite X

  `tournedroite` dit à la tortue de se tourner vers la droite de X degrés. `tournedroite` peut se contracter en `td`.

direction (dir)

      direction X

  `direction` fixe la direction de la tortue de X degrés en comptant de zéro, et donc ne dépend pas de la position et de la direction précédentes de la tortue. `direction` peut se contracter en `dir`.

centre

      centre

  `centre` déplace la tortue au centre du canevas.

va

      va X,Y

  `va` commande à la tortue d'aller à un certain endroit sur le canevas. Cet endroit est à X pixels depuis la gauche du canevas et à Y pixels depuis le haut du canevas.

vax

      vax X

  `vax` : en utilisant cette commande, la tortue va se déplacer de X pixels depuis la gauche du canevas tandis qu'elle restera à la même hauteur.

vay

      vay Y

  `vay` : en utilisant cette commande, la tortue va se déplacer de Y pixels depuis le haut du canevas tandis qu'elle restera à la même distance de la bordure gauche du canevas.

En utilisant les commandes `vas`, `vax`, `vay` et `centre` la tortue ne dessinera pas une ligne, peut importe si le crayon est levé ou baissé.

### Où est la tortue ?

Il y a deux commandes qui donnent la position de la tortue sur l'écran.

positionx

  `positionx` retourne le nombre de pixels séparant la gauche du canevas de la position courante de la tortue.

positiony

  `positiony` retourne le nombre de pixels séparant le haut du canevas de la position courante de la tortue.

### La tortue a un crayon

La tortue a un crayon qui trace une ligne lorsqu'elle se déplace. Il y a peu de commandes pour contrôler le crayon. Nous expliquons ces commandes dans ce paragraphe.

lèvecrayon (lc)

      lèvecrayon

  `lèvecrayon` relève le crayon du canevas. Lorsque le crayon est levé, aucune ligne n'est tracée lorsque la tortue se déplace. Voir aussi `baissecrayon`. `lèvecrayon` peut se contracter en `lc`.

baissecrayon (bc)

      baissecrayon

  `baissecrayon` abaisse le crayon sur le canevas. Lorsque le crayon est baissé sur le canevas, une ligne est tracée lorsque la tortue se déplace. Voir aussi `lèvecrayon`. `baissecrayon` peut se contracter en `bc`.

largeurcrayon (lac)

      largeurcrayon X

  `largeurcrayon` fixe l'épaisseur (la largeur du trait) du crayon à X pixels. `largeurcrayon` peut se contracter en `lac`.

couleurcrayon (cc)

      couleurcrayon R, G, B

  `couleurcrayon` fixe la couleur du crayon. `couleurcrayon` demande une combinaison RVB comme entrée. `couleurcrayon` peut se contracter en `cc`.

### Commandes pour contrôler le canevas

Voici les différentes commandes pour contrôler le canevas.

taillecanevas (tc)

      taillecanevas X, Y

  Avec la commande `taillecanevas`, vous pouvez fixer la taille du canevas. Elle reçoit X et Y comme entrée, où X est la nouvelle largeur du canevas en pixels, et Y est la nouvelle hauteur du canevas en pixels. `taillecanevas` peut se contracter en `tc`.

couleurcanevas (cca)

      couleurcanevas R, G, B

  `couleurcanevas` fixe la couleur du canevas. `couleurcanevas` reçoit une combinaison RVB comme entrée. `couleurcanevas` peut se contracter en `cca`.

### Commandes pour nettoyer

Il existe deux commandes pour nettoyer le canevas après avoir mis le désordre.

nettoietout (ntt)

      nettoietout

  Avec `nettoietout`, vous pouvez nettoyer tous les dessins sur le canevas. Toutes les autres choses restent : la position et l'angle de la tortue, la couleur du canevas, la visibilité de la tortue et la taille du canevas.

initialise

      initialise

  `initialise` nettoie beaucoup plus profondément que la commande `nettoietout`. Après la commande `initialise`, tout redevient comme lorsque vous avez lancé &kturtle;. La tortue se place au milieu de l'écran, la couleur du canevas est blanche, la tortue trace une ligne noire sur le canevas et taillecanevas est défini à 400 x 400 pixels.

### La tortue est un lutin (sprite)

La plupart des personnes ne savent pas ce qu'un lutin (sprite) est, voici donc une courte explication : les lutins sont de petites images qui peuvent se déplacer sur l'écran. (pour plus d'information, voir le glossaire sur lutins). Donc la tortue est un lutin !

Ce qui suit est un aperçu des commandes relatives aux lutins.

[La version actuelle de &kturtle; ne gère pas encore l'utilisation des lutins autres que la tortue. Dans des versions futures vous pourrez remplacer la tortue par quelque chose de votre propre conception ! ]

montre (mo)

      montre

  `montre` rend de nouveau la tortue visible après avoir été cachée.`montre` peut être abrégé par `mo`.

cache (ca)

      cache

  `cache` cache la tortue. Ceci peut être utilisé si la tortue ne s'adapte pas à votre dessin. `cache` peut se contracter en `ca`.

### La tortue peut-elle écrire du texte ?

La réponse est : oui. La tortue peut écrire, elle écrit tout ce que vous lui commander d'écrire.

écris

      écris X

  La commande `écris` est utilisée pour commander à la tortue d'écrire quelque chose sur le canevas. `écris` reçoit des nombres et des chaînes de caractères comme entrée. Vous pouvez utiliser `écris` pour écrire plusieurs nombres et chaînes en utilisant le symbole +. Voici un petit exemple :

      $année = 2003
      $auteur = "Cies"
      écris $auteur + " a commencé de projet KTurtle en" + $année + "et prend
       toujours du plaisir à travailler dessus !"

taillepolice

      taillepolice X

  `taillepolice` fixe la taille de la police qui est utilisée par la commande `écris`. `taillepolice` reçoit une entrée qui doit être un nombre. La taille est fixée en pixels.

### Une commande qui lance un dé pour vous

Il existe une commande qui lance un dé pour vous, elle s'appelle `hasard`, et est très utile pour des résultats inattendus.

hasard

      hasard X, Y

  `hasard` est une commande qui demande une entrée et qui vous donne une sortie. Comme entrée sont requis deux nombres, le premier (X) donne la sortie minimale, et le second (Y) fixe le maximum. La sortie est un nombre choisi au hasard qui est égal ou plus grand que le minimum et égal ou plus petit que le maximum. Voici un petit exemple :

       répète 500 [
        $x = hasard 1, 20
        avance $x
        tournedroite 10 - $x
      ]

  En utilisant la commande `hasard`, vous pouvez ajouter un peu de chaos dans votre programme.

### Entrée et retour avec les boîtes de dialogue

Une boîte de dialogue est une petite fenêtre contextuelle qui fournit du retour ou demande des choses en entrée. &kturtle; possède deux commandes pour les boîtes de dialogue : `message` et `fenêtreentrée`

message

      message X

  La commande `message` prend une chaîne en entrée. Elle affiche une boîte de dialogue contenant le texte de la chaîne.

      message "Cies a commencé de projet KTurtle en 2003 et prend toujours du
      plaisir à travailler dessus !"

demande

      demande X

  `demande` prend une chaîne en entrée. Elle affiche une boîte de dialogue contenant le texte de la chaîne, tout comme la commande message. Mais en plus, elle affiche un champ d'entrée dans la boîte de dialogue. Vous pouvez alors saisir grâce à ce champ un nombre ou une chaîne qui sera stocké dans un conteneur. Par exemple,

      $entrée = demande "Quel est votre âge ?"
      $sortie = 2005 - $entrée
      écris "En 2005, vous aviez " + $sortie + " ans."

  Lorsqu'un utilisateur annule la boîte de dialogue, ou ne met rien du tous, le conteneur est vidé.

## Conteneurs

Les conteneurs sont des lettres ou des mots qui peuvent être utilisés par le programmeur pour stocker un nombre ou un texte. Les conteneurs qui contiennent un nombre sont appelés des variables et les conteneurs qui contiennent du texte sont appelés des chaînes. Les conteneurs peuvent être identifiés par le caractère $ qui précède son usage.

Les conteneurs qui ne sont pas encore utilisés ne contiennent rien. Un exemple :

    écris $N

Cela n'écrira rien et nous aurons un message d'erreur.

### Variables : conteneurs de nombres

Commençons avec un exemple :

    $x = 3
    écris $x

À la première ligne, la lettre `x` est utilisée comme une variable (un conteneur de nombres). Comme vous le voyez, la valeur de la variable `x` est fixée sur 3. La deuxième ligne imprime la valeur.

Remarquez que si nous avions voulu afficher un x, nous aurions dû écrire :

    écris "x"

C'était facile, voyons maintenant un exemple plus difficile :

    $A = 2004
    $B = 25
    $C = $A + $B

    # la commande suivante affiche « 2029 »
    écris $C
    recule 30
    # la commande suivante affiche « 2004 plus 25 »
    écris $A + " plus " + $B
    recule 30
    # la commande suivante affiche « 1979 »
    écris $A - $B

Dans les deux premières lignes, les variables `A` et `B` sont fixées à 2004 et 25. À la troisième ligne, la variable `C` est fixée `A + B`, qui vaut 2029. Le reste de l'exemple consiste en trois commandes `écris` avec les `recule 30` entre. Les lignes `recule 30` sont là pour assurer que chaque sortie est imprimée sur une nouvelle ligne. Dans cet exemple, vous voyez aussi que les variables peuvent être utilisées dans des calculs mathématiques.

### Conteneurs contenant du texte (chaînes)

Dans un programme, le texte commence et se termine généralement par des guillemets. Comme vous l'avez déjà vu :

    écris "Bonjour programmeur !"

Le texte est délimité par des guillemets. Ce texte est appelé une chaîne.

Les chaînes peuvent également être stockées dans des conteneurs, tout comme les nombres. La plus grosse différence est que les chaînes ne peuvent pas être utilisées dans des calculs mathématiques et des questions. Voici un exemple d'utilisation des chaînes :

    $x = "Bonjour"
    nom = demande "Veuillez saisir votre nom..."
    écris $x + nom + ", comment allez vous ?"

À la première ligne, la variable `x` est fixée à Bonjour . À la deuxième ligne, la chaîne `nom` est fixée sur la sortie de la commande `demande`. À la troisième ligne, le programme affiche une concaténation des trois chaînes sur le canevas.

Ce programme vous demande de saisir votre nom. Lorsque par exemple vous saisissez le nom Paul, le programme imprime Bonjour Paul, comment allez vous ? . Remarquez que le signe plus (+) est le seul symbole mathématique que vous pouvez utiliser avec des chaînes.

## Est ce que la tortue peut faire des maths ?

Oui, &kturtle; peut aussi calculer. Vous pouvez ajouter (+), soustraire (-), multiplier (*) et diviser (/). Voici un exemple dans lequel nous allons tous les utiliser :

    $a = 20 - 5
    $b = 15 * 2
    $c = 30 / 30
    $d = 1 + 1
    écris "a : " + $a + ", $b : " + b + ", c : " + $c + ", d : " + $d

Savez vous quelles valeurs ont a, b, c et d ? Notez le symbole d'affectation `=`.

Si vous voulez faire simplement un calcul, vous pouvez le faire de la façon suivante :

    écris 2004-12

Voici maintenant un exemple avec des parenthèses :

    écris ( ( 20 - 5 ) * 2 / 30 ) + 1

Les expressions dans les parenthèses vont être calculées les premières. Dans cet exemple, 20-5 sera calculé, puis multiplié par 2, divisé par 30, puis 1 est ajouté (ce qui donne 2).

&kturtle; possède des fonctions mathématiques avancées. Il connaît le nombre `pi` et les fonctions trigonométriques comme `sin`, `cos`, `tan`, `arcsin`, `arccos`, `arctan` et les fonctions `sqrt` et `exp`.

### Laisser la tortue arrondir les nombres

Si vous avez besoin d'entiers dans les calculs, utilisez cette fonction.

arrondi

      arrondi(x)

  `arrondi` le nombre donné à l'entier le plus proche.

      écris arrondi(10.8)
      avance 20
      écris arrondi(10.3)
      avance 20

  Avec ce code, la tortue écrira les nombre 11 et 10.

## Poser des questions, obtenir des réponses...

`si` et `pendant` sont des contrôleurs d'exécution dont nous allons discuter dans le prochain paragraphe. Dans ce paragraphe nous utilisons la commande `si` pour expliquer les questions.

### Questions

Un simple exemple de question :

    $x = 6
    si $x > 5 {
      écris "bonjour"
    }

Dans cet exemple, la question est la partie `x > 5`. Si la réponse à cette question est vraie, le code entre les crochets sera exécuté. Les questions sont une partie importante en programmation et sont souvent utilisées avec des contrôleurs d'exécution, comme `si`. Tous les nombres et variables (conteneurs de nombres) peuvent être comparés les uns aux autres grâce à des questions.

Voici toutes les questions possibles :

#### Types de questions

`a == b` | égal à | la réponse est vraie si `a` est égal à `b`
`a != b` | non égal | la réponse est vraie si `a` n'est pas égal à `b`
`a > b` | plus grand que | la réponse est vraie si `a` est plus grand que `b`
`a < b` | plus petit que | la réponse est vraie si `a` est plus petit que `b`
`a >= b` | plus grand ou égal | la réponse est vraie si `a` est plus grand ou égal à `b`
`a <= b` | plus petit ou égal | la réponse est vraie si `a` est plus petit ou égal à `b`

### Mots collants pour questions

Les mots collants pour les questions nous permettent d'assembler plusieurs questions pour n'en former plus qu'une.

    $a = 1
    $b = 5
    si ($a < 5) et ($b == 5) {
      écris "bonjour"
    }

Dans cet exemple, le mot collant `et` est utilisé pour rassembler deux questions (`a < 5`, `b == 5`) ensemble. Si un côté de `et` répondait faux toute la question aurait pour réponse faux, parce qu'avec le mot collant `et` les deux côtés doivent être vrai pour répondre vrai. N'oubliez pas d'utiliser les parenthèses autour des questions !

Voici un aperçu schématique, une explication plus détaillée suit plus bas :

#### Mots collants pour questions

`et` | les deux côtés doivent être vrai pour que la réponse soit vrai
`ou` | si l'un des côtés est vrai la réponse est vrai
`non` | Cas particuliers : ne fonctionne que sur une question ! change « vrai » en « faux » et « faux » en « vrai ».

#### et

Lorsque deux questions sont assemblées avec `et`, les deux côtés du `et` doivent être « vrai » pour que le résultat soit « vrai ». Un exemple :

    $a = 1
    $b = 5
    si (($a < 10) et ($b == 5)) et ($a < $b) {
      écris "bonjour"
    }

Dans cet exemple, vous avez deux questions collées, assemblées à une troisième question.

#### ou

Si une des deux questions qui sont assemblées avec `ou` est « vrai », le résultat sera « vrai ». Un exemple :

    $a = 1
    $b = 5
    si (($a < 10) ou ($b == 10)) ou ($a == 0) {
      écris "bonjour"
    }

Dans cet exemple, vous voyez un assemblage de deux questions combiné avec une troisième question.

#### non

`non` est un mot collant spécial car il ne fonctionne qu'avec une question à la fois. `non` change « vrai » en « faux » et « faux » en « vrai ». Un exemple :

    $a = 1
    $b = 5
    si non (($a < 10) et ($b == 5)) {
      écris "bonjour"
    }
    sinon
    {
      écris "pas bonjour ;-)"
    }

Dans cet exemple, la question collée est « vrai », pourtant le `non` le change en « faux ». Ainsi, en fin de compte, `"pas bonjour ;-)"` est affiché sur le canevas.

## Contrôler l'exécution

Les contrôleurs d'exécution vous permettent, — comme leur nom l'indique — de contrôler l'exécution.

Les commandes de contrôle d'exécution sont surlignées en vert foncé en utilisant une police en gras. Les accolades sont principalement utilisées avec les contrôleurs d'exécution et sont surlignées en noir et en gras.

### Faite attendre la tortue

Si vous avez exécuté quelques programmes dans &kturtle; vous pouvez avoir remarqué que la tortue se déplace très rapidement pour dessiner. La commande suivante ralentit la tortue.

attends

      attends X

  `attends` fait attendre la tortue pendant X secondes.

      répète 36 {
        avance 5
        tournedroite 10
        attends 0.5
      }

  Ce code dessine un cercle, mais la tortue va attendre une demi-seconde après chaque étape. Cela donne l'impression d'une tortue qui va moins vite.

### Exécute « si »

si

      si question [ ... ]

  Le code qui est placé entre les accolades sera exécuté seulement `si` la réponse à la question est vrai. Pour plus d'information, veuillez lire le paragraphe sur les questions dans la page des questions.

      nettoietout
      $x = 6
      si $x > 5 {
        écris "x est plus grand que cinq !"
      }

  À la première ligne, `x` est fixé à 6. À la seconde ligne, la question `x > 5` est posée. Comme la réponse à la question est vraie, le contrôleur d'exécution `si` va permettre au code entre crochets d'être exécuté.

### Si non, en d'autres termes : « sinon »

sinon

      si question [ ... ] sinon [ ... ]

  `sinon` peut être utilisé en plus du contrôleur d'exécution `si`. Le code entre accolades après `sinon` n'est exécuté que si la réponse à la question qui est posée est fausse.

      initialise
      $x = 4
      si $x > 5 {
        écris "x est plus grand que cinq !"
      } sinon {
        écris "x est plus petit que six !"
      }

  La question demande si `x` est plus grand que 5. Comme `x` est fixé à 4 à la première ligne, la réponse à la question est fausse. Cela signifie que le code entre accolades après `sinon` est exécuté.

### La boucle « tantque »

tantque

      tantque question [ ... ]

  Le contrôleur d'exécution `tantque` ressemble beaucoup à `si`. La différence est que `tantque` répète le code entre accolades jusqu'à ce que la réponse à la question soit faux.

      $x = 1
      tantque $x < 5 {
        avance 10
        attends 1
        $x = $x + 1
      }

  À la première ligne, `x` est fixé à 1. À la seconde ligne, la question `x < 5` est posée. Comme la réponse à cette question est vraie, le contrôleur d'exécution `tantque` commence à exécuter le code entre accolades jusqu'à ce que la réponse à la question soit faux. Dans ce cas, le code entre accolades sera exécuté quatre fois, à chaque fois que la cinquième ligne est exécutée, `x` augmente de 1.

### La boucle « répète »

répète

      répète nombre { ... }

  Le contrôleur d'exécution `répète` est similaire à `tantque`. La différence est que `répète`laisse en boucle le code entre accolades pour le nombre donné.

### La boucle « pour », une boucle de comptage

pour

      pour point de départ à point d'arrivée [ ... ]

  La boucle `pour` est une boucle de comptage, &cad; qu'elle compte à votre place.

      pour $x = 1 à 10 {
        écris $x * 7
        avance 15
      }

  Chaque fois que le code entre accolades est exécuté, la valeur de `x` augmente de 1, jusqu'à ce que `x` atteigne la valeur 10. Le code entre les accolades écrit `x` multiplié par 7. Après que ce programme a fini son exécution, vous allez voir la table de multiplication de 7 imprimée sur le canevas.

  La taille du pas par défaut de la boucle est 1, vous pouvez utiliser une autre valeur avec :

      pour point de départ à point d'arrivée pas taille pas { ... }

### Quitter la boucle

coupure

      coupure

  Termine immédiatement la boucle courante et transfert le contrôle à la déclaration qui suit la boucle.

### Arrêter la tortue

sortie

      sortie

  Termine l'exécution du code.

## Créez vos propres commandes !

`apprends` est une commande très spéciale, car elle est utilisée pour créer vos propres commandes. La commande que vous créez peut recevoir des entrées et retourner des sorties. Regardons maintenant comment une nouvelle commande est créée :

    apprends cercle $x {
      répète 36 {
        avance $x
        tournegauche 10
      }
    }

La nouvelle commande est appelée `cercle`. `cercle` reçoit une entrée, un nombre, qui fixe la taille du cercle. `cercle` ne retourne aucune sortie. La commande `cercle` peut maintenant être utilisée comme une commande normale dans la suite du programme. Voyez cet exemple :

    apprends cercle $X {
      répète 36 {
        avance $X
        tournegauche 10
      }
    }

    va 30,30
    cercle 20

    va 40,40
    cercle 50

Dans l'exemple suivant, une commande avec une valeur de retour est créée.

    apprends multiplierParSoi $n {
      $r = $n * $n
      retourne $r
    }
    $i = demande "Veuillez saisir un nombre et appuyer sur Ok"
    écris $i + " multiplié par lui-même donnr : " + multiplierParSoi $i

Dans cet exemple, une nouvelle commande appelée `multiplierParSoi` est créée. L'entrée de cette commande est multipliée par elle-même puis retournée, en utilisant la commande `retourne`. La commande `retourne` est le seul moyen de sortir une valeur de la fonction que vous avez créée.

Les commandes peuvent avoir plus d'une entrée. Dans l'exemple suivant, une commande qui dessine un rectangle est créé.

    apprends boîte $X, $Y {
      avance $Y
      tournedroite 90
      avance $X
      tournedroite 90
      avance $Y
      tournedroite 90
      avance $X
      tournedroite 90
    }

Maintenant vous pouvez lancer `boîte 50, 100` et la tortue dessinera un rectangle sur le canevas.