# Guida alla programmazione &turtlelang;

Questa è la guida del &turtlelang; di &kturtle;. In questo capitolo accenniamo brevemente a tutti i diversi tipi di istruzioni. Quindi vengono spiegati uno ad uno i comandi. Poi vengono spiegati i contenitori, la matematica, le domande e le istruzioni di controllo dell'esecuzione. Infine ti viene mostrato come creare i tuoi comandi con impara.

## Differenti tipi di istruzioni

Come in qualsiasi altro linguaggio, il &turtlelang; ha differenti tipi di parole e di simboli. Qui vengono brevemente spiegate le differenze tra i tipi.

### Comandi

Usando i comandi tu dici alla tartaruga o a &kturtle; di fare qualcosa. Alcuni comandi richiedono argomenti, alcuni restituiscono risultati.

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

Per una panoramica dettagliata di tutti i comandi che &kturtle; supporta vai qui.

### Numeri

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

Abbiamo i cosiddetti numeri naturali: `0`, `1`, `2`, `3`, `4`, `5`, ecc. I numeri negativi: `-1`, `-2`, `-3`, ecc. E i numeri decimali, o numeri con la virgola, per esempio: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`.

I numeri possono essere usati in calcoli matematici e in domande. Possono anche essere inseriti in contenitori.

I numeri sono evidenziati con il rosso scuro nell'editor del codice.

### Stringhe

Prima un esempio:

    scrivi "Ciao, sono una stringa."

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

Le stringhe possono essere inserite in contenitori. Tuttavia non possono essere usate in calcoli matematici e domande.

Le stringhe sono evidenziate con il rosso nell'editor del codice.

### Nomi

Quando usi il linguaggio di programmazione &turtlelang; crei nuove cose. Se scrivi un programma spesso avrai bisogno di contenitori e, in alcuni casi, di impara per creare nuovi comandi. Quando crei un nuovo comando con impara dovrai specificare un nome.

Puoi scegliere qualsiasi nome, a meno che non abbia già un significato. Per esempio non puoi chiamare avanti un contenitore, dato che quel nome è già usato per un comando interno, e per questo ha un significato.

    # qui avanti è usato come nuovo comando,
    # ma ha già un significato
    # così questa riga genererà un errore:
    impara avanti {
      scrivi "questo non è valido"
    }

    # questo funziona:
    impara mio_avanti {
      scrivi "questo va bene"
    }

I nomi possono contenere solo lettere, numeri e trattini bassi (_). Devono tuttavia iniziare con una lettera. I nomi di contenitori devono iniziare con il prefisso dei contenitori ($).

    # qui avanti è usato come contenitore
    # e inizia con il prefisso $, quindi
    # non va in conflitto con il comando avanti
    $avanti = 20
    scrivi $avanti

I contenitori sono evidenziati con il viola grassetto nell'editor del codice.

Per una spiegazione più esauriente e per vedere più esempi leggi la documentazione sui contenitori e sul comando impara.

### Assegnamenti

Un assegnamento viene effettuato con il simbolo `=`. Nei linguaggi di programmazione è meglio leggere il singolo `=` non come "uguale" ma come "diventa". La parola "uguale" è più appropriata per `==` che è una domanda.

Gli assegnamenti sono usati generalmente per due motivi, (1) per aggiungere contenitori e (2) per modificare il contenuto di un contenitore. Per esempio:

    $x = 10
    # il contenitore x ora contiene il numero 10
    $W = "La mia età è: "
    # il contenitore W ora contiene la stringa "La mia età è: "
    # questa riga scrive il contenuto dei contenitori 'W' e 'x' sull'area di disegno
    scrivi $W + $x

Per vedere più esempi leggi la sezioni che spiega i contenitori.

### Simboli matematici

&kturtle; supporta tutti i simboli matematici di base: addizione (`+`), sottrazione (`-`), moltiplicazione (`*`), divisione (`/`) e le parentesi `(` e `)`.

Per una spiegazione più esauriente e per vedere più esempi leggi la sezione sulla matematica.

### Domande

Possiamo chiedere semplici domande la cui risposta sarà "vero" o "falso".

L'uso delle domande è ampiamente spiegato nella sezione sulle domande.

### I "collanti" delle domande

Le domande posso essere unite assieme con i cosiddetti "collanti delle domande". Le parole "collanti" sono `e` `o`, e un "collante" speciale: `non`.

L'uso dei "collanti" delle domande è spiegato nella sezione I "collanti" delle domande.

### Commenti

I commenti sono linee che iniziano con `#`. Per esempio:

    # questo è un commento!
    scrivi "questo non è un commento"
    # la linea precedente non è un commento, ma la linea successiva sì:
    # scrivi "questo non è un commento"

Noi possiamo aggiungere commenti al codice, affinché lo leggiamo noi stessi o lo leggano altri. I commenti sono usati per: (1) aggiungere una piccola descrizione al programma, (2) spiegare come funziona un pezzo di codice nel caso sia un po' complesso, e (3) per "commentare via" linee di codice che dovrebbero essere (temporaneamente) ignorate (guarda l'ultima linea dell'esempio).

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

## 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 che possono essere usati in &kturtle;. Nota che tutti i comandi predefiniti di cui discutiamo qui sono evidenziati con il blu nell'editor del codice, ciò può aiutarti a distinguerli.

### Muovere la tartaruga

Ci sono vari comandi per muovere la tartaruga sullo 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, e così non è relativo alla precedente direzione della tartaruga. `direzione` può essere abbreviato in `dir`.

centro

      centro

  `centro` 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.

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.

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

### Dove è la tartaruga?

Ci sono due comandi che restituiscono la posizione della tartaruga sullo 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 questi comandi.

pennasu (ps)

      pennasu

  `pennasu` alza la penna dall'area di disegno. Quando la penna è su non sarà disegnata alcuna linea quando 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ù sull'area di disegno sarà disegnata una linea quando 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 piccoli disegni che possono essere mossi in giro per lo schermo, come 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`.

### Può la tartaruga 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` è usato per comandare alla tartaruga di scrivere qualcosa sull'area di disegno. `scrivi` accetta numeri e stringhe come parametri. 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 tipo di carattere usato dal comando `scrivi`. `dimensionecarattere` richiede un argomento che dovrebbe essere un numero. La dimensione è impostata in pixel.

### Un comando che lancia dadi per te

C'è comando che lancia un dado per te, ed è chiamato `casuale`, ed è molto utile per avere "risultati inattesi".

numerocasuale (casuale)

      numerocasuale X,Y

  `numerocasuale` è un comando che richiede parametri e restituisce un valore. Come parametri 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.

### Inserire dati e visualizzare messaggi con finestre di dialogo

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

messaggio

      messaggio X

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

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

chiedi

      chiedi X

  `chiedi` richiede una stringa come argomento. Mostra una finestra a comparsa che contiene il testo della stringa, allo stesso modo di messaggio. Ma in più vi è un campo di inserimento nella finestra di dialogo. Attraverso questo campo di inserimento l'utente può inserire un numero o una stringa che può essere memorizzata in un contenitore. Per esempio

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

  Quando un utente annulla la finestra di dialogo, o non inserisce niente, il contenitore è svuotato.

## Contenitori

I contenitori sono lettere o parole che possono essere usate dal programmatore per memorizzare un numero o del testo. I contenitori che contengono un numero sono chiamati variabili, quelli che possono contenere del testo sono chiamati stringhe. I contenitori possono essere identificati dal carattere $ che ne precede l'uso.

I contenitori che non sono usati non contengono nulla. Un esempio:

    scrivi $N

Questo non scriverà niente e otterrai un messaggio d'errore.

### Variabili: contenitori numerici

Iniziamo con un esempio:

    $x = 3
    scrivi $x

Nella prima linea la lettera `x` è trasformata in una variabile (contenitore numerico). Come vedi il valore della variabile `x` è impostato a 3. Nella seconda linea viene stampato a video il valore.

Nota che se volevamo scrivere una x avremmo dovuto scrivere

    scrivi "x"

Quello era semplice, vediamo ora un esempio un po' più complesso:

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

    # il comando seguente scrive "2029"
    scrivi $C
    indietro 30
    # il comando seguente scrive "2004 più 25"
    scrivi $A + " più " + $B
    indietro 30
    # il comando seguente scrive "1979"
    scrivi $A - $B

nelle prime due righe le variabili `A` e `B` sono impostare a 2004 e 25. Nella terza riga la variabile `C` è impostata ad `A + B`, che è 2029. Il resto dell'esempio è costituito da 3 comandi `scrivi` con `indietro 30` in mezzo. Il comando `indietro 30` ci assicura che ogni testo è scritto in una nuova riga. In questo esempio puoi anche vedere che le variabili possono essere usate nei calcoli matematici.

### Contenitori che contengono testo (stringhe)

Nel codice della programmazione il testo regolare di solito inizia e finisce con le virgolette doppie. Come abbiamo già visto:

    scrivi "Ciao programmatore!"

Il testo regolare è delimitato dalle virgolette doppie. Chiamiamo questi pezzi di testo regolare stringhe.

Le stringhe possono essere memorizzate in contenitori allo stesso modo dei numeri. Le stringhe sono molto simili alle variabili. La più grande differenza è che le stringhe contengono testo invece che numeri. Per questo motivo le stringhe non possono essere usate in calcoli matematici e domande. Un esempio di uso di stringhe:

    $x = "Ciao "
    $nome = chiedi "Inserisci il tuo nome..."
    scrivi $x + $nome + ", come va?"

Nella prima riga la stringa `x` è impostata a Ciao . Nella seconda riga la stringa `nome` è impostata al risultato del comando `chiedi`. Nella terza riga il programma scrive nell'area di disegno una stringa composta da tre stringhe.

Questo programma ti chiede di inserire il tuo nome. Quando inserisci, per esempio, il nome Paolo, il programma scrive Ciao Paolo, come va?. Nota che il segno più (+) è l'unico segno matematico che puoi usare con le stringhe.

## Può la tartaruga eseguire calcoli?

Sì, &kturtle; farà la matematica per te. Puoi aggiungere (+), sottrarre (-), moltiplicare (*) e dividere (/). Ecco qui un esempio nel quale usiamo tutte le operazioni:

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

Lo sai che valori hanno a, b, c e d? Nota l'uso del simbolo di assegnamento `=`.

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

    scrivi 2004-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 20-5, quindi moltiplicato per 2, diviso per 30, e viene infine aggiunto 1 (avendo 2 come risultato).

&kturtle; ha funzionalità matematiche avanzate. Conosce il numero `pi` e funzione trigonometriche come `sen`, `cos`, `tan`, `arcsen`, `arccos`, `arctan` e le funzioni `sqrt` e `exp`.

### Permette alla tartaruga di arrotondare i numeri

Se hai bisogno di valori interi per i calcoli, usa questa funzione.

round

      round(x)

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

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

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

## Chiedere domande, avere risposte...

`se` e `mentre` sono comandi di controllo dell'esecuzione di cui parleremo nella prossima sezione. In questa sezione usiamo il comando `se` per spiegare le domande.

### Domande

Un semplice esempio di domanda:

    $x = 6
    se $x > 5 {
      scrivi "ciao"
    }

In questo esempio la domanda è costituita da `x > 5`. Se la risposta a questa domanda è "vero", sarà eseguito il codice tra le parentesi. Le domande sono una parte molto importante della programmazione e sono spesso usate insieme ai comandi di controllo dell'esecuzione, come `se`. Tutti i numeri e le variabili (contenitori numerici) possono essere confrontati l'un l'altro con le domande.

Qui vi sono tutte le possibili domande:

#### Tipi di domande

`a == b` | uguale | la risposta è vero se `a` è uguale a `b`
`a != b` | non uguale | la risposta è vero se `a` non è uguale a `b`
`a > b` | maggiore | la risposta è vero se `a` è maggiore di `b`
`a < b` | minore | la risposta è vero se `a` è minore di `b`
`a >= b` | maggiore o uguale | 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`

### I "collanti" delle domande

I "collanti" delle domande ci permettono di unire più domande in una domanda più grande.

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

In questo esempio è usato il "collante" `e` per unire insieme due domande (`a < 5`, `b == 5`). Se un lato di `e` avrà come risposta falso, l'intera domanda avrà come risposta falso, poiché con il "collante" `e` entrambi i lati devono essere vero per poter rispondere vero. Non ti dimenticare di usare le parentesi attorno ad ogni domanda!

Qui vi è una descrizione schematica; sotto segue una spiegazione più dettagliata:

#### I "collanti" delle domande

`e` | Entrambi i lati devono essere "vero" per poter rispondere "vero"
`o` | Se uno dei lati è "vero" la risposta è "vero"
`non` | Caso speciale: funziona solo con una domanda! Cambia "vero" in "falso" e "falso" in "vero".

#### e

Quando due domande sono incollate l'un l'altra con `e`, entrambi i lati di `e` devono essere "vero" per poter dare come risultato "vero". Un esempio:

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

In questo esempio puoi vedere una domanda incollata, unita ad un'altra domanda.

#### o

Se una delle due domande unite assieme con `o` è "vera", il risultato sarà "vero". Un esempio:

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

In questo esempio puoi vedere una domanda incollata, unita ad un'altra domanda.

#### non

`non` è uno speciale "collante" delle domande poiché funziona solo con una domanda alla volta. `non` cambia "vero" in "falso" e "falso" in "vero". Un esempio:

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

In questo esempio la domanda "incollata" è "vera", tuttavia `non` la cambia in "falsa". Così alla fine viene scritto `"non ciao ;-)"` sull'area di disegno.

## 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 di verde scuro con un tipo di carattere grassetto. Le parentesi sono usate principalmente con i comandi di controllo dell'esecuzione e sono evidenziate di verde chiaro.

### Far aspettare la tartaruga

Se hai programmato in &kturtle; devi 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ò da' l'impressione di una tartaruga che si muove lentamente.

### Eseguire "se"

se

      se domanda { ... }

  Il codice che si trova tra le parentesi sarà eseguito solo `se` la risposta alla domanda è vero. Per maggiori informazioni leggi sulle domande nella sezione sulle domande.

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

  Nella prima linea `x` è impostato a 6. Nella seconda linea è chiesta la domanda `x > 5`. Dato che la risposta a questa domanda è vero il comando di controllo dell'esecuzione `se` permetterà che venga eseguito il codice tra le parentesi

### Se no, in altre parole: "altrimenti"

altrimenti

      se domanda { ... } altrimenti { ... }

  `altrimenti` può essere usato in aggiunta al comando di controllo dell'esecuzione `se`. Il codice tra le parentesi dopo `altrimenti` è eseguito solo se la risposta alla domanda chiesta è falso.

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

  La domanda chiede se `x` è più grande di 5. Dato che `x` è stato impostato a 4 nella prima linea, la risposta alla domanda è falso. Ciò significa che viene eseguito il codice tra le parentesi dopo `altrimenti`.

### Il ciclo "mentre"

mentre

      mentre domanda { ... }

  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 la risposta alla domanda è falso.

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

  Nella prima linea `x` è impostato a 1. Nella seconda linea viene chiesta la domanda `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 la risposta alla domanda è falso. In questo caso il codice tra le parentesi sarà eseguito 4 volte, dato che ogni volta che viene eseguita la quinta linea `x` è 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 il numero di volte specificato.

### Il ciclo "per", un ciclo contato

per

      per punto di partenza finoa punto di arrivo { ... }

  Il ciclo `per` è un ciclo contato, &ie; conta per te.

      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 punto di partenza finoa punto di arrivo passo valore del passo { ... }

### Lascia un ciclo

interrompi

      interrompi

  Interrompe il ciclo corrente immediatamente e trasferisce il controllo all'istruzione che segue subito dopo quel ciclo

### Fermare la tartaruga

esci

      esci

  Termina l'esecuzione del codice.

## Crea i tuoi comandi con impara

`impara` è un comando molto particolare, dato che è usato per creare comandi personalizzati. Il comando che crei può richiedere parametri e restituire 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 parametro, un numero, per impostare la dimensione del cerchio. `cerchio` non restituisce 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.

    ricomincia

    impara moltiplicatoPerSeStesso $n {
      $r = $n * $n
      restituisci r
    }
    $i = chiedi "Inserisci un numero e premi OK"
    scrivi $i + " moltiplicato per se stesso è: " + moltiplicatoPerSeStesso $i

In questo esempio viene creato un nuovo comando chiamato `moltiplicatoPerSeStesso`. Il parametro di questo comando è moltiplicato per se stesso e quindi restituito, usando il comando `restituisci`. Il comando `restituisci` è il modo per restituire un valore da una funzione che hai creato.

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.