# Referência de Programação de &turtlescript;

Esta é a referência para o &turtlescript; do &kturtle;. Na primeira secção deste capítulo dê uma vista de olhos em alguns aspectos da gramática dos programas em &turtlescript;. A segunda secção lida em exclusivo com os operadores matemáticos, os operadores booleanos (verdadeiro/falso) e os operadores de comparação. A terceira secção é uma lista enorme com todos os comandos, explicando-os um-a-um. A quarta secção explica como atribuir valores às variáveis. Finalmente, é explicado como organizar a execução dos comandos com as instruções de controlo da execução na quinta secção e como criar os seus próprios comandos com o aprender, na última secção.

## A Gramática do &turtlescript;

Como em qualquer linguagem, o &turtlescript; tem diferentes tipos de palavras e símbolos. No Português, é feita a distinção entre os verbos (como 'andar' ou 'cantar') e os substantivos (como 'irmã' ou 'casa'), sendo usados para diferentes fins. O &turtlescript; é uma linguagem de programação, sendo usada para indicar ao &kturtle; o que fazer.

Nesta secção, alguns dos diferentes tipos de palavras e símbolos do &turtlescript; são explicados de forma breve. Serão explicados os comentários, os comandos e os três diferentes tipos de literais: números, cadeias de caracteres e os valores booleanos (verdadeiro/falso).

### Comentários

Um programa contém instruções que são executadas quando o programa é executado e outros itens, chamados de comentários. Os comentários não são executados; o &kturtle; simplesmente ignora-os ao executar o seu programa. Os comentários estão lá para que os outros programadores possam compreender melhor o seu programa. Tudo o que estiver a seguir a um símbolo `#` é considerado um comentário no &turtlescript;. Por exemplo, este pequeno programa não faz nada:

    # este pequeno programa não faz nada, é apenas um comentário!

É um pouco inútil, mas explica bem o conceito.

Os comentários tornam-se bastante úteis quando o programa se torna um pouco mais complexo. Podê-lo-á ajudar a dar alguns conselhos aos outros programas. No seguinte programa, irá ver os comentários a serem usados em conjunto com o comando imprimir.

    # este programa foi feito pelo Cies Breijs.
    imprimir "este texto será impresso na área de desenho"
    # a linha anterior não é um comentário, mas a seguinte é:
    # imprimir "este texto não será impresso!"

A primeira linha descreve o programa. A segunda é executada pelo &kturtle; e imprime a mensagem `este texto será impresso na área de desenho` na área de desenho propriamente dita. A terceira linha é um comentário. A quarta linha é um comentário que contém um pedaço de &turtlescript;, se for retirado o símbolo `#` da quarta linha, a instrução 'imprimir' será executada pelo &kturtle;. Os programadores dizem: a instrução da quarta linha está 'comentada'.

As linhas comentadas ficam realçadas com um cinzento claro no editor.

### Comandos

Ao usar os comandos, você diz à tartaruga ou ao &kturtle; para fazerem algo. Alguns comandos necessitam de dados de entrada, enquanto outros geram resultados.

    # o 'avancar' é um comando que necessita de dados de entrada, neste caso do número 100:
    avancar 100

A primeira linha é um comentário. A segunda linha contém o comando `avancar` e o número `100`. O número não faz parte do comando, mas é considerada uma 'entrada' para o comando.

Alguns comandos, como ⪚ o `go` necessitam de mais que um parâmetro. Os vários parâmetros, nesse caso, deverão ser separados pelo carácter `,` (vírgula).

Para uma ideia geral de todos os comandos que o &kturtle; suporta, venha aqui. Os comandos incorporados são realçados a azul-escuro

### Números

O mais provável é que você já conheça alguma coisa sobre os números. A forma como estes são usados no &kturtle; não é muito diferente da língua falada ou da matemática.

Temos os chamados números naturais: `0`, `1`, `2`, `3`, `4`, `5`, etc. Os números negativos: `-1`, `-2`, `-3`, etc. E os números decimais, por exemplo: `0,1`, `3,14`, `33,3333`, `-5,05`, `-1,0`. O carácter `,` (vírgula) é usado como separador decimal.

Os números poderão ser usados nos operadores matemáticos e nos operadores de comparação. Também poderão ser guardados em variáveis. Os números são realçados a vermelho escuro.

### Cadeias de caracteres

Primeiro um exemplo:

    print "Olá, sou uma cadeia de caracteres."

Neste exemplo, o `print` é um comando, enquanto o `"Olá, sou uma cadeia de caracteres."` é, de facto, uma cadeia de caracteres. Estas começam e terminam com o símbolo `"`; com estes símbolos, o &kturtle; sabe que é uma cadeia de caracteres.

As cadeias de caracteres poderão ser colocadas em variáveis, como acontece com os números. Contudo, ao contrário dos números, as cadeias de caracteres não podem ser usadas nos operadores matemáticos ou nos operadores de comparação. As cadeias de caracteres são realçadas a vermelho.

### Valores booleanos (verdadeiro/falso)

Existem apenas dois valores booleanos: `verdadeiro`
e `falso`
. Algumas vezes também são chamados de: ligado e desligado, um e zero. Contudo, no &turtlescript; são sempre chamados de `verdadeiro` e `falso`. Dê uma vista de olhos neste excerto de &turtlescript;:

    $a = verdadeiro

Se olhar para o inspector, poderá ver que a variável `$a` está igual a `verdadeiro`, tendo um tipo booleano.

Normalmente, os valores booleanos são o resultado de um operador de comparação, como acontece no seguinte excerto de &turtlescript;:

    $resposta = 10 > 3

A variável `$resposta` é configurada como `verdadeiro`, dado que `10` é maior que `3`.

Os valores booleanos, `true` (verdadeiro) e `false` (falso), estão realçados a vermelho escuro.

## Operadores matemáticos, booleanos e de comparação

O título deste secção poderá soar muito complicado, mas não é tão difícil de compreender como parece.

### Operadores matemáticos

Estes são os símbolos matemáticos básicos conhecidos: a adição (`+`), a subtracção (`-`), a multiplicação (`*`), a divisão (`/`) e a potência (`^`).

Aqui está um pequeno exemplo dos operadores matemáticos que poderá usar no &turtlescript;:

    $somar      = 1 + 1
    $subtrair = 20 - 5
    $multiplicar = 15 * 2
    $dividir   = 30 / 30
    $elevar    = 2 ^ 2

Os valores que resultam das operações matemáticas serão atribuídos às diversas variáveis. Se utilizar o inspector, poderá ver os valores.

Se você somente queria fazer um cálculo simples, você poderá fazer algo semelhante a isto:

    imprimir 2010-12

Agora, um exemplo com parêntesis:

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

O que estiver entre parêntesis será calculado em primeiro lugar. Neste exemplo, o 20-5 será calculado, depois será multiplicado por 2, dividido por 30 e depois é adicionado 1 (o que dá 2). Os parêntesis também poderão ser usados noutros casos.

O &kturtle; também tem mais funcionalidades sob a forma de comandos. Dê uma vista de olhos sobre os seguintes comandos, mas tenha em mente que diz respeito a operações avançadas: round, random, sqrt, pi, sin, cos, tan, arcsin, arccos, arctan.

### Operadores booleanos (verdadeiro/falso)

Enquanto os operadores matemáticos são usados principalmente para os números, os operadores booleanos são para os valores booleanos (`verdadeiro` e `falso`). Existem apenas três operadores booleanos, o `
`, `
` e `
`. O seguinte exemplo de &turtlescript; mostra como usá-los:

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

    $ou_1_1 = verdadeiro ou verdadeiro    # -> verdadeiro
    $ou_1_0 = verdadeiro ou falso   # -> verdadeiro
    $ou_0_1 = falso ou verdadeiro   # -> verdadeiro
    $ou_0_0 = falso ou falso  # -> falso

    $nao_1 = nao verdadeiro   # -> falso
    $nao_0 = nao falso  # -> verdadeiro

Se usar o inspector, poderá ver os valores; contudo, fornecemos estes resultados como pequenos comentários no fim das linhas. O `e` é avaliado como `verdadeiro` apenas se ambos os lados forem `verdadeiro`. O `ou` é avaliado como `verdadeiro` se qualquer um dos lados for `verdadeiro`. Finalmente, o `nao` transforma um `verdadeiro` num `falso` e um `falso` num `verdadeiro`.

Os operadores booleanos são realçados a rosa.

#### Alguns exemplos mais avançados

Veja o exemplo seguinte com o `e`:

    $a = 1
    $b = 5
    se (($a < 10) e ($b == 5)) e ($a < $b) {
      imprimir "olá"
    }

Neste excerto de &turtlescript;, o resultado dos três operadores de comparação é reunido com os operadores `e`. Isto significa que todos os três têm de ser avaliados como "verdadeiro" para imprimir o "olá".

Um exemplo com o `ou`:

    $n = 1
    se ($n < 10) ou ($n == 2) {
      imprimir "olá"
    }

Neste pedaço de &turtlescript;, o lado esquerdo do `ou` é avaliado como 'verdadeiro', enquanto o direito é avaliado como 'falso'. Dado que um dos lados do operador `ou` é 'verdadeiro', o operador `ou` é avaliado como 'verdadeiro'. Isto significa que o 'olá' é impresso.

Finalmente, um exemplo com o `não`, que muda o 'verdadeiro' para 'falso' e o 'falso' para 'verdadeiro'. Dê uma vista de olhos:

    $n = 1
    se nao ($n == 3) {
      imprimir "olá"
    } senao {
      imprimir "não olá ;-)"
    }

### Operadores de comparação

Considere esta simples comparação:

    $resposta = 10 > 3

Aqui o `10` é comparado com o `3`, através do operador 'maior que'. O resultado desta comparação, o valor booleano `verdadeiro` é guardado na variável `$resposta`.

Todos os números e variáveis (que contenham números) poderão ser comparados entre si, com os operadores de comparação.

Aqui estão todos os possíveis operadores de comparação:

### Tipos de perguntas

`A == B` | é igual | a resposta é verdadeira se o `A` for igual a `B`
`A != B` | é diferente | a resposta é verdadeira se o `A` não for igual ao `B`
`A > B` | maior que | a resposta é verdadeira se o `A` for maior que o `B`
`A < B` | menor que | a resposta é verdadeira se `A` for menor que `B`
`A >= B` | maior ou igual a | a resposta é verdadeira se `A` for maior ou igual ao `B`
`A <= B` | menor ou igual a | a resposta é verdadeira se `A` for menor ou igual a `B`

Lembre-se que o A e o B têm de ser números ou variáveis que contenham números.

## Comandos

Ao usar os comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados introduzidos, enquanto outros trazem resultados. Nesta secção iremos explicar todos os comandos incorporados que podem ser usados no &kturtle;. Em alternativa, usando o aprender, poderá criar os seus próprios comandos. Os comandos incorporados ficam realçados a azul escuro.

### Mover a tartaruga

Existem vários comandos para mover a tartaruga pelo ecrã.

forward (fw)

-     forward X

  O `forward` move a tartaruga para a frente X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rasto. O `forward` pode ser abreviado para `fw`

backward (bw)

-     backward X

  O `backward` move a tartaruga para trás X pixels. Quando o traço está em baixo, a tartaruga irá deixar um rasto. O `backward` pode ser abreviado para `bw`.

turnleft (tl)

-     turnleft X

  O `turnleft` diz à tartaruga para se virar X graus para a esquerda. O `turnleft` pode ser abreviado para `tl`.

turnright (tr)

-     turnright X

  O `turnright` diz à tartaruga para se virar X graus para a direita. O `turnright` pode ser abreviado para `tr`.

direction (dir)

-     direction X

  O `direction` configura a direcção da tartaruga para um ângulo de X graus a contar do zero, e isto não é relativo à direcção anterior da tartaruga. O `direction` pode ser abreviado para `dir`.

getdirection

-     getdirection

  O `getdirection` devolve a direcção da tartaruga como um ângulo de X graus a contar do zero, onde o zero é a direcção em que a tartaruga aponta para cima.

center

-     center

  O `center` move a tartaruga para o centro da área de desenho.

go

-     go X,Y

  O `go` manda a tartaruga ir para um dado local da área de desenho. Este local está a X pixels do lado esquerdo da área de desenho e a Y pixels do topo da área.

gox

-     gox X

  Ao usar o comando `gox`, a tartaruga irá mover-se X pixels a partir da esquerda da área de desenho, mantendo à mesma a sua altura. O `gox` pode ser abreviado para `gx`.

goy

-     goy Y

  Ao usar o comando `goy`, a tartaruga irá mover-se Y pixels a partir do topo da área de desenho, mantendo à mesma a sua distância ao lado esquerdo da área de desenho. O `goy` pode ser abreviado para `gy`.

Usando os comandos `go`, `gox`, `goy` e `center`, a tartaruga não irá desenhar a linha, não interessando se a caneta está activa ou não.

### Onde está a tartaruga?

Existem dois comandos que devolvem a posição da tartaruga no ecrã.

getx

- O `getx` devolve o número de pixels da esquerda da área de desenho até à posição actual da tartaruga.

gety

- O `gety` devolve o número de pixels de cima da área de desenho até à posição actual da tartaruga.

### A tartaruga tem um traço

A tartaruga tem um traço e vai desenhando uma linha à medida que a tartaruga se move. Existem alguns comandos para controlar o traço. Nesta secção iremos explicar estes comandos.

penup (pu)

-     penup

  O `penup` levanta o traço da área de desenho. Quando o traço está em cima, não é desenhada nenhuma linha à medida que a tartaruga se move. Veja também o `pendown`. O `penup` pode ser abreviado para `pu`.

pendown (pd)

-     pendown

  O `pendown` carrega no traço para baixo na área de desenho. Quando o traço está em baixo, é desenhada uma linha à medida que a tartaruga se move. Veja também o `penup`. O `pendown` pode ser abreviado para `pd`.

penwidth (pw)

-     penwidth X

  O `penwidth` configura a espessura do traço para X pixels. O `penwidth` pode ser abreviado para `pw`.

pencolor (pc)

-     pencolor R,G,B

  O `pencolor` configura a cor do traço. O `pencolor` recebe uma combinação de RGB como parâmetro. O `pencolor` pode ser abreviado para `pc`.

### Comandos para controlar a área de desenho

Existem vários comandos para controlar a área de desenho.

canvassize (cs)

-     canvassize X,Y

  Com o comando `canvassize`, poderá definir o tamanho da área de desenho. Recebe um X e um Y como entrada, onde o o X é a nova largura da área de desenho em pixels e o Y é a nova altura da área de desenho em pixels. O `canvassize` pode ser abreviado para `cs`.

canvascolor (cc)

-     canvascolor R,G,B

  O `canvascolor` configura a cor do traço. O `canvascolor` recebe uma combinação de RGB como parâmetro. O `canvascolor` pode ser abreviado para `cc`.

### Comandos para limpar

Existem dois comandos para limpar a área de desenho, depois de você ter deixado tudo confuso.

clear (ccl)

-     clear

  Com o `clear`, você poderá limpar todos os desenhos da área respectiva. Tudo o resto permanece igual: a posição e o ângulo da tartaruga, a cor da área de trabalho, a visibilidade da tartaruga e o tamanho da área de desenho.

reset

-     reset

  O `reset` limpa tudo de forma mais abrangente que o comando `clear`. Depois de um comando `reset`, tudo fica tal e qual estava quando você iniciou o &kturtle;. A tartaruga é posicionada no meio do ecrã, a cor da área de desenho é branca e a tartaruga irá desenhar uma linha preta na área de desenho, que fica com um tamanho de 400 x 400 0 pixels.

### A tartaruga é uma imagem móvel

Muitas das pessoas não sabem o que são as imagens móveis ('sprites'), daí uma breve explicação: as imagens móveis são pequenas imagens que podem percorrer o ecrã (para mais informações, veja o glossário sobre as imagens móveis).

A seguir você irá encontrar uma apresentação completa de todos os comandos que lidam com imagens móveis.

[A versão actual do &kturtle; não suporta ainda o uso de imagens móveis que não apenas a tartaruga. Nas versões futuras, você poderá mudar a tartaruga para outra coisa ao seu gosto]

spriteshow (ss)

-     spriteshow

  O `spriteshow` torna a tartaruga visível de novo depois de ter ficado escondida. O `spriteshow` pode ser abreviado para `ss`.

spritehide (sh)

-     spritehide

  O `spritehide` esconde a tartaruga. Isto pode ser usado se a tartaruga não couber no seu desenho. O `spritehide` pode ser abreviado para `sh`.

### Será que a tartaruga escreve?

A resposta é: sim. A tartaruga sabe escrever e pode escrever tudo o que lhe disser para escrever.

print

-     print X

  O comando `print` é usado para dizer à tartaruga para escrever algo na área de desenho. O `print` recebe números e texto como parâmetros. Você poderá executar o `print` para vários parâmetros com o sinal +. Veja aqui um pequeno exemplo:

      $ano = 2004
      $autor = "Ze"
      print "O " + $autor + " iniciou o projecto do KTurtle em " + $ano + " e ainda continua a gostar de trabalhar nele!"

fontsize

-     fontsize X

  O `fontsize` configura o tamanho da letra que é usado pelo `print`. O `fontsize` recebe um parâmetros que deverá ser um número. O tamanho é definido em pixels.

### Comandos matemáticos

Os seguintes comandos são as instruções matemáticas mais avançadas do &kturtle;.

round

-     round(x)

  O `round` arredonda o número indicado ao inteiro mais próximo.

      imprimir round(10.8)
      avancar 20
      imprimir round(10.3)
      avancar 20

  Com este código, a tartaruga iria apresentar os números 11 e 10.

random (rnd)

-     random X,Y

  O `random` é um comando que recebe parâmetros e devolve resultados. Como parâmetros são necessários dois números, em que o primeiro define o resultado mínimo (X) e o segundo o máximo (Y). O resultado é um número escolhido aleatoriamente que é maior ou igual ao mínimo e menor ou igual ao máximo. Aqui está um pequeno exemplo:

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

  Com o comando `random`, você poderá adicionar um pouco de confusão ao seu programa.

mod

-     mod X,Y

  O comando `mod` devolve o resto da divisão do primeiro número pelo segundo.

sqrt

-     sqrt X

  O comando `sqrt` é usado para descobrir a raiz quadrada de um número X.

pi

-     pi

  Este comando devolve a constante Pi, `3,14159`.

sin
, cos
, tan

-     sin X
      cos X
      tan X

  Estes três comandos representam as conhecidas funções trigonométricas `sin` (seno), `cos` (coseno) e `tan` (tangente). O argumento de entrada destes comandos, o X, é um número.

arcsin
, arccos
, arctan

-     arcsin X
      arccos X
      arctan X

  Estes comandos são as funções inversas do sin, cos e tan. O argumento de entrada destes comandos, o X, é um número.

### Entrada de dados e reacção através de janelas

Uma janela poderá pedir alguma alguma reacção em especial ou a introdução de determinados dados. O &kturtle; tem dois comandos para janelas, nomeadamente o `message` e o `ask`

message

-     message X

  O comando `message` recebe uma cadeia de caracteres à entrada. Mostra então uma janela que contém o texto da cadeia de caracteres.

      mensagem "O Ze iniciou o projecto do KTurtle em 2003 e ainda continua a gostar de trabalhar nele!"

ask

-     ask X

  O `ask` recebe uma cadeia de caracteres à entrada. Mostra uma janela que contém o texto da cadeia de caracteres, tal como acontece no message. Contudo, para além disso, também mostra um campo de texto na janela. Através deste campo, o utilizador poderá introduzir um número ou uma cadeia de caracteres que poderá ser guardada numa variável ou passado como argumento a um comando. Por exemplo

      $entrada = perguntar "Que idade tem?"
      $saida = 2003 - $entrada
      imprimir "Em 2003, você tinha " + $saida + " anos a dada altura."

  Quando um utilizador cancelar a janela ou não introduzir nada de todo, a variável fica vazia.

## Atribuição de variáveis

Vejamos primeiro as variáveis, e depois iremos ver como atribuir valores a essas variáveis.

As variáveis são palavras que começam por um $; no editor, são realçadas a púrpura.

As variáveis poderão conter qualquer número, texto ou valor booleano (verdadeiro/falso). Ao usar a atribuição `=`, uma variável ficará com conteúdo associado. Irá manter esse conteúdo até que o programa termine a execução ou até a variável ser atribuída de novo a outra coisa qualquer.

Poderá usar as variáveis, uma vez atribuídas, como se fossem o seu próprio conteúdo. Por exemplo, no seguinte excerto de &turtlescript;:

    $x = 10
    $x = $x / 3
    imprimir $x

Primeiro, é atribuído à variável `$x` o valor `10`. Depois, o `$x` terá como novo valor o seu próprio valor dividido por `3` — isto significa na prática que o `$x` terá atribuído o valor do produto `10 / 3`. Finalmente, é impresso o valor do `$x`. Nas linhas 2 e 3, irá ver que o `$x` é usado como se fosse o seu próprio conteúdo.

As variáveis têm de estar atribuídas para poderem ser usadas. Por exemplo, um:

    imprimir $N

Isto não irá imprimir nada e irá obter uma mensagem de erro.

Considere o pequeno excerto de código em &turtlescript;:

    $a = 2004
    $b = 25

    # o próximo comando imprime "2029"
    imprimir $a + $b
    recuar 30
    # o próximo comando imprime "2004 mais 25 é igual a 2029"
    imprimir $a + " mais " + $b + " é igual a " + ($a + $b)
    recuar 30

Nas duas primeiras linhas, as variáveis `a` e `b` são configuradas como sendo iguais a 2004 e 25. Depois nos dois comandos `imprimir` existe um comando `recuar 30` no meio. Os comentários antes dos comando `imprimir` explicam o que está a fazer. Como poderá ver, as variáveis poderão ser usadas como se fossem o valor que contêm, podendo usá-las com qualquer tipo de operadores ou fornecendo-os como entradas na invocação dos comandos.

Mais um exemplo:

    $nome = perguntar "Como te chamas?"
    imprimir "Olá " + $nome + "! Boa sorte a aprender a arte da programação..."

É bastante simples. Mais uma vez, poderá ver que a variável `$nome`, é tratada apenas como texto.

Ao usar as variáveis, o inspector torna-se bastante útil. Mostra-lhe o conteúdo de todas as variáveis que estão a ser usadas de momento.

## Controlar a execução

Os controladores de execução permitem-lhe — como o nome deles indica — controlar a execução.

Os comandos de controlo da execução ficam realçados a verde escuro e a negrito. Os parêntesis rectos, que são mais usados em conjunto com os controladores de execução, ficam realçados a preto e em negrito.

### Fazer a tartaruga esperar

Se já tentou programar um pouco no &kturtle;, você já poderá ter reparado que a tartaruga pode ser bastante rápida a desenhar. Este comando faz a tartaruga andar um pouco mais devagar.

wait

-     wait X

  O `wait` faz a tartaruga esperar X segundos.

      repeat 36 [
        forward 5
        turnright 10
        wait 0.5
      ]

  Este código irá desenhar uma circunferência, mas a tartaruga irá esperar meio segundo a cada passo. Isto dá a noção de uma tartaruga vagarosa.

### Executar o "if"

if

-     se booleano [ ... ]

  O código que é colocado entre os parêntesis só será executado `se` o valor booleano for verdadeiro.

      $x = 6
      se $x > 5 [
        imprimir "O x é maior que cinco!"
      ]

  Na primeira linha, o `$x` é inicializado a 6. Na segunda linha, a operador de comparação é usado para avaliar `x > 5`. Dado que a resposta a esta pergunta é verdadeira, o controlador de execução `se` irá permitir que o código entre chavetas seja executado.

### Se não, por outras palavras: "else"

else

-     se booleano { ... } senao { ... }

  O `senao` pode ser usado para além do controlador de execução `se`. O código entre chavetas a seguir ao `senao` só é executado se o valor booleano for falso.

      reset
      $x = 4
      se $x > 5 {
        imprimir "O x é maior que cinco!"
      } senao {
        imprimir "O x é menor que seis!"
      }

  O operador de comparação testa a expressão `x > 5`. Dado que o `x` fica igual a 4 na primeira linha, a resposta à pergunta é falso. Isto significa que o código entre chavetas a seguir ao `senao` é executado.

### O ciclo "while"

while

-     enquanto booleano { ... }

  O controlador de execução `while` é um pouco como o `se`. A diferença é que o `while` continua a repetir o código entre parêntesis até que a resposta à valor booleano seja falso.

      $x = 1
      enquanto $x < 5 {
        avancar 10
        esperar 1
        $x = $x + 1
      }

  Na primeira linha, o `$x` fica igual a 1. Na segunda, a expressão `x < 5` é avaliada. Dado que a resposta a esta pergunta é verdadeiro, o controlador de execução `enquanto` começa a execução do código entre chavetas até que a condição `$x < 5` seja falso. Neste caso, o código entre parêntesis será executado 4 vezes, dado que, de cada vez que a quinta linha é executada, o `$x` fica um número acima.

### O ciclo "repeat"

repeat

-     repetir número { ... }

  O controlador de execução `repetir` funciona um pouco como o `enquanto`. A diferença é que o `repetir` continua a repetir (em ciclo) o código entre parêntesis para o número indicado.

### O ciclo "for", um ciclo de contagem

for

-     para variável = número até número { ... }

  O ciclo `para` é um ciclo de contagem, &ie;, faz de contador para si. O primeiro membro configura a variável com o valor do primeiro ciclo. Em cada iteração, o número é aumentado até atingir o segundo número.

      para $x = 1 ate 10 {
        imprimir $x * 7
        avancar 15
      }

  De cada vez que o código entre chavetas é executado, o `$x` é incrementado de uma unidade, até que o valor do `x` chegue a 10. O código entre chavetas imprime o valor de `$x` multiplicado por 7. Depois de este programa terminar a sua execução, você irá ver a tabuada dos 7 na área de desenho.

  O tamanho por omissão do passo de um ciclo é 1; poderá usar outro valor qualquer com

      para variável = número até number passo número { ... }

### Sair de um ciclo

break

-     break

  Termina imediatamente o ciclo actual e transfere o controlo para a instrução imediatamente a seguir a esse ciclo.

### Pára a a execução do seu programa

exit

-     exit

  Termina a execução do seu programa.

### Verificar os testes durante a execução

assert

-     assert booleano

  Pode ser usado para confirmar a correcção do programa ou dos seus parâmetros.

      $valor = ask "Qual é a sua data de nascimento?"
      # o ano tem de ser positivo
      assert $valor
      > 0

## Crie os seus próprios comandos com o learn

O `aprender`
é um comando muito especial, porque é usado para criar os seus próprios comandos. O comando que criar poderá receber parâmetros e devolver resultados. Vamos ver como é que é criado um novo comando.

    aprender circunferencia $x {
      repetir 36 {
        avancar $x
        esquerda 10
      }
    }

O novo comando chama-se `circunferencia`. O `circunferencia` recebe um parâmetro, um número, para definir o tamanho da circunferência. O `circunferencia` não devolve nenhum resultado. O comando `circunferencia` pode agora ser usado como um comando normal. Veja este exemplo:

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

    go 30,30
    circunferencia 20

    go 40,40
    circunferencia 50

No próximo exemplo, vai ser criado um comando
com um valor de resultado devolvido.

    aprender faculdade $x {
      $r = 1
      para $i = 1 ate $x {
        $r = $n * $i
      }
      devolver $r
    }

    imprimir faculdade 5

Neste exemplo, existe agora um comando novo chamado `faculdade`. Se o parâmetro deste comando for `5`, então o resultado é igual a `5*4*3*2*1`. Ao usar o `devolver`, o valor do resultado é indicado e a execução é devolvida.

Os comandos poderão ter mais de uma entrada. No exemplo seguinte, é criado um comando que desenha um rectângulo.

    learn caixa $x, $y {
      avancar $y
      direita 90
      avancar $x
      direita 90
      avancar $y
      direita 90
      avancar $x
      direita 90
    }

Agora, poderá usar o `caixa 50, 100` para que a tartaruga desenhe um rectângulo na área de desenho.