# Referència de programació del &turtlescript;

Aquesta és la referència per a &turtlescript; de &kturtle;. En la primera secció d'aquest capítol es fa un repàs a alguns aspectes de la gramàtica dels programes de &turtlescript;. La segona secció es refereix exclusivament als operadors matemàtics, els operadors booleans (true/false -cert/fals-) i els operadors de comparació. La tercera secció bàsicament és una llista gegant explicant de totes les ordres instrucció a instrucció. La quarta secció explica com assignar valors a les variables. Per finalitzar s'explica la forma d'organitzar l'execució d'ordres amb les sentències de control de l'execució en la cinquena secció i com crear les vostres pròpies ordres amb aprendre en la sisena secció.

## La gramàtica de &turtlescript;

Igual que en qualsevol llenguatge, &turtlescript; té diferents tipus de paraules i símbols. En anglès es distingeixen els verbs (com «to walk» -caminar- o «to sing» -cantar-) i noms (com «sister» -germana- o «house» -casa-), que s'utilitzen per a diferents propòsits. &turtlescript; és un llenguatge de programació, que s'utilitza per indicar el que ha de fer &kturtle;.

En aquesta secció s'expliquen amb brevetat alguns dels diferents tipus de paraules i símbols de &turtlescript;. Expliquem els comentaris, les ordres i els tres diferents tipus de literals: nombres, cadenes i valors booleans («true/false» -cert/fals-).

### Comentaris

Un programa consisteix en les instruccions que s'executen quan s'executa el programa i els anomenats comentaris. Els comentaris no s'executen, &kturtle; simplement els ignora en executar el vostre programa. Els comentaris hi són perquè altres programadors entenguin millor el vostre programa. Tot el que segueix a un símbol `#` és considerat un comentari de &turtlescript;. Per exemple, aquest petit programa que no fa res:

    # aquest petit programa no fa res. Només és un comentari!

És un xic inútil, però plasma molt bé l'assumpte.

Els comentaris són molt útils quan el programa es fa més complex. Poden ajudar a donar un consell als altres programadors. En el següent programa veureu que els comentaris s'utilitzen juntament amb l'ordre print.

    # Aquest programa ha estat realitzat per Cies Breijs.
    print "Aquest text serà imprès en el llenç"
    # La línia anterior no és un comentari, però sí la línia següent:
    # print "Aquest text no s'imprimirà!"

La primera línia descriu el programa. La segona línia és executada per &kturtle; i imprimeix `Aquest text serà imprès en el llenç`. La tercera línia és un comentari. I la quarta línia és un comentari que conté un tros de &turtlescript;, si s'elimina el símbol `#` en la quarta línia, la declaració d'impressió serà executada per &kturtle;. Els programadors diuen: La sentència d'impressió en la quarta línia és un comentat (commented out).

Les línies comentades es ressalten en color gris clar en l'editor de codi.

### Ordres

L'ús d'ordres li diuen a la tortuga o &kturtle; que faci quelcom. Algunes ordres necessiten alguna entrada, alguna sortida.

    # «forward» és una ordre que necessita una entrada, en aquest cas el número 100:
    forward 100

La primera línia és un comentari. La segona línia conté l'ordre «`forward`» i el nombre 100. El nombre no forma part de l'ordre, es considera l'«entrada» d'aquesta.

Algunes ordres, com ara `go` (`vésa`) necessiten alguna cosa més que un valor d'entrada. Múltiples valors s'han de separar utilitzant el caràcter `,` (coma).

Per a una descripció detallada de totes les ordres que suporta &kturtle; aneu aquí. Les ordres encastades es ressalten en color blau fosc.

### Nombres

El més probable és que ja sabeu quelcom sobre els nombres. La manera com s'utilitzen en &kturtle; no és gaire diferent del llenguatge parlat, o les matemàtiques.

Tenim els anomenats nombres naturals: `0`, `1`, `2`, `3`, `4`, `5`, &etc; Els nombres negatius: `-1`, `-2`, `-3`,&etc; I els nombres amb decimals, per exemple: `0,1`, `3,14`, `33,3333`, `-5,05`, `-1,0`. El caràcter `.` (punt) s'utilitza com a separador de decimals.

Els nombres es poden utilitzar en operacions matemàtiques i operadors de comparació. També es poden desar en les variables. Els nombres són ressaltats en color vermell fosc.

### Cadenes

Primer un exemple:

    print "Hola, sóc una cadena."

En aquest exemple `print` és una ordre i on `"Hola, sóc una cadena."` és una cadena. Les cadenes comencen i acaben amb la marca `"`, per aquestes marques &kturtle; sabrà que és una cadena.

Les cadenes es poden posar en les variables, igual que els nombres. No obstant això, a diferència dels nombres, les cadenes no es poden utilitzar en els operadors matemàtics o els operadors de comparació. Les cadenes es ressalten en color vermell.

### Els valors booleans («true/false» -cert/fals-)

Només hi ha dos valors booleans: `true` i `false`
(`cert`) i `false`
(`fals`). De vegades també se'ls crida: «on» i «off», «yes» i «no», «1» i «0». Però en el &turtlescript; sempre se'ls crida, `true` i `false`. Doneu una ullada a aquest tros del &turtlescript;:

    $a = true

Si ens fixem en l'inspector podeu veure que la variable `$a` s'estableix a `true`, i té el tipus booleà.

Els valors booleans sovint són el resultat d'un operador de comparació, com en el següent fragment de &turtlescript;:

    $answer = 10 > 3

La variable `$answer` està establerta a `true`, perquè `10` és més gran que `3`.

Els valors booleans, `true` i `false`, es ressalten en color vermell fosc.

## Els operadors matemàtics, booleans i de comparació

El títol d'aquesta secció pot reservar una certa dificultat, però, no és tan difícil com sona.

### Els operadors matemàtics

Aquests són els símbols matemàtics bàsics coneguts com: add «suma» (`+`), subtract «resta» (`-`), multiply «multiplicació» (`*`), divide «divisió» (`/`) i power «potència» (`^`).

Aquí teniu un petit exemple dels operadors matemàtics que podeu utilitzar en &turtlescript;:

    $add      = 1 + 1
    $subtract = 20 - 5
    $multiply = 15 * 2
    $divide   = 30 / 30
    $power    = 2 ^ 2

Els valors resultants de les operacions matemàtiques són assignats a diverses variables. Utilitzant l'inspector podeu veure els valors.

Si el que voleu és fer un càlcul senzill podeu fer quelcom com això:

    print 2010-12

Ara veurem un exemple amb parèntesis:

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

Les expressions entre parèntesis es calculen primer. En aquest exemple, es calcula 20-5, després es multiplica per dos, dividit per 30, i després se suma 1 (el qual ens dóna 2). Els parèntesis també es poden utilitzar en altres casos.

&kturtle; també té funcions matemàtiques més avançades en forma d'ordres. Doneu una ullada a les següents ordres, però tingueu present que es tracten d'operacions avançades: round, random, sqrt, pi, sin, cos, tan, arcsin, arccos, arctan.

### Els operadors booleans («true/false» -cert/fals-)

On els operadors matemàtics són principalment per als nombres, els operadors booleans són per als valors booleans (`true` i `false`). Només hi ha tres operadors booleans, anomenats: `and`
, `or`
i `not`
. El següent fragment del &turtlescript; mostra com usar-los:

    $and_1_1 = true and true    # -> true
    $and_1_0 = true and false   # -> false
    $and_0_1 = false and true   # -> false
    $and_0_0 = false and false  # -> false

    $or_1_1 = true or true    # -> true
    $or_1_0 = true or false   # -> true
    $or_0_1 = false or true   # -> true
    $or_0_0 = false or false  # -> false

    $not_1 = not true   # -> false
    $not_0 = not false  # -> true

Utilitzant l'inspector podreu veure els valors, però també oferim aquests resultats com petits comentaris al final de les línies. `and` avalua `true` només si ambdues parts són `true`. `or` avalua `true` si una part i l'altra són `true`. I `not` torna un `true` en `false` i `false` en `true`.

Els operadors booleans es ressalten en color rosa.

#### Alguns exemples més avançats

Considerem el següent exemple amb `and`:

     $a = 1
    $b = 5
    if (($a < 10) and ($b == 5)) and ($a < $b) {
      print "hola"
    }

En aquest fragment de &turtlescript; el resultat de tres operadors de comparació es fusionen utilitzant els operadors `and`. Això significa que els tres han d'avaluar «true» perquè s'imprimeixi «hola».

Un exemple amb `or`:

    $n = 1
    if ($n < 10) or ($n == 2) {
      print "hola"
    }

En aquest fragment de &turtlescript; la part esquerra de `or` està avaluant a «true», el costat dret de «false». Atès que un dels dos costats de l'operador `or` és «true», l'operador `or` avaluarà «true». El qual vol dir que s'imprimirà «hola».

I, finalment, un exemple amb `not` que canvia de «true» a «fals» i de «fals» a «true». Doneu un cop d'ull:

    $n = 1
    if not ($n == 3) {
      print "hola"
    } else {
      print "sense hola ;-)"
    }

### Els operadors de comparació

Considereu en la possibilitat d'aquesta simple comparació:

    $answer = 10 > 3

Aquí `10` és comparat amb `3` amb l'operador «més gran que». El resultat d'aquesta comparació, el ​valor booleà `true` es desa a la variable `$answer`.

Tots els nombres i les variables (que contenen nombres) es poden comparar entre si amb els operadors de comparació.

Aquí hi ha tots els possibles operadors de comparació:

#### Tipus de preguntes

`$A == $B` | igual que | respon true si `$A` és igual que `$B`
`$A != $B` | no igual que | respon true si `$A` no és igual que `$B`
`$A > $B` | més gran que | respon true si `$A` és més gran que `$B`
`$A < $B` | més petit que | respon true si `$A` és més petit que `$B`
`$A >= $B` | més gran o igual que | respon true si `$A` és més gran o igual que `$B`
`$A <= $B` | més petit o igual que | respon true si `$A` és més petit o igual que `$B`

Tingueu en compte que $A i $B han de ser nombres o variables que contenen nombres.

## Ordres

Utilitzant ordres li direu a la tortuga o &kturtle; que faci quelcom. Algunes ordres necessiten alguna entrada o sortida. En aquesta secció explicarem totes les ordres integrades de &kturtle;. D'altra banda, utilitzant learn (aprèn), podreu crear les vostres pròpies ordres. Les ordres integrades que es debaten aquí es ressalten amb color blau fosc.

### Moure la tortuga

Hi ha diverses ordres per moure la tortuga sobre la pantalla.

forward -fw- (avança -av-)

      forward X

  `forward` mou la tortuga cap endavant la quantitat de X píxels. Quan el llapis està sota la tortuga aquesta deixa un rastre. `forward` pot abreujar-se com `fw`.

backward -bw- (recula -re-)

      backward X

  `backward` mou la tortuga cap enrere la quantitat de X píxels. Quan el llapis està sota la tortuga deixa un rastre. `backward` pot abreujar-se com `bw`.

turnleft -tl- (giraesquerra -ge-)

      turnleft X

  `turnleft` ordena a la tortuga tornar una quantitat de X graus cap a l'esquerra. `turnleft` pot abreujar-se com `tl`.

turnright -tr- (giradreta -gd-)

      turnright X

  `turnright` ordena a la tortuga tornar una quantitat de X graus cap a la dreta. `turnright` pot abreujar-se com `tr`.

direction -dir- (direcció -dir-)

      direction X

  `direction` estableix la direcció de la tortuga a una quantitat de X graus X comptant des de zero, i per tant no és relativa a la direcció anterior de la tortuga. `direction` pot abreujar-se com `dir`.

getdirection (obtinguesdireccio)

      getdirection (obtinguesdireccio)

  `getdirection` retorna la direcció de la tortuga a una quantitat de graus comptant des de zero, on zero és la direcció quan la tortuga està apuntant cap amunt.

center (centra)

      center

  `center` mourà la tortuga cap al centre sobre el llenç.

go (vésa)

      go X,Y

  `go` ordena a la tortuga anar cap a un lloc determinat en el llenç. Aquest lloc és X píxels des de l'esquerra del llenç, i Y píxels des de la part superior del llenç.

gox (vésax)

      gox X

  `gox` ordena a la tortuga que es desplaci X píxels des de l'esquerra del llenç mantenint la seva estada a la mateixa alçada. `gox` es pot abreujar a `gx`.

goy (vésay)

      goy Y

  `goy` ordena a la tortuga que es desplaci Y píxels des de la part superior del llenç mantenint la seva estada a la mateixa distància de la vora esquerra del llenç. `goy` es pot abreujar a `gy`.

Utilitzant les ordres `go`, `gox`, `goy` i `center` la tortuga no dibuixarà una línia, tant se val si el llapis és cap amunt o cap avall.

### On és la tortuga?

Hi ha dues ordres que retornen la posició de la tortuga sobre la pantalla.

getx (obtinguesx)

  `getx` retorna el nombre de píxels des de l'esquerra del llenç cap a la posició actual de la tortuga.

gety (obtinguesy)

  `gety` retorna el nombre de píxels des de la part superior del llenç cap a la posició actual de la tortuga.

### La tortuga té un llapis

La tortuga té un llapis que traça una línia quan aquesta es mou. Hi ha unes quantes ordres per controlar el llapis. S'expliquen en aquesta secció.

penup -pu- (aixecallapis -al-)

      penup

  `penup` aixeca el llapis del llenç. Quan el llapis està aixecat no es dibuixarà cap línia quan es mogui la tortuga. Veure també `pendown`. `penup` pot abreujar-se com `pu`.

pendown -pd- (baixallapis -bl-)

      pendown

  `penup` pressiona el llapis sobre el llenç. Quan el llapis està abaixat es dibuixarà una línia quan es mogui la tortuga. Veure també `penup`. `pendown` pot abreujar-se com `pd`.

penwidth -pw- (gruixllapis -gl-)

      penwidth X

  `penwidth` estableix l'amplada del traç del llapis (l'amplada de la línia) per una quantitat de X píxels. `penwidth` pot abreujar-se com `pw`.

pencolor -pc- (colorllapis -cl-)

      pencolor R,G,B

  `pencolor` estableix el color del llapis. `pencolor` pren una combinació RGB com a entrada. `pencolor` pot abreujar-se com `pc`.

### Ordres per controlar el llenç

Hi ha diverses ordres per controlar el llenç.

canvassize -cs- (midapaper -mp-)

      canvassize X,Y

  Amb l'ordre `canvassize` podreu establir la mida del llenç. Agafa X i Y com a entrada, on X és l'amplada del nou llenç en píxels, i Y és l'alçada del nou llenç en píxels. `canvassize` pot abreujar-se com `cs`.

canvascolor -cc- (colorpaper -cp-)

      canvascolor R,G,B

  `canvascolor` estableix el color del llenç. `canvascolor` pren una combinació RGB com a entrada. `canvascolor` pot abreujar-se com `cc`.

### Ordres per netejar

Hi ha dues ordres per netejar el llenç després d'haver fet un embolic.

clear -ccl- (neteja -net-)

      clear

  Amb `clear` podreu netejar tots els dibuixos del llenç. Totes les altres coses hi romandran: La posició i l'angle de la tortuga, el color del llenç, la visibilitat de la tortuga, i la mida del llenç.

reset (inicialitza)

      reset

  `reset` neteja molt més a fons que l'ordre `clear`. Després d'una ordre `reset` tot quedarà com en iniciar &kturtle;. La tortuga es col·loca al centre de la pantalla, el color del llenç és blanc, la tortuga dibuixa un traç negre sobre el llenç i la mida del llenç s'estableix a 400 x 400 píxels.

### La tortuga és un sprite

En primer lloc una breu explicació del que són els sprites: Els sprites són imatges petites que es poden moure per la pantalla, com veiem sovint en els jocs d'ordinador. La nostra tortuga és un sprite. Per a més informació veure el glossari quant a sprites.

A continuació trobareu una descripció completa de totes les ordres per a treballar amb sprites.

[La versió actual de &kturtle; encara no suporta l'ús d'sprites que no sigui la tortuga. Amb les futures versions es podrà canviar la tortuga per alguna cosa del vostre propi disseny.]

spriteshow -ss- (mostra -mo-)

      spriteshow

  `spriteshow` fa la tortuga visible de nou després d'haver-la ocultat. `spriteshow` pot abreujar-se com `ss`.

spritehide -sh- (oculta -oc-)

      spritehide

  `spritehide` oculta la tortuga. Es pot utilitzar si la tortuga no s'ajusta al vostre dibuix. `spritehide` pot abreujar-se com `sh`.

### Pot escriure la tortuga?

La resposta és: Sí. La tortuga pot escriure: Escriu gairebé tot el que se li ordena.

print (imprimeix)

      print X

  L'ordre `print` s'utilitza per ordenar a la tortuga que escrigui quelcom en el llenç. `print` pren els números i cadenes com a entrada. Podeu imprimir diversos nombres i cadenes mitjançant el símbol +. Veure aquest petit exemple:

      $year = 2003
      $author = "Joan"
      print "En " + $author + " va començar el projecte KTurtle al " + $year + " i encara gaudeix treballant-hi!"

fontsize (midalletra)

      fontsize X

  `fontsize` estableix la mida del tipus de lletra utilitza per `print`. `fontsize` pren una entrada que ha de ser un nombre. La mida s'estableix en píxels.

### Ordres matemàtiques

Les següents ordres són les ordres matemàtiques més avançades de &kturtle;.

round (arrod)

      round(x)

  `round` arrodoneix el nombre indicat a l'enter més proper.

      print round(10,8)
      forward 20
      print round(10,3)

  Amb aquest codi la tortuga imprimirà els nombres 11 i 10.

random -rnd- (aleatori -ale-)

      random X,Y

  `random` és una ordre que pren l'entrada i dóna una sortida. Com entrada requereix dos nombres, el primer (X) estableix el mínim de la sortida, el segon (Y) estableix el màxim. La sortida és un nombre escollit a l'atzar que és igual o superior al mínim i igual o inferior que el màxim. Aquí hi ha un petit exemple:

      repeat 500 {
        $x = random 1,20
        forward $x
        turnleft 10 - $x
      }

  Utilitzant l'ordre `random` podeu afegir una mica de caos al vostre programa.

mod

      mod X,Y

  L'ordre `mod` retorna la resta de la divisió del primer número pel segon número.

sqrt (arrel)

      sqrt X

  L'ordre `sqrt` és un requeriment per trobar l'arrel quadrada d'un nombre, X.

pi

      pi

  Aquesta ordre retorna la constant Pi, `3,14159`.

sin
, cos
, tan

      sin X
      cos X
      tan X

  Aquestes tres ordres representen les famoses funcions trigonomètriques `sin`, `cos` i `tan`. L'argument d'entrada d'aquestes ordres, X, és un nombre.

arcsin
, arccos
, arctan

      arcsin X
      arccos X
      arctan X

  Aquestes ordres són les funcions inverses de sin, cos i tan. L'argument d'entrada d'aquestes ordres, X, és un nombre.

### Aportacions i comentaris a través dels diàlegs

Un diàleg és una petita finestra emergent que proporciona alguna informació o us demana alguna entrada. &kturtle; té dos ordres per als diàlegs, anomenades: `message` i `ask`

message (missatge)

      message X

  L'ordre `message` pren una cadena com a entrada. Mostra un diàleg emergent que conté el text de la cadena.

      message "En Joan va començar el projecte KTurtle el 2003 i encara gaudeix treballant-hi!"

ask (pregunta)

      ask X

  `ask` pren una cadena com a entrada. La mostra en un diàleg emergent (similar a message), juntament amb un camp d'entrada. Després que l'usuari ha introduït un nombre o una cadena, el resultat es pot desar en una variable o passar-lo com a argument a una ordre. Per exemple:

      $in = ask "Quina és la vostra data de naixement?"
      $out = 2003 - $in
      print "L'any 2003 que van ser " + $out + " anys d'edat en algun moment."

  Si l'usuari cancel·la el diàleg d'entrada, o no entra res, la variable quedarà buida.

## Assignar les variables

En primer lloc donarem una ullada a les variables, llavors ens centrarem en l'assignació de valors a aquestes variables.

Les variables són paraules que comencen amb un $, en l'editor es ressalten amb color porpra.

Les variables poden contenir qualsevol nombre, cadena o valor booleà (true/false -cert/fals-). Utilitzant l'assignació, `=`, una variable pren el seu contingut. La qual mantindrà el contingut fins que el programa s'acabi d'executar o fins que la variable es torni a assignar a quelcom altre.

Podeu utilitzar variables, un cop assignades, simplement mantenen el seu contingut. Per exemple, en el següent fragment de &turtlescript;:

    $x = 10
    $x = $x / 3
    print $x

Primer a la variable `$x` se li assigna `10`. Llavors a `$x` es torna a assignar a la seva divisió per `3` -això significa que `$x` es torna a assignar al producte de `10 / 3`. Finalment imprimeix `$x`. En la línia dos i tres veureu que `$x` s'utilitza com si fos el seu contingut.

Les variables han de ser assignades per tal de ser utilitzades. Per exemple:

    print $n

Donarà com a resultat un missatge d'error.

Observem el següent fragment de &turtlescript;:

    $a = 2004
    $b = 25

    # Les següents ordres imprimeixen «2029»
    print $a + $b
    backward 30
    # La següent ordre imprimeix «2004 més 25 és igual que 2029»
    print $a + " més " + $b + " és igual que " + ($a + $b)

En les dues primeres línies les variables `$a` i `$b` s'estableixen a 2004 i 25. Després s'executen dues ordres `print` amb una `backward 30` al mig. Els comentaris abans de l'ordre `print` expliquen el que faran. L'ordre `backward 30` hi és per assegurar que cada sortida és una nova línia. Com podeu veure les variables es poden utilitzar com si fossin el que contenen, es poden utilitzar amb qualsevol tipus d'operador o com a entrada en utilitzar altres ordres.

Un exemple més:

    $name = ask "Quin és el teu nom?"
    print "Hola " + $name + "! Bona sort mentre apreneu l'art de la programació..."

Força simple. Una vegada més podeu veure com la variable `$name`, és tractada com una cadena.

En utilitzar variables l'inspector resulta molt útil. Mostra el contingut de totes les variables que estan actualment en ús.

## Controlar l'execució

Els controladors de l'execució us permeten -tal com el seu nom indica- controlar l'execució.

Els controladors de l'execució es ressalten amb color verd fosc en un tipus de lletra en negreta. Els parèntesis s'utilitzen juntament amb els controladors de l'execució i es ressalten amb color negre.

### Fer que la tortuga esperi

Si heu fet quelcom de programació en &kturtle; us haureu adonat que la tortuga pot ser molt ràpida dibuixant. Aquesta ordre farà que la tortuga esperi un període de temps determinat.

wait (espera)

      wait X

  `wait` fa que la tortuga esperi durant X segons.

      repeat 36 {
        forward 5
        turnright 10
        wait 0.5
      }

  Aquest codi dibuixa un cercle, però la tortuga esperarà mig segon després de cada pas. Això fa l'efecte d'una tortuga lenta.

### Executa «if -si-»

if (si)

      if booleà { ... }

  El codi que es col·loca entre els claudàtors només s'executarà si el valor booleà avalua true.

      $x = 6
      if $x > 5 {
        print "$x és més gran que cinc!"
      }

  A la primera línia `$x` està establert a 6. En la segona línia s'utilitza un operador de comparació per avaluar $x > 5. Atès que aquest avalua true, 6 és més gran que 5, el controlador de l'execució `if` permet executar el codi entre els claudàtors.

### Si no, en altres paraules: «else -altrament-»

else (altrament)

      if booleà { ... } else { ... }

  `else` es pot utilitzar a més del controlador de l'execució `if`. El codi entre claudàtors després de `else` només s'executa si el booleà avalua false.

      reset
      $x = 4
      if $x > 5 {
        print "$x és més gran que cinc!"
      } else {
        print "$x és més petit que sis!"
      }

  L'operador de comparació avalua l'expressió `$x > 5`. Donat que 4 no és més gran que 5, l'expressió s'avalua com fals. Això significa que el codi entre claudàtors després de `else` serà executat.

### El bucle «while -mentre-»

while (mentre)

      while booleà { ... }

  El controlador de l'execució `while` s'assembla molt a `if`. La diferència és que `while` no deixa de repetir (en bucle) el codi entre claudàtors fins que el booleà avalua false.

      $x = 1
      while $x < 5 {
        forward 10
        wait 1
        $x = $x + 1
      }

  En la primera línia `$x` s'estableix a 1. En la segona línia s'avalua `$x < 5`. Atès que la resposta a aquesta pregunta és true el controlador de l'execució while començarà a executar el codi entre claudàtors fins que `$x < 5` avaluï false. En aquest cas el codi entre els claudàtors s'executarà quatre vegades, perquè cada vegada que s'executa la cinquena línia `$x` s'incrementa en 1.

### El bucle «repeat -repeteix-»

repeat (repeteix)

      repeat nombre { ... }

  El controlador de l'execució `repeat` és molt similar `while`. La diferència és que `repeat` no deixa de repetir (en bucle) el codi entre els claudàtors tantes vegades com indica el nombre.

### El bucle «for -per-», un bucle de comptatge

for (per)

      for variable = nombre to nombre { ... }

  El bucle `for` és un bucle de comptatge, &ead;, que porta el compte per a vós. El primer nombre estableix la variable amb el valor en el primer bucle. Cada bucle incrementa aquest nombre fins que s'assoleix el segon nombre.

      for $x = 1 to 10 {
        print $x * 7
        forward 15
      }

  Cada vegada que s'executa el codi entre claudàtors `$x` s'incrementa en 1, fins que `$x` assoleix al valor de 10. El codi entre claudàtors imprimeix `$x` multiplicat per 7. Després que aquest programa acaba la seva execució veureu la taula de temps de 7 en el llenç.

  L'increment per omissió d'un bucle és 1, podeu utilitzar un altre valor amb

      for variable = nombre to nombre step nombre { ... }

### Deixar un bucle

break (trenca)

      break

  Finalitza el bucle actual immediatament i transfereix el control a la sentència immediatament següent a aquest bucle.

### Aturar l'execució del vostre programa

exit (surt)

      exit

  Finalitza l'execució del vostre programa.

### Comprovar les declaracions en temps d'execució

assert (declara)

      assert booleà

  Es pot utilitzar per a raonar sobre la correcció del programa o de l'entrada.

      $in = ask "Quina és la vostra data de naixement?"
      # l'any ha de ser un nombre positiu
      assert $in
      > 0

## Crear les vostres pròpies ordres amb learn -aprèn-

`learn`
és especial, ja que s'utilitza per crear les vostres pròpies ordres. Les ordres que creeu poden agafar una entrada i retornar una sortida. Donem una ullada a com es crea una ordre nova:

    learn circle $x {
      repeat 36 {
        forward $x
        turnleft 10
      }
    }

La nova ordre s'anomena `circle`. `circle` té una entrada com argument, per establir la mida del cercle. `circle` no torna cap sortida. Ara podeu utilitzar l'ordre `circle` com una ordre normal a la resta del codi. Veure aquest exemple:

    learn circle $X {
      repeat 36 {
        forward $X
        turnleft 10
      }
    }

    go 200,200
    circle 20

    go 300,200
    circle 40

En el següent exemple, es crea una ordre amb un valor de retorn
.

    learn faculty $x {
      $r = 1
      for $i = 1 to $x {
        $r = $r * $i
      }
      return $r
    }

    print faculty 5

En aquest exemple es crea una ordre nova anomenada `faculty`. Si l'entrada d'aquesta ordre és `5`, la sortida serà `5*4*3*2*1`. Mitjançant l'ús de `return` s'especificarà el valor de la sortida i es retornarà la fi de l'execució.

Les ordres poden tenir més d'una entrada. En el següent exemple, es crea una ordre que dibuixa un rectangle:

    learn box $x, $y {
      forward $y
      turnright 90
      forward $x
      turnright 90
      forward $y
      turnright 90
      forward $x
      turnright 90
    }

Ara podeu executar `box 50, 100` i la tortuga dibuixarà un rectangle en el llenç.