Ir al contenido
Descargar
Curso de Grost

Decidir y repetir

Módulo 1 · Primeros pasosLección 5 de 209 min de lectura4 retos
main.groPaso 1 de 4
vidas : int = 0
if vidas <= 0 {
  print("fuera")1 · Decidir con ifif ejecuta su bloque solo si la condición se cumple. Si no, se ejecuta el del else.} else {
  print("sigue")
}
Output
fuera
main.groPaso 2 de 4
for i : int in range(3) {2 · Repetir con forfor repite el bloque una vez por cada valor. range(3) da 0, 1 y 2: empieza en 0 y no llega al 3.  print(i)
}
Output
0
1
2
main.groPaso 3 de 4
mut combustible : int = 3
while combustible > 0 {
  print($"combustible {combustible}")
  combustible -= 13 · Repetir mientraswhile repite mientras la condición sea verdadera. Si nunca deja de serlo, el bucle no termina nunca.}
Output
combustible 3
combustible 2
combustible 1
main.groPaso 4 de 4
fn tirada(dado: int) String {
  match dado {
    1: {
      return "fallo"
    }
    6: {
      return "¡crítico!"
    }
    _: {4 · Elegir con matchmatch compara un valor con varios casos y ejecuta el que coincide. _ es el caso para todo lo demás.      return "normal"
    }
  }
}
Output

Este código todavía no imprime nada.

También con las flechas ← →

Hasta ahora tu código se ejecutaba de arriba abajo, una línea tras otra. Pero un juego tiene que decidir (¿le quedan vidas al jugador?) y repetir (crear diez enemigos, revisar cada moneda). En esta lección aprendes las dos cosas.

Decidir con if

main.gro
module Si
fn estado(vidas: int) String {
if vidas <= 0 {
return "fuera"
} elif vidas == 1 {
return "en peligro"
} else {
return "bien"
}
}
fn _ready() void {
print(estado(0))
print(estado(1))
print(estado(3))
}
Outputfuera en peligro bien
  • if condición { ... } ejecuta el bloque solo si la condición es true.
  • elif (“si no, si…”) prueba otra condición cuando la anterior no se cumplió. Puedes poner tantos como quieras.
  • else recoge todo lo que no cumplió ninguna. Es opcional.

Grost mira las condiciones en orden y ejecuta solo el primer bloque que se cumple.

Repetir con for

for recorre una serie de valores y ejecuta el bloque una vez con cada uno:

main.gro
module Bucles
fn _ready() void {
for i : int in range(3) {
print(i)
}
for i : int in range(10, 0, -5) {
print(i)
}
}
Output0 1 2 10 5
EscribesDa
range(3)0, 1, 2
range(2, 5)2, 3, 4: desde el primero, sin llegar al segundo
range(10, 0, -5)10, 5: el tercero es el paso, aquí hacia atrás

i es una variable nueva que en cada vuelta toma el siguiente valor. Con for también puedes recorrer listas, como las de enemigos o monedas; lo verás en el módulo de colecciones.

Repetir mientras: while y loop

while repite mientras su condición sea verdadera. Es útil cuando no sabes cuántas vueltas van a hacer falta:

main.gro
module Mientras
fn _ready() void {
mut combustible : int = 3
while combustible > 0 {
print($"combustible {combustible}")
combustible -= 1
}
}
Outputcombustible 3 combustible 2 combustible 1

loop repite para siempre, hasta que lo cortas con break:

main.gro
module Repetir
fn _ready() void {
mut intentos : int = 0
loop {
intentos += 1
if intentos == 3 {
break
}
}
print(intentos)
}
Output3

Saltar y salir: continue y break

Dentro de cualquier bucle:

  • continue salta al principio de la siguiente vuelta.
  • break sale del bucle del todo.
main.gro
module Romper
fn _ready() void {
for i : int in range(10) {
if i == 1 {
continue
}
if i == 4 {
break
}
print(i)
}
}
Output0 2 3

El 1 se salta por el continue, y al llegar al 4 el break termina el bucle, así que del 5 al 9 ni se prueban.

Elegir entre muchos casos: match

Cuando comparas un mismo valor con muchas posibilidades, match queda más claro que una cadena de elif:

main.gro
module Dado
fn tirada(dado: int) String {
match dado {
1: {
return "fallo"
}
2, 3: {
return "baja"
}
6: {
return "¡crítico!"
}
_: {
return "normal"
}
}
}
fn _ready() void {
print(tirada(1))
print(tirada(3))
print(tirada(5))
print(tirada(6))
}
Outputfallo baja normal ¡crítico!
  • Cada caso es un valor, dos puntos y su bloque.
  • 2, 3: vale para cualquiera de los dos.
  • _: es el comodín: recoge lo que no coincidió con ningún otro caso. Ponlo el último.

Hora de practicar

Retos: 0/4 resueltosSe guardan en este navegador
Reto 1 de 4sin resolver

¿Qué imprime este código?

main.gro
for i : int in range(2, 5) {
  print(i)
}
range(2, 5) da 2, 3 y 4: el 5 no entra.
range empieza en el primer número y se detiene antes del segundo.
Reto 2 de 4sin resolver

Haz que el mensaje salga solo cuando queda una vida.

Salida esperada
¡Última vida!
main.gro
fn _ready() void {
  vidas : int = 1
   vidas == 1 {
    print("¡Última vida!")
  }
}
Es la palabra que ejecuta un bloque solo si se cumple una condición.
Solución:
main.gro
fn _ready() void {
  vidas : int = 1
  if vidas == 1 {
    print("¡Última vida!")
  }
}
Reto 3 de 4sin resolver

¿Qué imprime este código?

main.gro
mut total := 0
for i : int in range(5) {
  if i == 3 { break }
  total += i
}
print(total)
Suma 0, 1 y 2; cuando i llega a 3, el break sale del bucle antes de sumarlo. 0 + 1 + 2 = 3.
Apunta el valor de total en cada vuelta y fíjate en qué vuelta se ejecuta el break.
Reto 4 de 4sin resolver

Completa el match: el 0 da cero y cualquier otro número, otro.

Salida esperada
cero
otro
main.gro
fn tipo(n: int) String {
   n {
    0: {
      return "cero"
    }
    : {
      return "otro"
    }
  }
}

fn _ready() void {
  print(tipo(0))
  print(tipo(7))
}
El primer hueco es la palabra que empieza la comparación de casos. El segundo, el comodín.
Solución:
main.gro
fn tipo(n: int) String {
  match n {
    0: {
      return "cero"
    }
    _: {
      return "otro"
    }
  }
}

fn _ready() void {
  print(tipo(0))
  print(tipo(7))
}