# Référence de programmation &turtlescript;

Ceci est le chapitre de référence &turtlescript; de &kturtle;. La première section de ce chapitre donne quelques aspects de la grammaire des programmes en &turtlescript;. La deuxième section traite exclusivement des opérateurs mathématiques, des opérateurs booléens (vrai / faux) et des opérateurs de comparaison. La troisième partie est une énorme liste de toutes les commandes, expliquées une par une.La section quatre explique comment assigner des valeurs aux variables. Enfin, nous expliquons comment arranger l'exécution des commandes avec les instructions de contrôle d'exécution dans la section cinq, et comment créer vos propres commandes avec apprends dans la section six.

## La grammaire de &turtlescript;

Comme tout langage, &turtlescript; dispose de différents types de mots et de symboles. En français, nous distinguons les verbes (comme « marcher » ou « chanter »), et les noms (comme « soeur » ou « maison »), ils sont utilisés pour différents objectifs. &turtlescript; est un langage de programmation, il est utilisé pour indiquer à &kturtle; ce qu'il faut faire.

Dans cette section, certains types de mots et symboles de &turtlescript; sont expliqués brièvement. Nous expliquons les commentaires, les commandes et les trois différents types de littéraux : les nombres, les chaînes et les booléens (vrai / faux).

### Commentaires

Un programme est constitué d'instructions qui sont exécutées lorsque le programme est lancé, et de commentaires. Les commentaires ne sont pas exécutés. &kturtle; les ignore simplement lors que votre programme est exécuté. Ils sont là pour aider les autres programmeurs à mieux comprendre votre programme. Tout ce qui suit le symbole `#` est considéré comme un commentaire en &turtlescript;. Par exemple, ce petit programme ne fait rien :

    # ce petit programme ne fait rien, c'est juste un commentaire !

C'est un peu inutile, mais ça explique bien les choses.

Les commentaires sont très utiles lorsque le programme devient un peu plus complexe. Il peut aider à donner des conseils aux autres programmeurs. Dans le programme suivant, vous pouvez voir l'utilisation des commentaires avec la commande print.

    # Ce programme a été écrit par Cies  Breijs.
    écris "ce texte sera affiché sur le canevas"
    # la ligne précédente n'est pas un commentaire, mais la ligne suivante en est un :
    # écris "ce texte ne sera pas affiché :"

La première ligne décrit le programme. La deuxième est exécutée par &kturtle; et écrit `Ce texte sera affiché sur le canevas` sur le canevas. La troisième ligne est un commentaire. Et la quatrième ligne est un commentaire qui contient un morceau de &turtlescript;. Si le symbole `#` était enlevé dans la quatrième ligne, l'instruction écris serait exécutée par &kturtle;. Les programmeurs disent que l'instruction écris dans la quatrième ligne est « commentée ».

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

### Commandes

À l'aide des commandes, vous dites à la tortue ou à &kturtle; de faire quelque chose. Certaines commandent nécessitent un paramètre, d'autres donnent une sortie.

    # avance est une commande qui nécessite un paramètre, dans ce cas le nombre 100 :
    avance 100

La première ligne est un commentaire. La seconde ligne contient la commande `avance` et le nombre `100`. Le nombre ne fait pas partie de la commande, mais est considéré comme un « paramètre » de la commande.

Pour une étude détaillée de toutes les commandes gérées par &kturtle;, allez ici. Les commandes internes sont surlignées en bleu foncé.

### 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 opérateurs mathématiques et dans des opérateurs de comparaison. Ils peuvent également être placés dans des variables. Les nombres sont surlignés en rouge foncé.

### 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 variables, tout comme les nombres. Cependant, contrairement aux nombres, les chaînes ne peuvent pas être utilisées avec les opérateurs mathématiques ou avec les opérateurs de comparaison. Les chaînes sont surlignées en rouge.

### Les valeurs booléennes (vrai / faux)

Il y a deux types de valeurs booléennes : `vrai` et `faux`. Parfois on les appelle également on et off, oui et non, un et zéro. Mais en &turtlescript;, on les appelle toujours `vrai` et `faux`. Regardez cet extrait de &turtlescript; :

    $a = vrai

Si vous regardez dans l'inspecteur, vous verrez que la variable $a est réglée sur `vrai`, et a le type booléen.

Souvent, les valeurs booléennes sont le résultat d'un opérateur de comparaison, comme dans le morceau de &turtlescript; suivant :

    $reponse = 10 > 3

La variable `$reponse` est placée à `vrai` car `10` est plus grand que `3`.

Les valeurs booléenne `vrai`et `faux` sont surlignées en rouge foncé.

## Les opérateurs mathématiques, booléens et de comparaison

Le titre de cette section peut sembler compliqué, mais ça ne l'est pas autant que ça en a l'air.

### Les opérateurs mathématiques

Il y a les symboles mathématiques de base connus comme : l'addition (`+`), la soustraction (`-`), la multiplication (`*`), division (`/`) et la puissance (`^`).

Voici un petit exemple sur les opérateurs mathématiques que vous pouvez utiliser dans &turtlescript; :

    $somme = 1 + 1
    $difference = 20 - 5
    $produit = 15 * 2
    $rapport = 30 / 30
    $puissance = 2 ^ 2

Les valeurs résultant de ces opérateurs mathématiques sont assignées aux différentes variables. En utilisant l'inspecteur, vous pouvez voir ces valeurs.

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

    écris 2010-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). Les parenthèses peuvent également être utilisées dans d'autres cas.

&kturtle; dispose également de caractéristiques mathématiques plus avancées sous la forme de commandes. Jetez un œil aux commandes suivantes, mais gardez à l'esprit qu'il s'agit d'opérations avancées : arrondi, hasard, racine, pi, sin, cos, tan, arcsin, arccos, arctan.

### Opérateurs booléens (vrai / faux)

Tandis que les opérateurs mathématiques travaillent avec des nombres, les opérateurs booléens travaillent avec des valeurs booléennes (`vrai` et `faux`). Il y a seulement trois opérateurs booléens : `et`, `ou` et `non`. Le morceau de &turtlescript; suivant montre comment les utiliser :

    $et_1_1 = vrai et vrai    # -> vrai
    $et_1_0 = vrai et faux   # -> faux
    $et_0_1 = faux et vrai   # -> faux
    $et_0_0 = faux et faux  # -> faux

    $ou_1_1 = vrai ou vrai    # -> vrai
    $ou_1_0 = vrai ou faux   # -> vrai
    $ou_0_1 = faux ou vrai   # -> vrai
    $ou_0_0 = faux ou faux  # -> faux

    $non_1 = non vrai   # -> faux
    $non_0 = non vrai   # -> vrai

En utilisant l'inspecteur, vous pouvez voir les valeurs, bien que nous fournissons ces résultats en petits commentaires à la fin de chaque ligne. `et` ne vaut `vrai` seulement si les deux côtés sont `vrais`. `ou` vaut `vrai` si l'un des deux côtés est `vrai`. Et `non` passe `vrai`en `faux`, et `faux` en `vrai`.

Les opérateurs booléens sont surlignés en rose.

#### Quelques exemples plus complexes

Considérons l'exemple suivant avec `et` :

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

Dans ce morceau de &turtlescript;, le résultat de trois opérateurs de comparaison sont fusionnés en utilisant des opérateurs `et`. Ceci signifie que les trois opérateurs doivent donner vrai pour que le texte « bonjour » soit affiché.

Un exemple avec `ou` :

    $n = 1
    si ($n < 10) ou ($n == 2) {
      écris "bonjour"
    }

Dans ce morceau de &turtlescript;, la partie gauche du `ou` donne « vrai », la partie droite donne « faux ». Comme un des deux côtés de l'opérateur `ou` est « vrai », l'opérateur `ou` vaut « vrai ». Ceci signifie que « bonjour » sera affiché.

Et pour terminer un exemple avec `non`, qui change « vrai » en « faux » et « faux » en « vrai ». Regardez :

    $n = 1
    si non ($n == 3) {
      écris "bonjour"
    } sinon {
      écris "pas bonjour ;-)"
    }

### Opérateurs de comparaison

Considérons cette comparaison simple :

    $reponse = 10 >

Ici, `10` est comparé à `trois` avec l'opérateur « plus grand que ». le résultat de cette comparaison, la valeur booléenne `vrai` est stockée dans la variable `$reponse`.

Tous les nombres et variables (qui contiennent des nombres) peuvent être comparés entre eux avec les opérateurs de comparaison.

Voici tous les opétateurs de comparaison possibles :

#### Type de question

`$A == $B` | egal | la réponse est vrai si `$A` est égal à `$B`
`$A != $B` | non égal | la réponse est vrai si `$A` n'est pas égal à `$B`
`$A > $B` | plus grand que | la réponse est vrai si `$A` est plus grand que `$B`
`$A < $B` | plus petit que | la réponse est vrai si `$A` est plus petit que `$B`
`$A >=$ B` | supérieur ou égal | la réponse est vrai si `$A` est plus grand ou égal à `$B`
`$A <= $B` | inférieur ou égal | la réponse est vrai si `$A` est plus petit ou égal à `$B`

Notes que $A et $B doivent être des nombres ou des variables qui contiennent ces nombres.

## 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 cette section, nous expliquons toutes les commandes internes de &kturtle;. Vous pouvez également créer vos propres commandes avec apprends. Les commandes internes discutées ici sont surlignées en bleu foncé.

### 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.

### Commandes mathématiques

Les commandes suivantes sont des commandes mathématiques de &kturtle; plus avancées.

arrondi

      arrondi(x)

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

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

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

hasard (hsd)

      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.

racine

      racine X

  La commande `racine` est utilisée pour trouver la racine carrée d'un nombre X.

pi

      pi

  Cette commande renvoie la constante PI, `3,14159`.

sin
, cos
, tan

      sin X
      cos X
      tan X

  Ces trois commandes représentent les fameuses fonctions trigonométriques `sin`, `cos` et `tan`. L'argument en entrée pour ces trois commandes, X, est un nombre.

arcsin
, arccos
, arctan

      arcsin X
      arccos X
      arctan X

  Ces commandes sont les fonctions inverse des fonctions sin, cos et tan. L'argument en entrée pour ces trois commandes, X, est un nombre.

### 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 `demande`

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é à travailler sur KTurtle en 2003 et s'amuse toujours à travailler dessus !"

demande

      demande X

  `demande` prend une chaîne en entrée. Elle affiche cette chaîne une boîte de dialogue (similaire à message), ainsi qu'un champ d'entrée. Après que l'utilisateur a saisi un nombre ou une chaîne, le résultat peut être stocké dans une variable ou passé comme argument à une commande. Par exemple :

       $entree = demande "quelle est votre année de naissance ?"
      $sortie = 2010 - $in
      écris "En 2010, vous avez eu " + $sortie + " ans à un moment donné."

  Si l'utilisateur annule la boîte de dialogue, ou ne met rien du tous, la variable est vide.

## Affectations des variables

Nous devons d'abord regarder les variables, ensuite, nous verrons comment affecter des valeurs à ces variables.

Les variables sont des mots qui commencent par un $, dans l'éditeur, elles sont surlignées en violet.

Les variables contiennent soit des nombres, des chaînes ou des valeurs booléennes (vrai / faux). En utilisant une affectation, `=`, une variable reçoit son contenu. Elle le conservera jusqu'à ce que le programme se termine ou qu'on assigne quelque chose d'autre à la variable.

Vous pouvez utiliser les variables, une fois affectées, tout comme s'il s'agissait de leur contenu. Par exemple, dans le morceau de &turtlescript; :

     $x = 10
    $x = $x / 3
    écris $x

Tout d'abord la variable `$x` se voit affecter la valeur `10`. Ensuite, `$x` se voit de nouveau affecter sa propre valeur divisée par `3` — ceci signifie en fait que `$x` est affectée du résultat de `10 / 3`. Enfin, `$x` est affichée. Dans les lignes deux et trois, vous voyez que `$x` est utilisé comme s'il s'agissait de son contenu.

Les variables doivent être affectées avant de pouvoir être utilisées. Par exemple :

    écris $n

donnera un message d'erreur.

Regardez le morceau de &turtlescript; suivant :

    $a = 2004
    $b = 25

    # la commande suivante affiche « 2029 »
    écris $a + $b
    recule 30
    # la commande suivante écrit "2004 plus 25 égal 2009"
    écris $a + " plus " + $b  + " égal " + ($a + $b)

Dans les deux premières lignes, les variables `$a` et `$b` sont initialisées à 2004 et 25. Ensuite viennent les deux commandes `écris` et un `recule 30` entre. Les commentaires avant les commandes `écris` expliquent ce que ces commandes font. La commande `recule 30` est ici pour s'assurer que chaque sortie se trouve sur une nouvelle ligne. Comme vous le voyez, les variables peuvent être utilisée comme s'il s'agissait de leur contenu, vous pouvez les utiliser avec n'importe quel type d'opérateurs ou les passer en entrée lorsque vous appelez des commandes.

Un autre exemple :

    $nom = demande "Quel est votre nom ?"
    écris "Salut " + $nom +  " ! Bonne chance dans l'apprentissage de la programmation..."

Plutôt direct. Encore une fois, vous voyez que la variable `$nom` est traitée comme une chaîne.

Lorsque vous utilisez des variables, l'inspecteur est très utile. Il vous montre le contenu de toutes les variables actuellement en cours d'utilisation.

## 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.

### 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 booléen { ... }

  Le code qui est placé entre les accolades sera exécuté seulement `si` la valeur booléenne vaut vrai.

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

  À la première ligne, `$x` est fixé à 6. À la seconde ligne, un opérateur de comparaison est utilisé pour évaluer `$x > 5`. Comme le résultat est vrai, 6 est plus grand que 5, le contrôleur d'exécution `si` va permettre au code entre accolades d'être exécuté.

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

sinon

      si booléen { ... } 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 le booléen vaut faux.

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

  L'opérateur de comparaison évalue l'expression `$x > 5`. Comme 4 n'est pas plus grand que 5, l'expression vaut faux. Cela signifie que le code entre accolades après `sinon` est exécuté.

### La boucle « tantque »

tantque

      tantque booléen { ... }

  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 le booléen vaut faux

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

  À la première ligne, `$x` est fixé à 1. À la seconde ligne, `$x < 5` est évalué. Comme la réponse à cette question est vrai, le contrôleur d'exécution `tantque` commence à exécuter le code entre accolades jusqu'à ce que `$x < 5` 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 autant de fois que le nombre donné.

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

pour

      pour variable = nombre à nombre { ... }

  La boucle `pour` est une boucle de comptage, &cad; qu'elle compte à votre place. Le premier nombre règle la variable pour la première boucle. À chaque boucle, le nombre est incrémenté jusqu'à ce que la seconde valeur soit atteinte.

      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 variable = nombre à nombre pas nombre { ... }

### Quitter la boucle

coupure

      coupure

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

### Arrête l'exécution du programme

sortie

      sortie

  Termine l'exécution de votre programme.

## 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 un argument en entrée, 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 factorielle $x {
      $r = 1
      pour $i = 1 à $x {
        $r = $r * $i
      }
      retourne $r
    }

    écris factorielle 5

Dans cet exemple, une nouvelle commande appelée `factorielle` est créée. Si l'entrée de la commande est `5`, alors la sortie sera `5*4*3*2*1`. En utilisant `retourne`, la valeur de sortie est spécifiée et le résultat est renvoyé.

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.