Ir al contenido
Descargar
Curso de Grost

Variables y constantes

Módulo 1 · Primeros pasosLección 2 de 207 min de lectura3 retos
main.groPaso 1 de 4
mut vidas : int = 31 · Una variableUna variable guarda un valor con un nombre. Esta se llama vidas, es un int (un número entero) y empieza valiendo 3.
Output

Este código todavía no imprime nada.

main.groPaso 2 de 4
mut vidas : int = 3
vidas -= 1
print(vidas)2 · CambiarlaEl mut dice que puede cambiar. vidas -= 1 le resta uno: ahora vale 2.
Output
2
main.groPaso 3 de 4
nombre : String = "Gobi"
nombre = "Bob"3 · Sin mut no cambiaSin mut, el valor queda fijo. Si intentas cambiarlo, Grost te avisa antes de ejecutar nada.
Output
Parse Error: Cannot assign to an immutable variable. Declare it with "mut" to make it mutable.
main.groPaso 4 de 4
MAX_VIDAS :: 3

fn _ready() void {
  mut vidas : int = MAX_VIDAS4 · Una constanteCon :: creas una constante: un valor fijo que se conoce antes de empezar el juego. Se suelen escribir en MAYÚSCULAS.}
Output

Este código todavía no imprime nada.

También con las flechas ← →

Un juego está lleno de datos que hay que recordar: cuántas vidas quedan, cuántas monedas llevas, cómo se llama el jugador. Para recordarlos, los guardas en variables.

Guardar un valor

main.gro
module Variables
fn _ready() void {
mut vidas : int = 3
print(vidas)
}
Output3

mut vidas : int = 3 tiene cuatro partes:

ParteQué hace
mutDice que el valor puede cambiar más adelante
vidasEl nombre con el que lo usarás
: intEl tipo: qué clase de valor guarda (aquí, un número entero)
= 3El valor con el que empieza

Después, cada vez que escribes vidas, Grost usa el valor que tenga en ese momento.

¿Puedo llamar a una variable como quiera?

Casi: el nombre puede llevar letras, números y _, pero no puede empezar por un número ni llevar espacios. Lo normal es escribirlo en minúsculas y separar palabras con _, como vidas_extra. Elige nombres que digan qué guardan: vidas se entiende, v no.

Con mut o sin mut

En Grost, una variable no puede cambiar salvo que lo digas con mut. Si te olvidas, el editor te lo señala antes de ejecutar:

main.gro
module Inmutable
fn _ready() void {
nombre : String = "Gobi"
nombre = "Bob"
}
OutputParse Error: Cannot assign to an immutable variable. Declare it with "mut" to make it mutable.

Puede parecer una molestia, pero ayuda: cuando ves una variable sin mut, sabes que su valor no cambia en ningún sitio, y te ahorras buscar quién la toca.

Que Grost deduzca el tipo

Si escribes := en lugar de : tipo =, Grost mira el valor y deduce el tipo él solo:

main.gro
module Deducir
fn _ready() void {
velocidad := 4.5 # 4.5 tiene decimales: es un float
nombre := "Gobi" # entre comillas: es un String
print(nombre, " corre a ", velocidad)
}
OutputGobi corre a 4.5

La variable sigue teniendo su tipo: velocidad es un float para siempre, aunque no lo hayas escrito.

Cambiar una variable

Para darle un valor nuevo se usa =. Y para cambiarlo a partir del que ya tiene hay atajos:

EscribesEs lo mismo que
vidas -= 1vidas = vidas - 1
puntos += 10puntos = puntos + 10
velocidad *= 2.0velocidad = velocidad * 2.0
tiempo /= 2.0tiempo = tiempo / 2.0
main.gro
module Cambiar
fn _ready() void {
mut vidas : int = 3
mut velocidad := 4.5
vidas -= 1
velocidad *= 2.0
print($"vidas: {vidas}, velocidad: {velocidad}")
}
Outputvidas: 2, velocidad: 9.0

Constantes

Algunos valores no cambian nunca y se conocen antes de que empiece el juego: el número máximo de vidas, la velocidad del jugador. Para eso están las constantes, que se declaran con :::

main.gro
module Constantes
MAX_VIDAS :: 3
fn _ready() void {
mut vidas : int = MAX_VIDAS
print(vidas)
}
Output3

Se escriben en MAYÚSCULAS para distinguirlas de un vistazo. Si mañana quieres que el jugador tenga 5 vidas, lo cambias en un solo sitio.

Variables del script

Una variable declarada dentro de una función solo existe mientras esa función se ejecuta. Si la declaras fuera, al nivel del script, la comparten todas sus funciones y conserva su valor entre una llamada y otra:

main.gro
module Puntos
mut puntos : int = 0
fn sumar_puntos() void {
puntos += 10
}
fn _ready() void {
sumar_puntos()
sumar_puntos()
print(puntos)
}
Output20

sumar_puntos() es una función que hemos escrito nosotros; _ready la usa dos veces. En la lección de funciones verás cómo se crean.

Hora de practicar

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

¿Qué imprime este código?

main.gro
mut vidas := 3
vidas -= 1
vidas += 5
print(vidas)
3 - 1 = 2, y 2 + 5 = 7.
Ve línea a línea: empieza en 3, luego le restas uno y después le sumas cinco.
Reto 2 de 3sin resolver

A este código le falta una palabra para que puntos pueda cambiar. ¿Cuál?

Salida esperada
5
main.gro
module Puntos

fn _ready() void {
   puntos : int = 0
  puntos += 5
  print(puntos)
}
Es la palabra que dice que una variable puede cambiar. Tiene tres letras.
Solución:
main.gro
module Puntos

fn _ready() void {
  mut puntos : int = 0
  puntos += 5
  print(puntos)
}
Reto 3 de 3sin resolver

¿Qué línea declara una constante?

:: crea una constante. Las otras tres son variables: con mut puede cambiar; sin mut queda fija, pero no deja de ser una variable.
Las constantes usan dos veces el mismo signo.