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

Esta é a referência para o &turtlelang; do &kturtle;. Neste capítulo iremos abordar brevemente todos os tipos de instruções diferentes. Depois, serão explicados os comandos, um por um. Em seguida, serão explicados os recipientes, a matemática, as questões e os controladores de execução. Por último, será mostrado como criar os seus próprios comandos com o aprenda.

## Tipos diferentes de instruções

Como em qualquer linguagem, o &turtlelang; possui diferentes tipos de palavras e símbolos. Aqui as diferenças entre os tipos serão brevemente explanadas.

### Comandos

Usando comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados de entrada, enquanto outros fornecem resultados ou dados de saída.

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

Para uma ideia geral de todos os comandos que o &kturtle; suporta, vá para aqui.

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

Os números podem ser usados em cálculos matemáticos e perguntas. Eles também podem ser colocados em recipientes.

Os números ficam realçados em vermelho escuro no editor de código.

### 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 podem ser colocadas em recipientes. Porém, não podem ser usadas em cálculos matemáticos nem em questões.

As cadeias de caracteres ficam realçadas em vermelho no editor de código.

### Nomes

Ao usar a linguagem de programação &turtlelang;, você pode criar coisas novas. Se você escrever um programa, irá necessitar geralmente de recipientes e em alguns casos você precisará usar o comando aprenda para criar novos comandos. Ao criar um novo comando com o aprenda, você terá que especificar um nome.

Você poderá escolher qualquer nome, desde que ele não tenha já algum significado. Por exemplo, você não poderá chamar uma função de parafrente, uma vez que esse nome já é usado para um comando interno.

    # Aqui o parafrente é usado como um novo comando,
    # mas ele já tem um significado
    # assim isto irá resultar num erro:
    aprenda parafrente {
      mostre "isto é inválido"
    }

    # isto irá funcionar:
    aprenda meuparafrente {
      mostre "isto está correto"
    }

Os nomes só poderão conter letras, números e sublinhados (_). De qualquer forma, devem começar por uma letra. Os nomes dos recipientes devem começar com o prefixo de recipiente ($).

    # aqui o parafrente é usado como recipiente,
    # iniciando com o prefixo $, para que não entre
    # em conflito com o comando parafrente
    $parafrente = 20
    mostre $parafrente

Os recipientes ficam realçados em roxo no editor de código.

Por favor, leia a documentação sobre os recipientes e o comando aprenda para uma melhor explicação e mais exemplos.

### Atribuições

As atribuições são feitas com o símbolo `=`. Nas linguagens de programação é melhor ler o `=` simples não como um 'é igual a' mas sim como um 'ficar igual a'. O termo 'é igual a' é mais apropriado para o `==`, que é uma pergunta.

As atribuições são usadas normalmente por duas razões, (1) para adicionar conteúdo aos recipientes e (2) para modificar o conteúdo de um recipiente. Por exemplo:

    $x = 10
    # o recipiente x contém agora o número 10
    $W = "A minha idade é: "
    # o recipiente W contém agora o texto "A minha idade é: "
    # isto imprime o conteúdo dos recipientes 'W' e 'x' na área de desenho
    print $W + $x

Para mais exemplos, veja a seção que explica os recipientes.

### Símbolos matemáticos

O &kturtle; suporta todos os símbolos matemáticos básicos: a adição (`+`), a subtração (`-`), a multiplicação (`*`), a divisão (`/`) e os parênteses `(` e `)`.

Para uma explicação completa e mais exemplos, veja a seção de matemática.

### Perguntas

Nós podemos fazer perguntas simples onde a respostar será 'verdadeiro' ou 'falso'.

O uso de perguntas é extensivamente explicado na seção perguntas.

### Palavras de colagem de perguntas

As perguntas podem ser coladas juntas com o que se denomina por 'cola das perguntas'. As palavas de colagem são o `e`, o `ou` e uma palavra especial: o `não`.

A utilização da colagem de perguntas é explicada na seção de colagem de Perguntas.

### Comentários

Comentários são linhas que iniciam com um `#`. Por exemplo:

    # isto é um comentário!
    mostre "isto não é um comentário"
    # a linha anterior não é um comentário, mas a próxima é:
    # mostre "isto não é um comentário"

Nós podemos adicionar comentários ao código para nós mesmos ou para que alguém os leia. Comentários são usados para: (1) adicionar uma pequena descrição ao programa, (2) explanar como um pedaço do código funciona se ele for um pouco complicado, e (3) para 'comentar' linhas de código que devem ser (temporariamente) ignoradas (veja a última linha do exemplo).

As linhas comentadas ficam realçadas em cinza claro no editor de código.

## Comandos

Ao usar os comandos, você diz à tartaruga ou ao &kturtle; para fazer algo. Alguns comandos precisam de dados de entrada, enquanto outros fornecem resultados ou dados de saída. Nesta seção iremos explicar todos os comandos que podem ser usados no &kturtle;. Observe que todos os comandos internos que discutiremos aqui ficam realçados em azul no editor de código, para que isto possa ajudar você a distinguí-los.

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

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.

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.

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"
      print $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.

### Um comando que joga aos dados para você

Existe um comando que lança os dados para você, que se chama `aleatório` e é muito útil para alguns resultados inesperados.

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.

### 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 `pergunte`

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 Breijs iniciou o projeto do KTurtle em 2003 e ainda continua gostando de trabalhar nele!"

pergunte

      pergunte X

  O `pergunte` recebe uma cadeia de caracteres como entrada. Ele exibe uma janela de diálogo que contém o texto da cadeia de caracteres, tal como acontece no mensagem. Além disso, ele também exibe um campo de entrada de texto na janela. Através deste campo, o usuário poderá digitar um número ou uma cadeia de caracteres que poderá ser guardada num recipiente. Por exemplo

      $entrada = pergunte "Que idade você tem?"
      $saída = 2003 - 2009 + $entrada
      mostre "Em 2003, você tinha " + $saída + " anos em determinado momento."

  Quando um usuário cancelar a janela ou não digitar nenhuma informação, o recipiente fica vazio.

## Recipientes

Os recipientes são letras ou palavras que podem ser usadas pelo programador para guardar algum número ou algum texto. Os recipientes que contém um número chamam-se variáveis, enquanto que os que contém texto chamam-se cadeias de caracteres. Os recipientes podem ser identificados pelo caractere de recipiente $ que procede o seu uso.

Os recipientes que não são usados não contém nada. Por exemplo, um:

    mostre $N

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

### Variáveis: recipientes de números

Vamos começar com um exemplo:

    $x = 3
    mostre $x

Na primeira linha, a letra `x` passou a ser uma variável (um recipiente de números). Como você pode ver, o valor da variável `x` passou para 3. Na segunda linha, o valor é impresso.

Lembre-se que, se quisermos exibir um x, então devemos escrever

    mostre "x"

Isto foi fácil, mas agora há um exemplo um pouco mais difícil:

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

    # o próximo comando imprime "2029"
    mostre $C
    paratrás 30
    # o próximo comando imprime "2004 mais 25"
    mostre $A + " mais " + $B
    paratrás 30
    # o próximo comando imprime "1979"
    mostre $A - $B

Nas duas primeiras linhas, as variáveis `A` e `B` são definidas como sendo iguais a 2004 e 25. Na terceira linha, a variável `C` fica igual a `A + B`, o que dá 2029. O resto do exemplo consiste em 3 comandos `mostre` com `paratrás 30` no meio. O `paratrás 30` está lá para garantir que cada resultado fique numa linha diferente. Neste exemplo, você vê também que as variáveis podem ser usadas em cálculos matemáticos.

### Recipientes de texto (cadeias de caracteres)

No código do programa, o texto normal é iniciado e termina normalmente com aspas. Como já foi visto:

    mostre "Olá programador!"

O texto fica delimitado com as aspas. Estes pedaços de texto normal são chamados então de cadeias de caracteres.

As cadeias de caracteres também podem ser guardadas em recipientes assim como números. As cadeias de caracteres são parecidas com as variáveis. A maior diferença é que as cadeias de caracteres contém texto ao invés de números. Por este motivo, elas não podem ser usadas em cálculos matemáticos e perguntas. Um exemplo do uso de cadeias de caracteres:

    $x = "Olá "
    $nome = pergunte "Por favor digite o seu nome..."
    print $x + $nome + ", como você está?"

Na primeira linha, a cadeia de caracteres `x` fica igual a Olá . Na segunda linha, a cadeia de caracteres `nome` é configurada como o resultado do comando `pergunte`. Na terceira linha, o programa imprime uma composição de três cadeias de caracteres na área de desenho.

Este programa pede para inserir o seu nome. Quando você, por exemplo, inserir o nome José, o programa irá imprimir Olá José, como está?. Lembre-se que o sinal de mais (+) é o único símbolo matemático que você poderá usar com as cadeias de caracteres.

## Será que a tartaruga sabe fazer contas?

Sim, o &kturtle; sabe fazer contas para você. Você poderá adicionar (+), subtrair (-), multiplicar (*) e dividir (/). Aqui está um exemplo no qual iremos usar todas as operações:

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

Você sabe qual o valor de a, b, c e d? Por favor, repare o uso do símbolo de atribuição `=`.

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

    mostre 2004-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).

O &kturtle; tem recurso avançados de matemática. Ele conhece o número `pi` e funções trigonométricas como `seno`, `cosseno`, `tangente`, `arco-seno`, `arco-cosseno`, `arco-tangente` e as funções `raizquadrada` e `expoente`.

### Deixe a tartaruga arredondar seus números

Se você precisar de números inteiros nos cálculos, use esta função.

arredonda

      arredonda(x)

  `arredonda` o número fornecido para o inteiro mais próximo.

      mostre arredonda(10.8)
      parafrente 20
      mostre arredonda(10.3)
      parafrente 20

  Com este código a tartaruga exibirá os números 11 e 10.

## Fazendo perguntas, obtendo respostas...

O `se` e o `enquanto` são controladores de execução que iremos discutir na próxima seção. Nesta seção iremos usar o comando `se` para explicar as perguntas.

### Perguntas

Um exemplo simples de pergunta:

    $x = 6
    se $x > 5 {
      mostre "olá"
    }

Neste exemplo, a pergunta é `x > 5`, se a resposta a esta pergunta for verdadeiro, o código entre chaves será executado. As perguntas são uma parte importante da programação e são usadas geralmente em conjunto com os controladores de execução, como o `se`. Todos os números e variáveis (recipientes de números) poderão ser comparados uns com os outros com perguntas.

Aqui estão todas as perguntas possíveis:

#### Tipos de perguntas

`a == b` | é igual a | a resposta é verdadeiro se o `a` for igual ao `b`
`a != b` | não é igual a | a resposta é verdadeiro se o `a` não for igual ao `b`
`a > b` | maior que | a resposta é verdadeiro se o `a` for maior que o `b`
`a < b` | menor que | a resposta é verdadeiro se o `a` for menor que o `b`
`a >= b` | maior ou igual a | a resposta é verdadeiro se o `a` for maior ou igual ao `b`
`a <= b` | menor ou igual a | a resposta é verdadeiro se o `a` for menor ou igual ao `b`

### Colagem de perguntas

As perguntas também podem ser coladas umas às outras com palavras de colagem de perguntas onde, desta forma, algumas perguntas tornam-se uma pergunta maior.

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

Neste exemplo, a palavra de colagem `e` é usada para colar 2 perguntas (`a < b`, `b == 5`) juntas. Se um lado do `e` der uma resposta falso, a pergunta toda irá responder falso, porque, com a palavra de colagem `e`, ambos os lados precisam ser verdadeiro para que a resposta seja verdadeiro. Por favor não se esqueça de usar os parênteses ao redor das perguntas!

Aqui está um resumo esquemático, bem como uma explicação mais detalhada:

#### Palavras de colagem de perguntas

`e` | Ambos os lados têm que ser verdadeiro para a resposta ser verdadeiro
`ou` | Se um dos lados for verdadeiro a resposta é verdadeiro
`não` | Caso especial: só funciona com uma pergunta! Muda o 'verdadeiro' para 'falso' e o 'falso' para 'verdadeiro'.

#### e

Quando são coladas duas perguntas juntas com `e`, ambos os lados do `e` terão que ser 'verdadeiro' para que o resultado também seja 'verdadeiro'. Um exemplo:

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

Nestes exemplo, você poderá ver uma pergunta colada a outra pergunta também colada.

#### ou

Se uma das duas perguntas coladas juntas com o `ou` for 'verdadeiro', o resultado será também 'verdadeiro'. Um exemplo:

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

Neste exemplo, irá ver uma pergunta colada a outra pergunta, que também está colada.

#### não

O `não` é uma palavra de colagem especial porque somente funciona com uma pergunta de cada vez. O `não` muda 'verdadeiro' para 'falso' e 'falso' para 'verdadeiro'. Um exemplo:

    $a = 1
    $b = 5
    se não (($a < 10) e ($b == 5)) {
      mostre "olá"
    }
    senão
    {
      mostre "adeus ;-)"
    }

Neste exemplo a pergunta colada é 'verdadeiro' ainda que o `não` mude-a para 'falso'. Assim, no final, `"adeus ;-)"` é impresso na área de desenho.

## 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.

espere

      espere X

  O `espere` faz a tartaruga esperar X segundos.

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

se

      se pergunta { ... }

  O código que é colocado entre chaves somente será executado `se` a resposta à pergunta for verdadeiro. Por favor leia, para obter mais informações sobre perguntas, a seção de perguntas.

      $x = 6
      se $x > 5 {
        mostre "O x é maior que cinco!"
      }

  Na primeira linha, o `x` é definido como 6. Na segunda linha, a pergunta `x > 5` é feita. Uma vez que a resposta a esta pergunta é verdadeiro, 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 pergunta { ... } senão { ... }

  O `senão` pode ser usado em adição ao controlador de execução `se`. O código entre chaves após o `senão` só é executado se a resposta à pergunta feita é respondida como falso.

      apague
      $x = 4
      se $x > 5 {
        mostre "x é maior que cinco!"
      }
      senão
      {
        mostre "x é menor que seis!"
      }

  A pergunta feita é se `x` é maior que 5. Uma vez que `x` é definido como 4 na primeira linha a resposta à questão é falso. Isto significa que o código entre chaves após o `senão` será executado.

### O ciclo "enquanto"

enquanto

      enquanto pergunta { ... }

  O controlador de execução `enquanto` é um pouco parecido com o `se`. A diferença é que o `enquanto` fica repetindo (em ciclo) o código entre os chaves até que a resposta à pergunta seja falso.

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

  Na primeira linha o `x` é definido como 1. Na segunda linha a pergunta `x < 5` é feita. Uma vez que a resposta é verdadeiro o controlador de execução `enquanto` inicia a execução do código entre chaves até que a resposta à pergunta seja falso. Neste caso o código entre chaves será executado 4 vezes, porque cada vez que a quinta linha é executada o `x` é aumentado em 1.

### O ciclo "repita"

repita

      repita número { ... }

  O controlador de execução `repita` é um pouco parecido com o `enquanto`. A diferença é que o `repita` fica repetindo (em ciclo) o código entre chaves para um dado número.

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

para

      para ponto inicial até ponto final { ... }

  O ciclo `para` é um ciclo de contagem, &ie;, faz um contador para você.

      para $x = 1 até 10 {
        mostre $x * 7
        parafrente 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 que este programa terminar a sua execução, você irá ver a tabuada do 7 na área de desenho.

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

      para ponto inicial até ponto final passo tamanho do passo { ... }

### Deixar um ciclo

quebre

      quebre

  Termina o ciclo atual imediatamente e transfere o controle da instrução imediatamente seguindo o ciclo

### Para a tartaruga

sair

      sair

  Finaliza a execução do código.

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

O `aprenda`
é um comando muito especial, porque ele é usado para criar seus próprios comandos. O comando que você criar pode ter valores de entrada e retornar valores de saída. Vamos dar uma olhada em como um novo comando é criado:

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

O novo comando é chamado `círculo`. `círculo` recebe um valor de entrada, um número, para configurar o tamanho do círculo. `círculo` não retorna nenhum valor de saída. O comando `círculo` pode agora ser usado como um comando normal no resto do código. 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, um comando com valor de retorno é criado.

    apague

    aprenda multiplicaPorSi $n {
      $r = $n * $n
      retorne $r
    }
    $i = pergunte "Por favor digite um número e pressione OK"
    mostre $i + " multiplicado por ele mesmo é: " + multiplicaPorSi $i

Neste exemplo um novo comando chamado `multiplicaPorSi` é criado. A entrada deste comando é multiplicada por ela mesmo e então retornada, usando o comando `retorne`. O comando `retorne` é a maneira de retornar um valor a partir de uma função que você criou.

Os comandos podem ter mais de um valor de entrada. No próximo exemplo, um comando que desenha um retângulo é criado.

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

Agora você pode executar `caixa 50, 100` e a tartaruda irá desenhar um retângulo na área de desenho.