# Referência de programação do &turtlescript;

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

## A Gramática do &turtlescript;

Como em qualquer linguagem, o &turtlescript; possui 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 seçã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 após 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. Ele poderá ajudar a fornecer alguns conselhos aos outros programadores. No programa a seguir, irá ver os comentários a serem usados juntamente com o comando imprimir.

    # este programa foi feito pelo Cies Breijs.
    mostre "este texto será impresso na área de desenho"
    # a linha anterior não é um comentário, mas a seguinte é:
    # mostre "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 em cinza claro no editor.

### Comandos

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

    # o 'parafrente' é um comando que necessita de dados de entrada, neste caso do número 100:
    parafrente 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 &eg; `vápara` precisam de mais de um valor de entrada. Valores múltiplos devem ser separados usando o caracter `,` (vírgula).

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

### Números

Muito provavelmente você já conhece alguma coisa sobre os números. A forma como eles são usados no &kturtle; não é muito diferente do idioma falado ou da matemática.

Temos então os números conhecidos por naturais: `0`, `1`, `2`, `3`, `4`, `5`, &etc; Os números negativos: `-1`, `-2`, `-3`, &etc; Finalmente, os números decimais ou fracionários, como por exemplo: `0.1`, `3.14`, `33.3333`, `-5.05`, `-1.0`. O caractere `.` (ponto) é 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 em vermelho escuro.

### Cadeias de caracteres

Primeiro um exemplo:

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

Neste exemplo, o `mostre` é um comando, enquanto o `"Olá, sou uma cadeia de caracteres."` é, de fato, uma cadeia de caracteres. Elas começam e terminam com o símbolo `"`; através destes 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 em vermelho.

### Valores booleanos (verdadeiro/falso)

Existem apenas dois valores booleanos: `verdadeiro`
e `falso`
. Às vezes também são chamados de: `ligado` e `desligado`, `sim` e `não`, `um` e `zero`. Contudo, no &turtlescript; são sempre chamados de `verdadeiro` e `falso`. Dê uma olhada neste trecho de &turtlescript;:

    $a = verdadeiro

Se olhar para o inspetor, 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 trecho de &turtlescript;:

    $resposta = 10 > 3

A variável `$resposta` é configurada como `verdadeiro`, uma vez 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 seçã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 subtração (`-`), a multiplicação (`*`), a divisão (`/`) e a potenciação (`^`).

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 inspetor, poderá ver os valores.

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

    mostre 2010-12

Agora, um exemplo com parênteses:

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

O que estiver entre parênteses 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). Parênteses podem ser usados em outros casos.

O &kturtle; também possui mais funcionalidades sob a forma de comandos. Dê uma olhada nos seguintes comandos, mas tenha em mente o que diz respeito a operações avançadas: arredonda, aleatório, raizquadrada, pi, seno, cosseno, tangente, arcoseno, arcocosseno, arcotangente.

### 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 e são chamados de: `e`
, `ou`
, e `não`
. 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

    $not_1 = nao verdadeiro   # -> falso
    $not_0 = nao falso  # -> verdadeiro

Se usar o inspetor, 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 em rosa.

#### Alguns exemplos mais avançados

Veja o exemplo a seguir com o `e`:

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

Neste trecho 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) {
      mostre "olá"
    }

Neste trecho de &turtlescript;, o lado esquerdo do `ou` é avaliado como verdadeiro, enquanto o direito é avaliado como falso. Uma vez que um dos dois 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 olhada:

    $n = 1
    se nao ($n == 3) {
      mostre "olá"
    } senao {
      mostre "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 seção iremos explicar todos os comandos incorporados que podem ser usados no &kturtle;. Em alternativa, usando o `aprenda`, poderá criar os seus próprios comandos. Os comandos incorporados ficam realçados em azul escuro.

### Movendo a tartaruga

Existem vários comandos para mover a tartaruga pela tela.

parafrente (pf)

      parafrente X

  O `parafrente` move a tartaruga para a frente X pontos. Quando o traço está em baixo, a tartaruga irá deixar um rastro. O `parafrente` pode ser abreviado para `pf`.

paratrás (pt)

      paratrás X

  O `paratrás` move a tartaruga para trás X pontos. Quando o traço está em baixo, a tartaruga irá deixar um rastro. O `paratrás` pode ser abreviado para `pt`.

paraesquerda (pe)

      paraesquerda X

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

paradireita (pd)

      paradireita X

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

direção (dir)

      direção X

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

lerdireção

      lerdireção

  O `lerdireção` retorna a direção da tartaruga para um ângulo de X graus a contar do zero, onde zero é a direção quando a tartaruga está apontando para frente.

centralize

      centralize

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

vápara

      vápara X,Y

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

váparax

      váparax X

  Ao usar o comando `váparax`, a tartaruga irá mover-se X pontos a partir da esquerda da área de desenho, mantendo-se na mesma altura. O `váparax` pode ser abreviado como `vx`.

váparay

      váparay Y

  Ao usar o comando `váparay`, a tartaruga irá mover-se Y pontos a partir do topo da área de desenho, mantendo-se na mesma distância do lado esquerdo da área de desenho. O `váparay` pode ser abreviado como `vy`.

Ao usar os comandos `vápara`, `váparax`, `váparay` e `centralize` a tartaruga não irá desenhar uma linha, não importa se usado com `usenada` ou `uselápis`.

### Onde está a tartaruga?

Existem dois comandos que devolvem a posição da tartaruga na tela.

pegax

  `pegax` devolve o número em pontos a partir da esquerda da área de desenho até a posição atual da tartaruga.

pegay

  `pegay` devolve o número em pontos a partir do topo da área de desenho até a posição atual 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 seção iremos explicar estes comandos.

usenada (un)

      usenada

  O `usenada` 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 `uselápis`. O `usenada` pode ser abreviado para `un`.

uselápis (ul)

      uselápis

  O `uselápis` pressiona o 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 `usenada`. O `uselápis` pode ser abreviado para `ul`.

larguradolápis (ll)

      larguradolápis X

  A `larguradolápis` configura a espessura do traço para X pontos. A `larguradolápis` pode ser abreviado para `ll`.

cordolápis (cl)

      cordolápis R,G,B

  A `cordolápis` configura a cor do traço. A `cordolápis` recebe uma combinação de RGB como parâmetro. A `cordolápis` pode ser abreviado para `cl`.

### Comandos para controlar a área de desenho

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

tamanhodatela (tt)

      tamanhodatela X,Y

  Com o comando `tamanhodatela` você poderá alterar o tamanho da área de desenho. Ele recebe dois parâmetros (X e Y) de entrada, em que o X é a nova largura da área de desenho em pontos, e o Y é a nova altura da mesma área em pontos. O `tamanhodatela` pode ser abreviado para `tt`.

cordofundor (cf)

      cordofundo R,G,B

  A `cordofundo` define a cor da área de desenho. A `cordofundor` recebe uma combinação RGB como parâmetro. A `cordofundo` pode ser abreviado para `cf`.

### Comandos para limpar

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

limpetela (lt)

      limpetela

  Com o `limpetela`, você poderá limpar todos os desenhos da área de desenho. Todo 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.

apague

      apague

  O `apague` limpa tudo de forma mais abrangente que o comando `limpetela`. Depois de um comando `apague`, tudo fica como estava quando você iniciou o &kturtle;. A tartaruga é posicionada no meio do tela, a cor da área de desenho é branca e a tartaruga irá desenhar uma linha preta na área de desenho e o tamanho da tela é definido para 400 x 400 pontos.

### A tartaruga é uma imagem móvel

Muitas pessoas não sabem o que são as imagens móveis ('sprites' em inglês), daí uma breve explicação: as imagens móveis são pequenas imagens que podem percorrer a tela (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 atual do &kturtle; não suporta ainda o uso de imagens móveis além da tartaruga. Nas versões futuras, você poderá mudar a tartaruga para outra coisa que desejar.

apareça (ap)

      apareça

  O `apareça` torna a tartaruga visível de novo depois de ter ficado escondida. O `apareça` pode ser abreviado para `ap`.

desapareça (da)

      desapareça

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

### A tartaruga sabe escrever?

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

mostre

      mostre X

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

      $ano = 2003
      $autor = "Cies Breijs"
      mostre $autor + " iniciou o projeto do KTurtle em " + $ano + " e ainda continua gostando de trabalhar nele!"

tamanhodafonte

      tamanhodafonte X

  O `tamanhodafonte` configura o tamanho da letra que é usado pelo `mostre`. O `tamanhodafonte` recebe um parâmetro que deverá ser um número. O tamanho é definido em pontos.

### Comandos matemáticos

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

arredonda

      arredonda(x)

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

      mostre arredonda 10.8
      parafrente 20
      mostre arredonda 10.3
      parafrente 20

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

aleatório (al)

      aleatório X,Y

  O `aleatório` é um comando que recebe parâmetros e devolve resultados. Como parâmetros são necessários dois números, onde 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:

      repita 500 {
        $x = aleatório 1,20
        parafrente $x
        paraesquerda 10 - $x
      }

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

resto

      resto X,Y

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

raizquadrada

      raizquadrada X

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

pi

      pi

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

seno
, cosseno
, tangente

      seno X
      cosseno X
      tangente X

  Estes três comandos representam as conhecidas funções trigonométricas `seno`, `cosseno` e `tangente`. O argumento de entrada destes comandos, X, deve ser a medida de um ângulo em graus.

arcsin
, arccos
, arctan

      arcoseno X
      arcocosseno X
      arcotangente X

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

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

Um diálogo é uma pequena janela que fornece algum retorno ou pergunta por alguma entrada. O &kturtle; tem dois comandos para diálogos, chamados`mensagem` e o `perguntar`

mensagem

      mensagem X

  O comando `mensagem` recebe uma cadeia de caracteres como entrada. Exibe então uma janela que contém o texto da cadeia de caracteres.

      mensagem "Cies iniciou o projeto do KTurtle em 2003 e ainda continua gostando de trabalhar nele!"

perguntar

      perguntar X

  O `perguntar` recebe uma cadeia de caracteres como entrada. Ele mostra o texto da cadeia de caracteres em uma janela (de maneira similar ao mensagem), mostrando também um campo de entrada de texto. Após o usuário inserir um número ou uma cadeia de caracteres nesta caixa, o resultado poderá ser guardado numa variável ou passado como argumento a um comando. Por exemplo

      $entrada = perguntar "Qual o ano do seu nascimento?"
      $saida = 2003 - $entrada
      mostre "Em 2003, você tinha " + $saida + " anos em determinado momento."

  Quando um usuário cancelar a janela ou não inserir nada, 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 em 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.

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

    $x = 10
    $x = $x / 3
    mostre $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 que estar atribuídas para poderem ser usadas. Por exemplo, um:

    mostre $n

Irá resultar numa mensagem de erro.

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

    $a = 2004
    $b = 25

    # o próximo comando imprime "2029"
    mostre $a + $b
    paratrás 30
    # o próximo comando imprime "2004 mais 25 é igual a 2029"
    mostre $a + " mais " + $b + " é igual a " + ($a + $b)
    paratrás 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 `mostre` existe um comando `paratrás 30` no meio são executados. Os comentários antes dos comando `mostre` explicam o que ele está fazendo. O comando `paratrás 30` está ai para garantir que cada saída está numa nova linha. 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 se chama?"
    mostre "Olá " + $nome + "! Boa sorte ao 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 inspetor torna-se bastante útil. Ele mostra o conteúdo de todas as variáveis que estão sendo usadas atualmente.

## Controlando a execução

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

Os comandos de controle de execução são realçados em verde escuro e negrito. As chaves são frequentemente usadas juntamente com os controladores de execução e eles são realçados em preto.

### Fazendo a tartaruga esperar

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

aguarde

      aguarde X

  O `aguarde` faz a tartaruga esperar X segundos.

      repita 36 {
        parafrente 5
        paradireita 10
        aguarde 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 se

se

      se booleano { ... }

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

      $x = 6
      se $x > 5 {
        mostre "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`. Uma vez que a resposta a esta pergunta é verdadeira, o controlador de execução `se` irá permitir que o código entre chaves seja executado.

### Se não, em outras palavras: senão

senão

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

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

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

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

### O ciclo enquanto

enquanto

      enquanto booleano { ... }

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

      $x = 1
      enquanto $x < 5 {
        parafrente 10
        aguarde 1
        $x = $x + 1
      }

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

### O ciclo repita

repita

      repita número { ... }

  O controlador de execução `repita` funciona um pouco como o `enquanto`. A diferença é que o `repita` repete o código entre parênteses um número fixo de vezes, igual ao número dado.

### O ciclo para, um ciclo de contagem

para

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

  O ciclo `para` é um ciclo de contagem, &ie;, faz uma contagem para você. 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 {
        mostre $x * 7
        avancar 15
      }

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

  O passo padrão para um ciclo é 1, você pode usar um outro valor com

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

### Deixar um ciclo

quebre

      quebre

  Termina imediatamente o ciclo atual e transfere o controle para a instrução imediatamente após esse ciclo.

### Interrompe a execução do seu programa

sair

      sair

  Termina a execução do seu programa.

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

declara

      declara booleano

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

      $entrada = perguntar "Qual é a sua data de nascimento?"
      # o ano deve ser positivo
      declara $entrada
      > 0

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

O `aprenda`
é 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 é criado um novo comando.

    aprenda circunferência $x {
      repita 36 {
        parafrente $x
        paraesquerda 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:

    aprenda círculo $X {
      repita 36 {
        parafrente $X
        paraesquerda 10
      }
    }

    vápara 200,200
    círculo 20

    vápara 300,200
    círculo 40

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 seguinte exemplo, é criado um comando que desenha um retângulo.

    aprenda caixa $X, $Y {
      parafrente $Y
      paradireita 90
      parafrente $X
      paradireita 90
      parafrente $Y
      paradireita 90
      parafrente $X
      paradireita 90
    }

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