# Guía del lenguaje de programación &turtlescript;

Esta es la guía del lenguaje de programación &turtlescript; de &kturtle;. La primera sección de este capítulo está dedicada a aspectos relacionados con la gramática de los programas de &turtlescript;. La segunda sección trata exclusivamente los operadores aritméticos, los operadores lógicos (verdadero/falso) y los operadores de comparación. La tercera sección es, básicamente, una gran lista con todos las órdenes explicadas una a una. La cuarta sección explica cómo asignar valores a las variables. Finalmente, en la quinta sección se explica cómo organizar la ejecución de órdenes usando declaraciones de control de la ejecución y, en la sexta, cómo puedes crear tus propias órdenes con aprender.

## La gramática de &turtlescript;

Como ocurre con todos los idiomas, &turtlescript; consta de diferentes tipos de palabras y símbolos. En español distinguimos entre verbos (como «caminar» y «cantar») y sustantivos (como «hermana» o «casa») que se usan para distintos propósitos. &turtlescript; es un lenguaje de programación que se usa para dar instrucciones a la tortuga sobre lo que tiene que hacer.

En esta sección, se explican brevemente los distintos tipos de palabras que usa &turtlescript;. Se introduce lo que son comentarios, órdenes y los tres diferentes tipos de literales: números, cadenas y valores lógicos (verdadero/falso).

### Comentarios

Un programa consta de instrucciones (que es lo que se ejecuta) y de los denominados comentarios. Los comentarios no se ejecutan. Es decir, &kturtle; los ignora por completo cuando se ejecuta un programa. Los comentarios están ahí para que otros programadores puedan comprender mejor el programa. Todo lo que aparece después de un símbolo `#` se considera como un comentario en &turtlescript;. Un ejemplo es este programa que no hace nada:

    # este programa no hace nada, es solo un comentario

Es un programa inútil, pero permite explicar bien el asunto.

Los comentarios son especialmente útiles en el caso de programas más complejos, ya que permiten dar consejos a otros programadores. En el siguiente programa verás comentarios que se usan junto con la orden escribir.

    # este programa ha sido creado por Cies Breijs
    escribir "este texto aparecerá escrito en el lienzo"
    # la línea anterior no es un comentario, pero la siguiente sí que lo es:
    # escribir "¡este texto no aparecerá escrito!"

La primera línea describe el programa. La segunda línea es ejecutada por &kturtle;, que escribe en el lienzo `este texto aparecerá escrito en el lienzo`. La tercera línea es un comentario. Y la cuarta es un comentario que contiene una orden de &turtlescript;. Si de esta cuarta línea se eliminara el símbolo `#`, &kturtle; ejecutaría la orden de escribir. Lo que los programadores suelen decir es que la orden de escribir se ha «comentado».

Las líneas comentadas aparecen resaltadas en gris claro en el editor de código.

### Órdenes

Con las órdenes puedes decirle a la tortuga o a &kturtle; lo que tiene que hacer. Algunas órdenes necesitan un parámetro de entrada, mientras que otras devuelven un parámetro de salida.

    # avanzar es una orden que requiere de un parámetro de entrada, en este caso el número 100:
    avanzar 100

La primera línea es un comentario. La segunda línea contiene la orden `avanzar` y el número `100`. El número no es parte de la orden, es solo su parámetro de entrada.

Algunas órdenes, como &eg; `ir`, necesitan más de un valor de entrada. Si hay varios valores, hay que separarlos con el carácter `,` (coma).

Para una descripción detallada de todas las órdenes que reconoce &kturtle;, vaya aquí. Las órdenes integradas en &kturtle; aparecen resaltadas en azul oscuro.

### Números

Lo más probable es que ya sepa bastante de números. La forma en que &kturtle; usa los números no es muy diferente a cómo se hace en el idioma hablado o en las matemáticas.

Tenemos los llamados números naturales («`0`», «`1`», «`2`», «`3`», «`4`», «`5`», etc.), los enteros negativos («`-1`», «`-2`», «`-3`», etc.) y los números con decimales («`0,1`», «`3,14`», «`33,3333`», «`-5,05`», «`-1,0`», etc.). El carácter `,` (coma) se utiliza como separador.

Los números pueden utilizarse en conjunción con operadores aritméticos y operadores de comparación. También pueden guardarse en variables. Los números aparecen resaltados en rojo oscuro.

### Cadenas

Primero un ejemplo:

    escribir "Hola, soy una cadena."

En este ejemplo, `escribir` es una orden y `"Hola, soy una cadena."` es una cadena. Las cadenas comienzan y terminan con dobles comillas (`"`); es esto lo que hace que &kturtle; las identifique como tal.

Al igual que ocurre con los números, las cadenas también se pueden guardar en variables. Sin embargo, al contrario que los números, las cadenas no pueden usarse con operadores aritméticos o con operadores de comparación. Las cadenas aparecen resaltadas en rojo.

### Valores lógicos (verdadero/falso)

Solo hay dos valores lógicos: `verdadero` y `falso`, aunque en ocasiones se los denomina «sí» y «no» o «uno» y «cero». Pero en &turtlescript; siempre los llamaremos `verdadero` y `falso`. Fíjate en este código de &turtlescript;:

    $a = verdadero

Si le echas un vistazo al inspector verás que a la variable `$a` le corresponde el valor `verdadero` y que es de tipo lógico.

Con frecuencia, los valores lógicos son el resultado de un operador de comparación, como ocurre en el siguiente ejemplo:

    $respuesta = 10 > 3

A la variable `$respuesta` le corresponde el valor `verdadero` porque `10` es mayor que `3`.

Los valores lógicos `verdadero` y `falso` aparecen resaltados en rojo oscuro.

## Operadores aritméticos, lógicos y de comparación

Aunque el título de esta sección parezca complejo, verás como el contenido no es tan difícil como parece.

### Operadores aritméticos

Estos son los símbolos aritméticos básicos: suma (`+`), resta (`-`), multiplicación (`*`), división (`/`) y potenciación (`^`).

Este es un ejemplo de cómo usar los operadores aritméticos en &turtlescript;:

    $sumar = 1 + 1
    $restar = 20 - 5
    $multiplicar = 15 * 2
    $dividir = 30 / 30
    $potencia = 2 ^ 2

Los valores resultantes de estas operaciones aritméticos son asignados a variables. Puedes ver los valores resultantes en el inspector.

Si lo que quieres es realizar un cálculo simple, puedes hacer algo como esto:

    escribir 2010-12

Ahora veamos un ejemplo con paréntesis:

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

Primero se calculan las operaciones que están dentro de los paréntesis. En este ejemplo, primero se calcula 20 - 5; el resultado se multiplica por 2, luego se divide por 30 y, por último, se le suma 1. El resultado final es 2. Los paréntesis pueden también usarse en otros casos.

&kturtle; también tiene otras funciones aritméticas en forma de órdenes. Echa un vistazo a las siguientes órdenes, eso sí, teniendo en cuenta que se trata de operaciones avanzadas: redondear, aleatorio, raíz, pi, sen, cos, tan, arcsen, arccos, arctan.

### Operadores lógicos (verdadero/falso)

Mientras que los operadores aritméticos se usan principalmente con números, los operadores lógicos están pensados para usarse con valores lógicos (`verdadero` y `falso`). Hay solo tres operadores lógicos: `y`, `o` y `no`. El siguiente código de &turtlescript; muestra cómo usarlos:

    $y_1_1 = verdadero y verdadero  # -> verdadero
    $y_1_0 = verdadero y falso  # -> falso
    $y_0_1 = falso y verdadero  # -> falso
    $y_0_0 = falso y falso  # -> falso

    $o_1_1 = verdadero o verdadero # -> verdadero
    $o_1_0 = verdadero o falso  # -> verdadero
    $o_0_1 = falso o verdadero  # -> verdadero
    $o_0_0 = falso o falso  # -> falso

    $no_1 = no verdadero  # -> falso
    $no_0 = no falso  # -> verdadero

Puedes ver los valores resultantes en el inspector, aunque también se proporcionan pequeños comentarios al final de las líneas. `Y` resulta en `verdadero` solo si ambas partes son `verdaderos`. `O` resulta en `verdadero` si una de las dos partes es `verdadero`. Y `no` transforma `verdadero` en `falso` y`falso` en `verdadero`.

Los operadores lógicos aparecen resaltados en rosa.

#### Unos ejemplos más complejos:

Considera el siguiente ejemplo con `and`:

    $a = 1
    $b = 5
    si (($a < 10) y ($b == 5)) y ($a < $b) {
      escribir "hola"
    }

En este código de &turtlescript;, el resultado de los tres operadores de comparación están agrupados mediante los operadores `y`. Esto significa que los tres resultados tienen que ser iguales a «verdadero» para que se escriba la palabra «hola».

Un ejemplo con `o`:

    $n = 1
    si ($n < 10) o ($n == 2) {
      escribir "hola"
    }

En este código de &turtlescript;, la parte izquierda del operador `o` es «verdadera», mientras que la derecha es «falsa». Ya que una de las dos partes del operador `o` es «verdadera», el resultado del operador `o` también lo es. Esto quiere decir que se escribe la palabra «hola».

Finalmente, un ejemplo con `no`, que transforma «verdadero» en «falso» y «falso» en verdadero». Fíjate:

    $n = 1
    si no ($n == 3) {
      escribir "hola"
    } sino {
      escribir "no hola ;-)"
    }

### Operadores de comparación

Considera esta comparación sencilla:

    $respuesta = 10 > 3

Aquí, `10` se compara con `3` usando el operador «más grande que». El resultado de esta operación, es decir, el valor lógico `verdadero`, se guarda en la variable `$respuesta`.

Todos los números y variables (que contengan números) pueden compararse entre sí usando operadores de comparación.

Estos son todos los posibles operadores de comparación:

#### Tipos de preguntas

`$A == $B` | igual a | la respuesta es «verdadera» si `$A` es igual a `$B`
`$A != $B` | no igual a | la respuesta es «verdadera» si `$A` no es igual a `$B`
`$A > $B` | mayor que | la respuesta es «verdadera» si `$A` es mayor que `$B`
`$A < $B` | menor que | la respuesta es «verdadera» si `$A` es menor que `$B`
`$A >= $B` | mayor o igual que | la respuesta es «verdadera» si `$A` es mayor o igual que `$B`
`$A <= $B` | menor o igual que | la respuesta es «verdadera» si `$A` es menor o igual que `B`

Ten en cuenta que $A y $B tienen que ser números o variables que contengan números.

## Órdenes

Con las órdenes podemos decirle a la tortuga o a &kturtle; lo que tiene que hacer. Algunas órdenes requieren de parámetros de entrada, mientras que otras devuelven parámetros de salida. En esta sección se explican todas las órdenes integradas en &kturtle;. Alternativamente, puedes usar aprender para crear tus propias órdenes. Las órdenes que van a detallarse aquí aparecen resaltadas en azul oscuro.

### Cómo mover la tortuga

Hay varias órdenes que permiten mover la tortuga por la pantalla.

avanzar (avz)

      avanzar X

  `avanzar` desplaza la tortuga hacia delante X píxeles. Cuando el pincel está bajado, la tortuga deja a su paso un trazo. `avanzar` puede abreviarse como `avz`.

retroceder (ret)

      retroceder X

  `retroceder` hace retroceder la tortuga X píxeles. Cuando el pincel está bajado, la tortuga deja a su paso un trazo. `retroceder` puede abreviarse como `ret`.

izquierda (izq)

      izquierda X

  `izquierda` le ordena a la tortuga que rote X grados hacia la izquierda. `izquierda` puede abreviarse como `izq`.

derecha (der)

      derecha X

  `derecha` le ordena a la tortuga que rote X grados hacia la derecha. `derecha` puede abreviarse como `der`.

dirección (dir)

      dirección X

  `dirección` determina el ángulo de dirección de la tortuga, que será X grados contando a partir de cero. No se tiene en cuenta la dirección anterior de la tortuga. `dirección` puede abreviarse como `dir`.

obtenerdirección

      obtenerdirección

  `obtenerdirección` determina el ángulo de dirección de la tortuga, que será X grados contando a partir de cero.

centrar

      centrar

  `centrar` mueve la tortuga al centro del lienzo.

ir

      ir X; Y

  `ir` le ordena a la tortuga que se desplace a una posición concreta del lienzo. Esta posición está a X píxeles del margen izquierdo del lienzo y a Y píxeles del margen superior del lienzo.

irx

      irx X

  `irx` le ordena a la tortuga que vaya a una posición que está a X píxeles del margen izquierdo del lienzo, sin modificar su altura. `irx` se puede abreviar con `ix`.

iry

      iry Y

  `iry` le ordena a la tortuga que vaya a una posición que está a Y píxeles del margen superior del lienzo, sin modificar la distancia a la que se encuentre del margen izquierdo. `iry` se puede abreviar con `iy`.

Con las órdenes `ir`, `irx`, `iry` y `centrar`, la tortuga no dibuja ningún trazo, independientemente de que el pincel esté bajado o no.

### ¿Dónde está la tortuga?

Hay dos órdenes que devuelven la posición de la tortuga en la pantalla.

obtenerx

  `obtenerx` devuelve el número de píxeles desde el margen izquierdo del lienzo de la posición actual de la tortuga.

obtenery

  `obtenery` devuelve el número de píxeles desde el margen superior del lienzo de la posición actual del la tortuga.

### La tortuga tiene un pincel

La tortuga tiene un pincel que dibuja una línea cuando esta se desplaza. Hay varia órdenes que controlan el pincel. En esta sección se explican estas órdenes.

levantarpincel (lpl)

      levantarpincel

  `levantarpincel` alza el pincel del lienzo. Cuando el pincel está «levantado», la tortuga no deja ningún trazo cuando se desplaza. Consulta también `bajarpincel`. `levantarpincel` puede abreviarse como `lpl`.

bajarpincel (bpl)

      bajarpincel

  `bajarpincel` presiona el pincel sobre el lienzo. Cuando el pincel está «bajado», la tortuga deja un trazo a su paso. Vea también `levantarpincel`. `bajarpincel` puede abreviarse como `bpl`.

grosorpincel (gpl)

      grosorpincel X

  `grosorpincel` fija el grosor de la línea trazada por la tortuga en X píxeles. `grosorpincel` puede abreviarse como `gpl`.

colorpincel (cpl)

      colorpincel R;G;B

  `colorpincel` fija el color del pincel. El parámetro de entrada de `colorpincel` es una combinación RGB. `colorpincel` puede abreviarse como `cpl`.

### Órdenes que controlan el lienzo

Existen varias órdenes que controlan el lienzo.

tamañolienzo (tl)

      tamañolienzo X;Y

  Con la orden `tamañolienzo` puede modificar las dimensiones del lienzo. Requiere de X e Y como parámetros de entrada, donde X es el ancho en píxeles del nuevo lienzo, e Y es la altura del nuevo lienzo también en píxeles. `tamañolienzo` puede abreviarse como `tl`.

colorlienzo (cl)

      colorlienzo R;G;B

  `colorlienzo` define el color del lienzo. El parámetro de entrada de `colorlienzo` es una combinación RGB. `colorlienzo` puede abreviarse como `cl`.

### Comandos para limpiar

Existen dos comandos que permiten limpiar el lienzo después de un embrollo.

limpiar (lmp)

      limpiar

  Con `limpiar` puede borrar todos los dibujos del lienzo. Todo lo demás permanece: la posición y ángulo de la tortuga, el color del lienzo, la visibilidad de la tortuga y el tamaño del lienzo.

reiniciar

      reiniciar

  `reiniciar` borra todo de una forma más concienzuda que la orden `limpiar`. Después de una orden `reiniciar`, todo vuelve a como estaba cuando inició &kturtle;. La tortuga regresará a su posición en el centro del lienzo, el color del lienzo volverá a ser blanco, la tortuga dibujará de nuevo una línea negra en el lienzo y el tamaño del lienzo será 400x400 píxeles.

### La tortuga es un duendecillo

Antes de nada conviene explicar qué son los sprites: los duendecillos son pequeñas figuras que pueden desplazarse por la pantalla, como vemos con frecuencia en los videojuegos. Nuestra tortuga también es un duendecillo. Para obtener más información, consulta la entrada en el glosario correspondiente a los duendecillos.

A continuación, encontrarás una descripción detallada de todas las órdenes relacionadas con duendecillos.

(La versión actual de &kturtle; no admite otro duendecillo aparte de la tortuga. En las versiones futuras sí que podrá cambiar la tortuga por algo diseñado por usted mismo.)

mostrartortuga (mt)

      mostrartortuga

  `mostrartortuga` vuelve visible de nuevo a la tortuga después de haberla ocultado. `mostrartortuga` puede abreviarse como `mt`.

ocultartortuga (ot)

      ocultartortuga

  `ocultartortuga` oculta la tortuga. Puede usarse cuando la tortuga no quede bien en su dibujo. `ocultartortuga` puede abreviarse como `ot`.

### ¿La tortuga puede escribir?

La respuesta es «sí». La tortuga puede escribir: escribirá todo lo que le ordenes.

escribir

      escribir X

  La orden `escribir` le indica a la tortuga que escriba algo en el lienzo. El parámetro de entrada de `escribir` puede ser un número o una cadena. Puedes concatenar varios números y cadenas usando el símbolo «+». Aquí tienes un ejemplo sencillo:

      $año = 2003
      $autor = "Cies"
      escribir $autor + " comenzó a trabajar en el proyecto KTurtle en " + $año + " y todavía disfruta haciéndolo"

tamañoletra

      tamañoletra X

  `tamañoletra` fija el tamaño del tipo de letra que usa la orden `escribir`. El parámetro de entrada de `tamañoletra` tiene que ser un número. El tamaño viene determinado en píxeles.

### Órdenes aritméticas

Las siguientes son algunas de las órdenes aritméticas más avanzadas de &kturtle;.

redondear

      redondear(X)

  Permite `redondear` el número dado a su entero más cercano.

      escribir redondear(10,8)
      avanzar 20
      escribir redondear(10,3)

  Este código hace que la tortuga escriba los números 11 y 10.

aleatorio (alt)

      aleatorio X;Y

  `aleatorio` es una orden que requiere de parámetros de entrada y que devuelve un parámetro de salida. Como parámetros de entrada, necesita dos números, el primero (X) fija el valor mínimo del parámetro de salida, y el segundo (Y) fija su valor máximo. El parámetro de salida es un número elegido al azar que es igual o más grande que el valor mínimo, e igual o más pequeño que el valor máximo. Aquí tiene un ejemplo sencillo:

      repetir 500 {
        $x = aleatorio 1;20
        avanzar $x
        izquierda 10 - $x
      }

  Con la orden `aleatorio` puedes incorporar algo de caos a tu programa.

mod

      mod X,Y

  La orden `mod` devuelve el resto de la división del primer número entre el segundo número.

raíz

      raíz X

  La orden `raíz` sirve para calcular la raíz cuadrada de un número X.

pi

      pi

  Esta orden devuelve el valor del número Pi, `3,14159`.

sen
, cos
, tan

      sen X
      cos X
      tan X

  Estas tres órdenes representan las famosas funciones trigonométricas `sen`, `cos` y `tan`. El parámetro de entrada de estas tres órdenes, X, es un número.

arcsen
, arccos
, arctan

      arcsen X
      arccos X
      arctan X

  Estas tres órdenes son las funciones inversas de sen, cos y tan. El parámetro de entrada de estas órdenes, X, es un número.

### Entrada e información mediante diálogos

Un diálogo es una pequeña ventana emergente que proporciona información o que solicita un parámetro de entrada. &kturtle; tiene dos órdenes relacionadas con diálogos: `mensaje` y `preguntar`.

mensaje

      mensaje X

  La orden `mensaje` necesita una cadena como parámetro de entrada. Muestra una ventana emergente con el texto de la cadena.

      mensaje "Cies comenzó a trabajar en el proyecto KTurtle en 2003 y todavía disfruta haciéndolo"

preguntar

      preguntar X

  `preguntar` necesita una cadena como parámetro de entrada. Muestra el texto de la cadena en una ventana emergente (igual que hace mensaje) junto a un campo de entrada. Una vez que el usuario ha introducido un número o una cadena, el resultado puede guardarse en una variable o pasarse como un argumento a otra orden. Por ejemplo:

      $entrada = preguntar "¿En qué año naciste?"
      $salida = 2003 - $entrada
      escribir "En 2003 tenías " + salida + " años."

  Si el usuario cancela el diálogo de entrada o no introduce ningún valor, la variable queda vacía.

## Asignar valores a las variables

Antes de nada, echemos un vistazo a las variables, después veremos cómo asignarles valores.

Las variables son palabras que comienzan con un $; en el editor, aparecen resaltadas en color morado.

Las variables pueden contener un número, una cadena o un valor lógico (verdadero/falso). Con el signo de asignación (`=`) se da un valor a la variable, que mantendrá hasta que el programa termine de ejecutarse o hasta que se le asigne un nuevo valor.

Puedes usar las variables, una vez asignadas, de la misma forma que usarías su contenido. Por ejemplo, vea el siguiente código de &turtlescript;:

    $x = 10
    $x = $x / 3
    escribir $x

Primero, a la variable `$x` se le asigna el valor `10`. A continuación, a esta misma variable `$x` se le asigna su propio valor dividido por `3`, es decir, a la variable `$x` se da el valor `10 / 3`. Finalmente, se escribe `$x`. En las líneas dos y tres, comprobará que se usa la variable `$x` como si fuera un número.

A las variables hay que asignarles un valor para que puedan ser usadas. Por ejemplo:

    escribir $n

Este código da lugar a un mensaje de error.

Considera el siguiente código de &turtlescript;:

    $a = 2004
    $b = 25

    # la siguiente orden escribe "2029"
    escribir $a + $b
    retroceder 30
    # la siguiente orden escribe  "2004 más 25 igual a 2029"
    escribir $a + " más " + $b + " es igual a " + ($a + $b)

En las primeras dos líneas, a las variables `$a` y `$b` se les asigna los valores 2004 y 25. A continuación hay dos órdenes `escribir` con una orden `retroceder 30` en medio. Los comentarios que hay antes de las órdenes `escribir` explican lo que hacen. Como ves, puedes usar las variables de la misma forma que usarías sus contenidos. Es decir, puedes usarlas con cualquier operador o convertirlas en el parámetro de entrada de una orden.

Un nuevo ejemplo:

    $nombre = preguntar "¿Cuál es tu nombre?"
    escribir "¡Hola " + $nombre + "! Buena suerte con el aprendizaje del arte del programar..."

Este ejemplo es muy claro. De nuevo, aquí tiene como la variable `$name` se trata como si fuera una cadena.

Cuando estés usando variables, el inspector te puede ser de gran ayuda. Muestra el contenido de todas las variables que están en uso en un momento dado.

## Cómo controlar la ejecución

Los controladores de la ejecución permiten, tal como su nombre indica, controlar la ejecución.

Las órdenes de control de la ejecución aparecen resaltadas en negro y con un tipo de letra negrita. Las llaves, que se usan generalmente junto con los controladores de ejecución, aparecen resaltadas en negro.

### Cómo hacer que la tortuga espere

Si ya has programado algo en &kturtle;, te habrás dado cuenta de que la tortuga es muy rápida dibujando. Con esta orden puede hacer que la tortuga se detenga durante un tiempo determinado.

esperar

      esperar X

  `esperar` hace que la tortuga se detenga durante X segundos.

      repetir 36 {
        avanzar 5
        derecha 10
        esperar 0,5
      }

  Este código dibuja un circulo, pero la tortuga espera durante medio segundo antes de realizar el siguiente paso. Esto da la impresión de que la tortuga se está moviendo a cámara lenta.

### Ejecutar «si»

si

      si valor lógico { ... }

  El código que está entre llaves solo se ejecutará `si` el valor lógico es «verdadero».

      $x = 6
      si $x > 5 {
        escribir $x + " es mayor que cinco"
      }

  En la primer línea, a `$x` se le asigna el valor 6. En la segunda, se usa un operador de comparación para evaluar la condición `$x > 5`. Al cumplirse esta condición, es decir, al ser 6 mayor que 5, el controlador `si` permite que el código entre llaves se ejecute.

### Si no es así: «sino»

sino

      si valor lógico { ... } sino { ... }

  `sino` puede usarse en conjunción con el controlador `si`. El código que aparece entre llaves después de `sino` solo se ejecute si el valor lógico es «falso».

      reiniciar
      $x = 4
      si $x > 5 {
        escribir $x + " es mayor que cinco"
      }
      sino {
        escribir $x + " es menor que seis"
      }

  El operador de comparación evalúa la expresión `$x > 5`. Ya que en este caso 4 no es mayor que 5, el resultado es «falso». Esto quiere decir que se ejecuta el código que aparece entre llaves después de `sino`.

### El bucle «mientras»

mientras

      mientras valor lógico { ... }

  El controlador `mientras` actúa de forma similar a `si`. La diferencia es que `mientras` continúa ejecutando (en un bucle) el código que se encuentra entre llaves hasta que el valor lógico sea «falso».

      $x = 1
      mientras $x < 5 {
        avanzar 10
        esperar 1
        $x = $x + 1
      }

  En la primer línea, a `$x` se le asigna el valor 1. En la segunda, se evalúa la condición `$x < 5`. Mientras el resultado de esta condición sea «verdadero», el controlador `while` continúa ejecutando el código que se encuentra entre llaves, así hasta que la condición `$x < 5` sea «falsa». En este ejemplo, el código entre llaves se ejecuta 4 veces, porque cada vez que la quinta línea se ejecuta, al valor de `$x` se le suma 1.

### El bucle «repetir»

repetir

      repetir número { ... }

  El controlador `repetir` actúa de forma similar a `mientras`. La diferencia es que `repetir` continúa ejecutando (en un bucle) el código que se encuentra entre llaves tantas veces como le indica el número dado.

### El bucle «para», un bucle que cuenta

para

      para variable = número hasta número { ... }

  El bucle `para` es un «bucle que cuenta», &ie;, que lleva la cuenta por ti. El primer número asigna a la variable el valor del primer bucle. Con cada bucle, este número se incrementa hasta alcanzar el segundo número.

      para $x = 1 hasta 10 {
        escribir $x * 7
        avanzar 15
      }

  Cada vez que se ejecute el código entre llaves, la variable `$x` se incrementa en 1, así hasta que sea igual a 10. El código entre llaves escribe el valor de `$x` multiplicado por 7. Cuando el código termine de ejecutarse, verás en el lienzo la tabla de multiplicar del 7.

  El incremento predeterminado del bucle es 1, pero puedes usar otro valor con:

      para variable = número hasta número paso número { ... }

### Interrumpir un bucle

parar

      parar

  Interrumpe inmediatamente el bucle que se está ejecutando y transfiere el control a la primera línea de código después del bucle.

### Interrumpir la ejecución de tu programa

salir

      salir

  Detiene la ejecución de tu programa.

### Comprobación de afirmaciones en tiempo de ejecución

afirmar

      afirmarvalor lógico { ... }

  Se puede utilizar para razonar sobre la corrección del programa o de los datos de entrada

      $in = ask "What is your year of birth?"
      # el año debe ser positivo
      assert $in
      > 0

## Crea tus propias órdenes con «aprender»

`aprender` es especial ya que lo puedes usar para crear tus propias órdenes. La orden que crees puede admitir parámetros de entrada y devolver parámetros de salida. Veamos cómo se crea una nueva orden:

    aprender círculo $x {
      repetir 36 {
        avanzar $x
        izquierda 10
      }
    }

La nueva orden se denomina `círculo`. `círculo` necesita un parámetro de entrada para fijar el tamaño del círculo y no devuelve ningún parámetro de salida. A partir de ahora la orden `círculo` puede utilizarse como una orden normal en cualquier lugar del código. Mira este ejemplo:

    aprender círculo $x {
      repetir 36 {
        avanzar $x
        izquierda 10
      }
    }

    ir 200;200
    círculo 20

    ir 300;200
    círculo 40

En el próximo ejemplo, se crea una orden que devuelve un parámetro de salida:

    aprender facultad $x {
      $r = 1
      para $i = 1 hasta $x {
        $r = $r * $i
      }
      devolver $r
    }

    escribir facultad 5

En este ejemplo, se crea una nueva orden llamada `facultad`. Si el parámetro de entrada es `5`, entonces el parámetro de salida es `5*4*3*2*1`. Con `devolver` se define un parámetro de salida que se devuelve durante la ejecución.

Las órdenes pueden tener más de un parámetro de entrada. En el siguiente ejemplo se crea una orden que dibuja un rectángulo:

    aprender caja $x;$y {
      avanzar $y
      derecha 90
      avanzar $x
      derecha 90
      avanzar $y
      derecha 90
      avanzar $x
      derecha 90
    }

Ahora, si ejecuta `caja 50;100`, la tortuga dibujará una rectángulo en el lienzo.