Variables y constantes
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.Este código todavía no imprime nada.
mut vidas : int = 3
vidas -= 1
print(vidas)2 · CambiarlaEl mut dice que puede cambiar. vidas -= 1 le resta uno: ahora vale 2.2
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.Parse Error: Cannot assign to an immutable variable. Declare it with "mut" to make it mutable.
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.}Este código todavía no imprime nada.
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
module Variables
fn _ready() void { mut vidas : int = 3 print(vidas)}mut vidas : int = 3 tiene cuatro partes:
| Parte | Qué hace |
|---|---|
mut | Dice que el valor puede cambiar más adelante |
vidas | El nombre con el que lo usarás |
: int | El tipo: qué clase de valor guarda (aquí, un número entero) |
= 3 | El 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:
module Inmutable
fn _ready() void { nombre : String = "Gobi" nombre = "Bob"}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:
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)}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:
| Escribes | Es lo mismo que |
|---|---|
vidas -= 1 | vidas = vidas - 1 |
puntos += 10 | puntos = puntos + 10 |
velocidad *= 2.0 | velocidad = velocidad * 2.0 |
tiempo /= 2.0 | tiempo = tiempo / 2.0 |
module Cambiar
fn _ready() void { mut vidas : int = 3 mut velocidad := 4.5 vidas -= 1 velocidad *= 2.0 print($"vidas: {vidas}, velocidad: {velocidad}")}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 :::
module Constantes
MAX_VIDAS :: 3
fn _ready() void { mut vidas : int = MAX_VIDAS print(vidas)}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:
module Puntos
mut puntos : int = 0
fn sumar_puntos() void { puntos += 10}
fn _ready() void { sumar_puntos() sumar_puntos() print(puntos)}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
¿Qué imprime este código?
mut vidas := 3
vidas -= 1
vidas += 5
print(vidas)A este código le falta una palabra para que puntos pueda cambiar. ¿Cuál?
5
module Puntos
fn _ready() void {
puntos : int = 0
puntos += 5
print(puntos)
}module Puntos
fn _ready() void {
mut puntos : int = 0
puntos += 5
print(puntos)
}¿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.