Ir al contenido
Descargar
Curso de Grost

Funciones

Módulo 1 · Primeros pasosLección 4 de 208 min de lectura3 retos
main.groPaso 1 de 4
fn sumar(a: int, b: int) int {
  return a + b
}1 · Definir una funciónUna función es código con nombre que puedes usar todas las veces que quieras. a y b son sus parámetros: los datos que recibe.
Output

Este código todavía no imprime nada.

main.groPaso 2 de 4
fn sumar(a: int, b: int) int {
  return a + b
}

fn _ready() void {
  print(sumar(2, 3))2 · Devolver un valorEl int tras los paréntesis es lo que devuelve. return entrega el resultado a quien la llamó.}
Output
5
main.groPaso 3 de 4
fn saludar(quien: String) void {
  print($"¡Hola, {quien}!")
}

fn _ready() void {
  saludar("Gobi")3 · Sin resultado: voidvoid significa que no devuelve nada: la función solo hace algo, en este caso saludar.}
Output
¡Hola, Gobi!
main.groPaso 4 de 4
fn danio(base: int, critico: bool = false) int {
  return base * 2 if critico else base
}

fn _ready() void {
  print(danio(10))
  print(danio(10, critico = true))4 · Valor por defectoUn parámetro puede tener un valor por defecto. Al llamar, puedes nombrarlo para que se lea mejor.}
Output
10
20
También con las flechas ← →

Ya llevas un rato usando funciones: print, int(), to_upper()… y escribiendo una, _ready. Ahora vas a crear las tuyas. Una función sirve para dos cosas: no repetir código y ponerle nombre a lo que hace, para que se entienda al leerlo.

Crear una función

main.gro
module Funciones
fn sumar(a: int, b: int) int {
return a + b
}
fn _ready() void {
print(sumar(2, 3))
print(sumar(10, -4))
}
Output5 6
ParteQué es
fnDice que empieza una función
sumarSu nombre
(a: int, b: int)Sus parámetros: los datos que recibe, cada uno con su tipo
intEl tipo del valor que devuelve
{ return a + b }Su cuerpo: lo que hace al llamarla

Al escribir sumar(2, 3) la llamas: a vale 2, b vale 3, y el return devuelve 5 al sitio desde donde la llamaste.

Devolver o no devolver

return termina la función y entrega un valor. Si la función no tiene nada que entregar, su tipo es void:

main.gro
module Saludar
fn saludar(quien: String) void {
print($"¡Hola, {quien}!")
}
fn _ready() void {
saludar("Gobi")
saludar("mundo")
}
Output¡Hola, Gobi! ¡Hola, mundo!
¿Por qué _ready es void?

Porque Gobu la llama para que haga cosas al empezar, no para pedirle un resultado. Lo mismo pasa con las demás funciones que llama el motor, como _process(delta), que se ejecuta en cada frame del juego.

Valores por defecto y argumentos con nombre

Un parámetro puede llevar un valor por defecto: si al llamar no lo das, usa ese. Y al llamar puedes nombrar un argumento, lo que te deja saltarte los que vienen antes:

main.gro
module Danio
fn danio(base: int, multiplicador: float = 1.0, critico: bool = false) float {
return base * multiplicador * (2.0 if critico else 1.0)
}
fn _ready() void {
print(danio(10))
print(danio(10, 1.5))
print(danio(10, critico = true))
}
Output10.0 15.0 20.0

danio(10, critico = true) se lee mucho mejor que danio(10, 1.0, true): no hace falta ir a mirar qué significa ese true.

Una función dentro de otra

Lo que devuelve una función se puede usar directamente, incluso como argumento de otra:

main.gro
module Doble
fn doble(n: int) int {
return n * 2
}
fn _ready() void {
print(doble(doble(3)))
}
Output12

Grost resuelve primero lo de dentro: doble(3) da 6, y doble(6) da 12.

Cuando no necesitas el resultado

Si una función devuelve algo y no lo usas, el editor te avisa: a veces es un despiste. Cuando lo haces a propósito, díselo con _ =:

main.gro
module Descartar
fn sumar(a: int, b: int) int {
return a + b
}
fn _ready() void {
_ = sumar(1, 2) # la función se ejecuta, pero no necesito el resultado
print("listo")
}
Outputlisto

Del mismo modo, un parámetro que no usas se marca empezando su nombre por _, como _otro. Lo vas a ver en funciones que llama el motor y que te dan más datos de los que necesitas.

Hora de practicar

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

¿Qué imprime este código?

main.gro
fn doble(n: int) int {
  return n * 2
}

fn _ready() void {
  print(doble(doble(3)))
}
doble(3) da 6 y doble(6) da 12.
Resuelve primero el doble(3) de dentro.
Reto 2 de 3sin resolver

Completa la función triple: recibe un int y devuelve otro int, el triple.

Salida esperada
12
main.gro
fn triple(n: int)  {
   n * 3
}

fn _ready() void {
  print(triple(4))
}
El primer hueco es el tipo que devuelve. El segundo, la palabra que entrega el resultado.
Solución:
main.gro
fn triple(n: int) int {
  return n * 3
}

fn _ready() void {
  print(triple(4))
}
Reto 3 de 3sin resolver

¿Qué imprime este código?

main.gro
fn saludo(nombre: String = "jugador") String {
  return $"Hola, {nombre}"
}

fn _ready() void {
  print(saludo())
}
Como no le pasas nada, nombre usa su valor por defecto: "jugador".
Mira qué pasa con un parámetro que tiene un valor por defecto cuando no se lo das.