# Guida alla programmazione &turtlescript;

Questa è la guida del linguaggio &turtlescript; di &kturtle;. La prima sezione di questo capitolo offre una carrellata di alcuni degli aspetti della grammatica dei programmi &turtlescript;. La seconda tratta esclusivamente di operatori matematici, di operatori booleani (vero/falso) e di operatori di confronto. La terza sezione fornisce invece una lunga lista di tutti i comandi, spiegandoli uno per uno. La quarta spiega come assegnare dei valori alle variabili. Infine, nella quinta spieghiamo come organizzare l'esecuzione dei comandi usando le istruzioni di controllo dell'esecuzione, infine, nella sesta sezione, come creare propri comandi usando `impara`.

## La grammatica &turtlescript;

Come in ogni lingua, &turtlescript; ha diversi tipi di parole e simboli. In italiano distinguiamo tra verbi (come «camminare» o «cantare») e nomi (come «sorella» o «casa»), usati per scopi diversi. &turtlescript; è un linguaggio di programmazione, usato per dire a &kturtle; cosa fare.

In questa sezione sono brevemente spiegati alcuni dei diversi tipi di parole e di simboli. Spieghiamo i commenti, i comandi e i tre tipi di valori letterali: i numeri, le stringhe e i valori booleani (vero/falso).

### Commenti

Un programma è composto di istruzioni eseguite durante l'esecuzione del programma, e di commenti. I commenti non vengono eseguiti, &kturtle; semplicemente li ignora durante l'esecuzione dei programmi. I commenti aiutano gli altri programmatori a comprendere meglio i tuoi programmi. In &turtlescript;, tutti ciò che segue il carattere `#` viene considerato un commento. Per esempio, questo piccolo programma non fa nulla:

    # questo piccolo programma non fa nulla, è solo un commento!

È un po' inutile, ma spiega bene il concetto.

I commenti sono utili quando un programma diventa sempre più complesso. Può essere utile dare qualche indicazione ad altri programmatori. Nel programma seguente, puoi vedere commenti usati con il comando stampa.

    # questo programma è stato creato da Cies Breijs.
    scrivi "questo testo sarà scritto sull'area di disegno"
    # la riga precedente non è un commento, ma la riga seguente sì:
    # scrivi "questo testo non sarà scritto!"

La prima riga descrive il programma. La seconda riga è eseguita da &kturtle;, e scrive `questo testo sarà scritto sull'area di disegno` sull'area di disegno. La terza riga è un commento. Infine, la quarta è un commento che contiene un'istruzione &turtlescript;; se dalla quarta riga venisse rimosso il carattere `#`, l'istruzione «scrivi» verrebbe eseguita da &kturtle;. I programmatori dicono: l'istruzione «scrivi» nella quarta riga è stata "commentata".

Le linee commentate sono evidenziate con il grigio chiaro nell'editor.

### Comandi

Con i comandi puoi dire alla tartaruga o a &kturtle; di fare qualcosa. Alcuni comandi richiedono degli argomenti, alcuni restituiscono dei risultati.

    # «avanti» è un comando che richiede un argomento, in questo caso il numero 100:
    avanti 100

La prima riga è un commento. La seconda contiene il comando `avanti` e il numero `100`. Il numero non è parte di un comando, ma è considerato un "argomento" del comando.

Alcuni comandi, ⪚ `vai`, richiedono più di un argomento. Valori multipli devono essere separati usando il carattere `,` (virgola).

Per una panoramica dettagliata di tutti i comandi che &kturtle; supporta, vai qui. I comandi predefiniti sono evidenziati con il blu scuro.

### Numeri

Molto probabilmente conosci già i numeri. Il modo in cui questi sono usati in &kturtle; non è molto diverso dalla lingua parlata o dalla matematica.

Abbiamo i cosiddetti numeri naturali: `0`, `1`, `2`, `3`, `4`, `5`, &etc;. I numeri negativi: `-1`, `-2`, `-3`, &etc;. E i numeri decimali, o numeri con la virgola, per esempio: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`. Come separatore dei decimali viene usato il carattere `.` (punto).

I numeri possono essere usati negli operatori matematici e negli operatori di confronto. Possono anche essere memorizzati nelle variabili. Sono evidenziati con il rosso scuro.

### Stringhe

Prima un esempio:

    scrivi "Ciao, sono una stringa."

In questo esempio `scrivi` è un comando, e `"Ciao, sono una stringa."` è una stringa. Le stringhe iniziano e finiscono con il carattere `"`: grazie a questi caratteri &kturtle; sa che è una stringa.

Le stringhe possono essere memorizzate in variabili, allo stesso modo dei numeri. A differenza dei numeri, però, le stringhe non possono essere usate con gli operatori matematici o con gli operatori di confronto. Le stringhe sono evidenziate in rosso.

### Valori booleani (vero/falso)

Ci sono solo due valori booleani: `vero`
e `falso`
, chiamati anche `on` e `off`, `sì` e `no`, `uno` e `zero`. Tuttavia, in &turtlescript; sono sempre chiamati `vero` e `falso`. Guarda questo frammento di codice &turtlescript;:

    $a = vero

Se guardi l'ispettore, puoi vedere che la variabile `$a` è impostata a `vero`, e che il suo tipo è booleano.

Spesso i valori booleani sono il risultato di un operatore di confronto, come nel seguente frammento di &turtlescript;:

    $risposta = 10 > 3

La variabile `$risposta` è impostata a `vero`, dato che `10` è maggiore di `3`.

I valori booleani, `vero` e `falso`, sono evidenziati con il rosso scuro.

## Operatori matematici, booleani e di confronto

Il titolo di questa sezione può far pensare a qualcosa di estremamente complesso; tuttavia non è complicato come si potrebbe pensare.

### Operatori matematici

I simboli matematici di base sono: addizione (`+`), sottrazione (`-`), moltiplicazione (`*`), divisione (`/`) e potenza (`^`).

Ecco un piccolo esempio con gli operatori matematici che puoi usare in &turtlescript;:

    $addizione       = 1 + 1
    $sottrazione     = 20 - 5
    $moltiplicazione = 15 * 2
    $divisione       = 30 / 30
    $potenza         = 2 ^ 2

I valori risultanti dalle operazioni matematiche sono assegnati alle varie variabili. Usando l'ispettore puoi vederne i valori.

Se vuoi eseguire un semplice calcolo, puoi scrivere qualcosa di simile a questo:

    scrivi 2010-12

Ora un esempio con le parentesi:

    scrivi ( ( 20 - 5 ) * 2 / 30 ) + 1

Ciò che si trova dentro le parentesi sarà calcolato prima. In questo esempio, sarà calcolato prima 20-5, quindi il risultato viene moltiplicato per 2, diviso per 30, e infine viene aggiunto 1 (ottenendo 2 come risultato). Le parentesi possono essere usate anche in altri casi.

&kturtle; ha anche comandi matematici avanzati. Guarda i seguenti comandi, ricordando che sono operazioni avanzate: round, numerocasuale, sqrt, pi, sen, cos, tan, arcsen, arccos, arctan.

### Operatori booleani (vero/falso)

Se gli operatori matematici servono principalmente per i numeri, quelli booleani servono per i valori booleani (`vero` e `falso`). Ci sono solo tre operatori: `e`
, `o`
, e `non`
. Il seguente codice &turtlescript; mostra come usarli:

    $e_1_1 = vero e vero    # -> vero
    $e_1_0 = vero e falso   # -> falso
    $e_0_1 = falso e vero   # -> falso
    $e_0_0 = falso e falso  # -> falso

    $o_1_1 = vero o vero    # -> vero
    $o_1_0 = vero o falso   # -> vero
    $o_0_1 = falso o vero   # -> vero
    $o_0_0 = falso o falso  # -> falso

    $non_1 = non vero   # -> falso
    $non_0 = non falso  # -> vero

Puoi vederne i valori usando l'ispettore, anche se i risultati sono forniti come commenti alla fine di ogni riga. `e` dà come risultato `vero` solo se entrambi i lati sono `vero`. `o` dà come risultato `vero` se almeno uno dei due lati è `vero`. Infine, `non` trasforma `vero` in `falso` e `falso` in `vero`.

Gli operatori booleani sono evidenziati in rosa.

#### Alcuni esempi più complessi

Consideriamo il seguente esempio con `e`:

    $a = 1
    $b = 5
    se (($a < 10) e ($b == 5)) e ($a < $b) {
      scrivi "ciao"
    }

In questo frammento di codice &turtlescript;, i risultati di tre operatori di confronto sono "uniti" usando gli operatori `e`. Ciò significa che per far stampare ciao, tutti e tre devono dare come risultato vero.

Un esempio con `o`:

    $n = 1
    se ($n < 10) o ($n == 2) {
      scrivi "ciao"
    }

In questo frammento di codice &turtlescript;, il lato sinistro di `o` dà come risultato vero , quello destro falso. Dato che almeno uno dei due lati dell'operatore `o` è vero, l'operatore `o` dà come risultato vero. Ciò significa che viene stampato ciao.

Infine, un esempio con `non`, che cambia il vero in falso, e il falso in vero Diamo un'occhiata:

    $n = 1
    se non ($n == 3) {
      scrivi "ciao"
    } altrimenti {
      scrivi "non ciao ;-)"
    }

### Operatori di confronto

Consideriamo questo semplice confronto:

    $risposta = 10 > 3

Qui `10` è confrontato con `3` usando l'operatore maggiore di. Il risultato di questo confronto, il valore booleano `vero`, è memorizzato nella variabile `$risposta`.

Tutti i numeri e le variabili (che contengono numeri) possono essere confrontate tra di loro usando gli operatori di confronto.

Tutti gli operatori di confronto possibili sono:

### Tipi di domande

`$A == $B` | uguale | la risposta è vero se `A` è uguale a `$B`
`$A != $B` | diverso | la risposta è vero se `$A` è diverso da `$B`
`$A > $B` | maggiore di | la risposta è vero se `$A` è maggiore di `$B`
`$A < $B` | minore di | la risposta è vero se `$A` è minore di `B$`
`$A >= $B` | maggiore o uguale a | la risposta è vero se `$A` è maggiore o uguale a `$B`
`$A <= $B` | minore o uguale | la risposta è vero se `$A` è minore o uguale a `$B`

Nota che `$A` e `$B` devono essere numeri o variabili che contengono numeri.

## Comandi

Usando i comandi tu dici alla tartaruga o a &kturtle; di fare qualcosa. Alcuni comandi richiedono argomenti, alcuni restituiscono risultati. In questa sezione spieghiamo tutti i comandi incorporati in &kturtle;. In alternativa, puoi creare comandi personalizzati usando `impara`. I comandi incorporati di cui parliamo qui sono evidenziati in blu scuro.

### Muovere la tartaruga

Ci sono vari comandi per muovere la tartaruga nello schermo.

avanti (av)

-     avanti X

  `avanti` muove la tartaruga avanti di X pixel. Quando la penna è giù, la tartaruga lascerà un tratto. `avanti` può essere abbreviato in `av`.

indietro (in)

-     indietro X

  `indietro` muove la tartaruga indietro di X pixel. Quando la penna è giù, la tartaruga lascerà un tratto. `indietro` può essere abbreviato in `in`.

sinistra (sx)

-     sinistra X

  `sinistra` comanda alla tartaruga di girare X gradi a sinistra. `sinistra` può essere abbreviato in `sx`.

destra (dx)

-     destra X

  `destra` comanda alla tartaruga di girare X gradi a destra. `destra` può essere abbreviato in `dx`.

direzione (dir)

-     direzione X

  `direzione` imposta la direzione della tartaruga a X gradi partendo da zero, quindi non relativamente alla direzione precedente della tartaruga. `direzione` può essere abbreviato in `dir`.

valoredirezione

-     valoredirezione

  `valoredirezione` restituisce la direzione della tartaruga come un numero in gradi a partire da zero, dove lo zero è la direzione che la tartaruga ha quando è rivolta verso l'alto.

centra

-     centra

  `centra` muove la tartaruga al centro dell'area di disegno.

vai

-     vai X,Y

  `vai` comanda alla tartaruga di andare in un certo punto dell'area di disegno. Questo punto dista X pixel da sinistra, e Y pixel dall'alto dell'area di disegno.

vaix

-     vaix X

  `vaix` usando questo comando la tartaruga si muoverà a X pixel dalla sinistra dell'area di disegno mantenendo la sua altezza. `vaix` può essere abbreviato in `vx`.

vaiy

-     vaiy Y

  `vaiy` usando questo comando la tartaruga si muoverà a Y pixel dall'alto dell'area di disegno mantenendosi alla stessa distanza dal bordo sinistro dell'area di disegno. `vaiy` può essere abbreviato in `vy`.

Usando i comandi `vai`, `vaix`, `vaiy` e `centra` la tartaruga non disegnerà una linea, non importa che la penna sia su o giù.

### Dove è la tartaruga?

Ci sono due comandi che restituiscono la posizione della tartaruga nello schermo.

coordinatax

- `coordinatax` restituisce il numero di pixel dalla sinistra dell'area di disegno fino alla posizione corrente della tartaruga.

coordinatay

- `coordinatay` restituisce il numero di pixel dall'alto dell'area di disegno fino alla posizione corrente della tartaruga.

### La tartaruga ha una penna

La tartaruga ha una penna, che disegna una linea quando la tartaruga si muove. Ci sono alcuni comandi che controllano la penna. In questa sezione vengono spiegati.

pennasu (ps)

-     pennasu

  `pennasu` alza la penna dall'area di disegno. Quando la penna è su, non sarà disegnata alcuna linea mentre la tartaruga si muove. Vedi anche `pennagiu`. `pennasu` può essere abbreviato in `ps`.

pennagiu (pg)

-     pennagiu

  `pennagiu` abbassa la penna sull'area di disegno. Quando la penna è giù, verrà disegnata una linea sull'area di disegno mentre la tartaruga si muove. Vedi anche `pennasu`. `pennagiu` può essere abbreviato in `pg`.

spessorepenna (sp)

-     spessorepenna X

  `spessorepenna` imposta lo spessore della penna (lo spessore della linea) a X pixel. `spessorepenna` può essere abbreviato in `sp`.

colorepenna (cp)

-     colorepenna R,G,B

  `colorepenna` imposta il colore della penna. `colorepenna` richiede una combinazione RGB come argomento. `colorepenna` può essere abbreviato in `cp`.

### Comandi per controllare l'area di disegno

Ci sono vari comandi per controllare l'area di disegno.

dimensionesfondo (ds)

-     dimensionesfondo X,Y

  Con il comando `dimensionesfondo` puoi impostare la dimensione dell'area di disegno. Prende X e Y come argomenti, dove X è la nuova larghezza in pixel dell'area di disegno, mentre Y è la nuova altezza in pixel. `dimensionesfondo` può essere abbreviato in `ds`.

coloresfondo (cs)

-     coloresfondo R,G,B

  `coloresfondo` imposta il colore dell'area di disegno. `coloresfondo` richiede una combinazione RGB come argomento. `coloresfondo` può essere abbreviato in `cs`.

### Comandi per fare pulizia

Ci sono due comandi per pulire l'area di disegno dopo che hai fatto confusione.

pulisci (cls)

-     pulisci

  Con `pulisci` puoi pulire tutti i disegni dall'area di disegno. Tutte le altre cose rimangono: la posizione e l'angolo della tartaruga, il colore dell'area di disegno, la visibilità della tartaruga e la dimensione dell'area di disegno.

ricomincia

-     ricomincia

  `ricomincia` pulisce molto più accuratamente del comando `pulisci`. Dopo un comando `ricomincia`, tutto ritorna come era quando hai avviato &kturtle;. La tartaruga è posizionata al centro dello schermo, il colore dell'area di disegno è bianco, la tartaruga disegna linee nere sull'area di disegno e la dimensione dell'area di disegno è 400 x 400 pixel.

### La tartaruga è un folletto

Prima una breve spiegazione di cosa sono i folletti: i folletti sono dei piccoli disegni che possono essere mossi in giro per lo schermo, cosa che spesso vediamo nei giochi per il computer. Anche la nostra tartaruga è un folletto. Per maggiori informazioni, vedi la voce di glossario sui folletti.

Di seguito troverai una descrizione completa di tutti i comandi che lavorano con i folletti.

L'attuale versione di &kturtle; non supporta ancora l'uso di folletti diversi dalla tartaruga. Con le future versioni potrai cambiare la tartaruga in qualcos'altro creato da te.

mostra (ms)

-     mostra

  `mostra` rende nuovamente visibile la tartaruga dopo che è stata nascosta. `mostra` può essere abbreviato in `ms`.

nascondi (ns)

-     nascondi

  `nascondi` nasconde la tartaruga. Ciò può essere usato se non conviene che la tartaruga appaia nel tuo disegno. `nascondi` può essere abbreviato in `ns`.

### La tartaruga può scrivere del testo?

La risposta è: sì. La tartaruga può scrivere: scrive tutto quello che tu le comandi di scrivere.

scrivi

-     scrivi X

  Il comando `scrivi` viene usato per comandare alla tartaruga di scrivere qualcosa nell'area di disegno. `scrivi` accetta come argomenti numeri e stringhe. Puoi scrivere vari numeri e stringhe usando il simbolo +. Guarda qui un piccolo esempio:

      $anno = 2003
      $autore = "Cies"
      scrivi $autore + " ha iniziato il progetto KTurtle nel " + $anno + " e ancora si diverte a lavorarci!"

dimensionecarattere

-     dimensionecarattere X

  `dimensionecarattere` imposta la dimensione del carattere usato dal comando `scrivi`. `dimensionecarattere` richiede un argomento, che dovrebbe essere un numero. La dimensione è impostata in pixel.

### Comandi matematici

I comandi seguenti sono dei comandi matematici avanzati di &kturtle;.

round

-     round(x)

  `round` arrotonda il numero dato all'intero più vicino.

      scrivi round(10.8)
      avanti 20
      scrivi round(10.3)

  Con questo codice la tartaruga scriverà i numeri 11 e 10.

numerocasuale (casuale)

-     numerocasuale X,Y

  `numerocasuale` è un comando che richiede degli argomenti e restituisce un valore. Come argomenti richiede due numeri, il primo (X) imposta il valore minimo restituito, il secondo (Y) imposta il massimo. Il valore restituito è un numero scelto casualmente, maggiore o uguale del minimo, e minore o uguale del massimo. Qui vi è un piccolo esempio:

      ripeti 500 {
        $x = numerocasuale 1,20
        avanti $x
        sinistra 10 - $x
      }

  Usando il comando `numerocasuale` puoi aggiungere un po' di caos al tuo programma.

mod

-     mod X,Y

  Il comando `mod` restituisce il resto della divisione del primo numero con il secondo..

sqrt

-     sqrt X

  Il comando `sqrt` è usato per calcolare la radice quadrata di un numero, X.

pi

-     pi

  Questo comando restituisce la costante Pi, `3.14159`.

sen
, cos
, tan

-     sen X
      cos X
      tan X

  Questi tre comandi rappresentano le famose funzioni trigonometriche `sen`, `cos` e `tan`. L'argomento di questi comandi, X, è un numero.

arcsen
, arccos
, arctan

-     arcsen X
      arccos X
      arctan X

  Questi comandi rappresentano le funzioni inverse di sen, cos e tan. L'argomento di questi comandi, X, è un numero.

### Inserire i dati e visualizzare i messaggi nelle finestre

Una finestra è una piccola finestra a comparsa che mostra un messaggio oppure chiede di inserire qualcosa. &kturtle; ha due comandi per le finestre , chiamati: `messaggio` e `chiedi`

messaggio

-     messaggio X

  Il comando `messaggio` richiede come argomento una stringa. Mostra una finestra a comparsa che contiene il testo della stringa.

      messaggio "Cies ha iniziato KTurtle nel 2003 e ancora si diverte a lavorarci!"

chiedi

-     chiedi X

  `chiedi` richiede come argomento una stringa. Mostra questa stringa in una finestra a comparsa (in modo simile a messaggio) che contiene anche un campo di inserimento testo. Dopo che l'utente ha inserito un numero o una stringa, il risultato può essere memorizzato in una variabile, oppure passato come argomento ad un comando. Per esempio:

      $in = chiedi "Qual è la tua età?"
      $out = 2003 - $in
      scrivi "Ad un certo punto del 2003 avevi " + $out + " anni."

  Se l'utente annulla la finestra , o non inserisce niente, la variabile sarà vuota.

## Assegnamento di variabili

Vediamo prima le variabili, poi come assegnare dei valori a queste variabili.

Le variabili sono delle parole che iniziano per $, e nell'editor sono evidenziate in viola.

Le variabili possono contenere qualsiasi numero, una stringa o unvalore booleano (vero/falso). Usando l'assegnazione, `=`, è possibile impostare il contenuto di una variabile. Lo manterrà fino alla fine dell'esecuzione del programma, oppure fino a quando le viene assegnato qualcos'altro.

Una volta assegnate, puoi usare le variabili come se fossero il loro contenuto. Per esempio, nel frammento seguente di codice &turtlescript;:

    $x = 10
    $x = $x / 3
    scrivi $x

Prima, alla variabile `$x` viene assegnato `10`. Quindi, ad `$x` viene riassegnato il proprio valore diviso per `3` — ciò effettivamente significa che ad `$x` viene assegnato il risultato di `10 / 3`. Infine, `$x` viene stampata. Nelle righe due e tre puoi vedere che`$x` è usata come se fosse quello che in realtà contiene.

Per poter usare le variabili, deve avergli assegnato qualcosa. Ad esempio:

    scrivi $n

Avrà come risultato un messaggio d'errore.

Osserviamo il seguente frammento di codice &turtlescript;:

    $a = 2004
    $b = 25

    # il comando seguente scrive "2029"
    scrivi $a + $b
    indietro 30
    # il comando seguente scrive "2004 più 25 = 2029"
    scrivi $a + " più " + $b " = " + ($a + $b)

Nelle prime due righe le variabili `$a` e `$b` sono impostare a 2004 e 25. Quindi ci sono due comandi `scrivi` con `indietro 30` in mezzo. I commenti prima dei comandi `scrivi` spiegano cosa viene fatto. Il comando `indietro 30` è usato per scrivere ogni testo in una nuova riga. Come puoi vedere, le variabili possono essere usate come se fossero quello che contengono, e puoi usarle con qualsiasi tipo di operatore oppure come argomento quando usi qualche comando.

Ancora un esempio:

    $nome = chiedi "Qual è il tuo nome?"
    scrivi "Ciao " + $nome + "! Buona fortuna per l'apprendimento dell'arte della programmazione..."

Abbastanza semplice. Puoi nuovamente vedere come la variabile `$nome` è considerata come fosse una stringa di testo.

Quando usi variabili, l'ispettore è molto utile. Mostra il contenuto di tutte le variabili attualmente usate.

## Controllare l'esecuzione

I comandi di controllo dell'esecuzione ti permettono — come dicono il loro nomi — di controllare l'esecuzione.

I comandi di controllo dell'esecuzione sono evidenziati in verde scuro, e con un carattere grassetto. Le parentesi sono usate principalmente con i comandi di controllo dell'esecuzione, e sono evidenziate di nero.

### Far aspettare la tartaruga

Se hai programmato in &kturtle;, potresti aver notato che la tartaruga può essere molto veloce a disegnare. Questo comando fa sì che la tartaruga attenda per un tempo specificato.

aspetta

-     aspetta X

  `aspetta` fa sì che la tartaruga attenda X secondi.

      ripeti 36 {
        avanti 5
        destra 10
        aspetta 0.5
      }

  Questo codice disegna un cerchio, ma la tartaruga attenderà mezzo secondo dopo ogni passo. Ciò dà l'impressione che la tartaruga si muova lentamente.

### Esegui se

se

-     se booleano { ... }

  Il codice che si trova tra le parentesi sarà eseguito solo `se` il valore booleano dà come risultato vero.

      $x = 6
      se $x > 5 {
        scrivi "x è più grande di cinque!"
      }

  Nella prima riga, `$x` è impostato a 6. Nella seconda viene usato un operatore di confronto per produrre il risultato di `$x > 5`. Dato che è vero (6 è più grande di 5), il comando di controllo dell'esecuzione `se` permetterà che il codice tra le parentesi venga eseguito.

### Se no, in altre parole: altrimenti

altrimenti

-     se booleano { ... } altrimenti { ... }

  `altrimenti` può essere usato in aggiunta al comando di controllo dell'esecuzione `se`. Il codice tra le parentesi dopo `altrimenti` viene eseguito solo se il valore booleano vale falso.

      ricomincia
      $x = 4
      se $x > 5 {
        scrivi "x è più grande di cinque!"
      } altrimenti {
        scrivi "x è più piccolo di cinque!"
      }

  L'operatore di confronto valuta l'espressione `$x > 5`. Dato che 4 non è maggiore di 5, l'espressione vale falso. Ciò significa che il codice tra le parentesi dopo `altrimenti` viene eseguito.

### Il ciclo mentre

mentre

-     mentre booleano { ... }

  Il comando di controllo dell'esecuzione `mentre` è molto simile a `se`. La differenza è che `mentre` continua a ripetere (in modo ciclico) il codice tra le parentesi fino a quando il valore booleano è falso.

      $x = 1
      mentre $x < 5 {
        avanti 10
        aspetta 1
        $x = $x + 1
      }

  Nella prima riga, `x` è impostato a 1. Nella seconda viene valutato `x < 5`. Dato che la risposta a questa domanda è vero, il comando di controllo dell'esecuzione `mentre` inizia ad eseguire il codice tra le parentesi fino a quando `$x < 5` dà come risultato falso. In questo caso il codice tra le parentesi verrà eseguito 4 volte, dato che ogni volta che viene eseguita la quinta riga `$x` viene incrementato di 1.

### Il ciclo ripeti

ripeti

-     ripeti numero { ... }

  Il comando di controllo dell'esecuzione `ripeti` è molto simile a `mentre`. La differenza è che `ripeti` continua a ripetere (iterare) il codice tra le parentesi per il numero di volte specificato.

### Il ciclo per, un ciclo contato

per

-     per variabile = numero finoa numero { ... }

  Il ciclo `per` è un ciclo contato, &ie; conta per te. Il primo numero imposta nel primo ciclo la variabile al valore. Ad ogni ciclo il numero è incrementato fino a quando diventa uguale al secondo numero.

      per $x = 1 finoa 10 {
        scrivi $x * 7
        avanti 15
      }

  Ogni volta che viene eseguito il codice tra le parentesi, `$x` viene incrementato di 1, fino a quando `$x` raggiunge il valore di 10. Il codice tra le parentesi scrive il valore di `$x` moltiplicato per 7. Alla fine dell'esecuzione di questo programma vedrai scritta sull'area di disegno la tabellina del 7.

  Il passo predefinito di un ciclo è 1, puoi usare un altro valore con

      per variabile = numero finoa numero passo numero { ... }

### Lasciare un ciclo

interrompi

-     interrompi

  Interrompe immediatamente il ciclo corrente, e trasferisce il controllo all'istruzione che si trova subito a dopo quel ciclo.

### Interrompere l'esecuzione dei programmi

esci

-     esci

  Termina l'esecuzione del programma.

### Controllare le asserzioni durante l'esecuzione

asserisci

-     asserisci booleano

  Può essere usato per assicurarsi della validità del programma o dei dati inseriti.

      $in = chiedi "Qual è il tuo anno di nascita?"
      # l'anno deve essere un valore maggiore di zero
      asserisci $in
      > 0

## Crea i tuoi comandi con impara

`impara`
è un comando speciale, usato per creare comandi personalizzati. Il comando che crei può richiedere degli argomenti e restituire dei valori. Diamo un'occhiata a come creare un nuovo comando:

    impara cerchio $x {
      ripeti 36 {
        avanti $x
        sinistra 10
      }
    }

Il nuovo comando è chiamato `cerchio`. `cerchio` richiede un argomento per impostare la dimensione del cerchio. `cerchio` non restituisce dei valori. Il comando `cerchio` può essere ora usato nel resto del codice come un normale comando. Guarda questo esempio:

    impara cerchio $X {
      ripeti 36 {
        avanti $X
        sinistra 10
      }
    }

    vai 200,200
    cerchio 20

    vai 300,200
    cerchio 40

Nell'esempio seguente viene creato un comando con un valore restituito
.

    impara esempio $x {
      $r = 1
      per $i = 1 finoa $x {
        $r = $r * $i
      }
      restituisci $r
    }

    scrivi esempio 5

In questo esempio viene creato un nuovo comando chiamato `esempio`. Se l'argomento di questo comando è `5`, il risultato è `5*4*3*2*1`. Usando `restituisci` viene specificato il valore restituito è l'esecuzione del comando termina.

I comandi possono avere più di un argomento. Nell'esempio che segue, viene creato un comando che disegna un rettangolo.

    impara scatola $x, $y {
      avanti $y
      destra 90
      avanti $x
      destra 90
      avanti $y
      destra 90
      avanti $x
      destra 90
    }

Adesso puoi eseguire `scatola 50, 100`, e la tartaruga disegnerà un rettangolo nell'area di disegno.