Una función te permite agrupar código en una unidad reutilizable.
Consiste en la palabra clave func, el nombre de la función y una lista separada por comas de cero o más parámetros y tipos entre paréntesis.
Parámetros de funciones
Todos los parámetros deben tener un tipo explícito; no hay inferencia de tipos para los parámetros.
Los parámetros no tienen valores predeterminados, así que todos los parámetros de una función son obligatorios.
import "fmt"
// No parameters
func PrintHello() {
fmt.Println("Hello")
}
// Two parameters
func PrintGreetingName(greeting string, name string) {
fmt.Println(greeting + " " + name)
}
Los parámetros del mismo tipo se pueden declarar juntos, seguidos de una sola declaración de tipo.
import "fmt"
func PrintGreetingName(greeting, name string) {
fmt.Println(greeting + " " + name)
}
Parámetros vs. argumentos
Cubramos rápidamente dos términos que a menudo se confunden: parameters y arguments.
Los parámetros de una función son los nombres definidos en la firma de la función, como greeting y name en la función PrintGreetingName de arriba.
Los argumentos de una función son los valores concretos que se pasan a los parámetros de la función cuando invocamos la función.
Por ejemplo, en el ejemplo de abajo, "Hello" y "Katrina" son los argumentos que se pasan a los parámetros greeting y name:
PrintGreetingName("Hello", "Katrina")
Valores de retorno
A los parámetros de la función les siguen cero o más valores de retorno, que también deben tener un tipo explícito.
Los valores de retorno únicos se dejan sin paréntesis; los múltiples se envuelven entre paréntesis.
Las funciones devuelven valores al código que las llama usando la palabra clave return.
Puede haber varias sentencias return en una función.
La ejecución de la función termina en cuanto llega a una de esas sentencias return.
Si una función debe devolver varios valores, estos se separan con comas.
func Hello(name string) string {
return "Hello " + name
}
func HelloAndGoodbye(name string) (string, string) {
return "Hello " + name, "Goodbye " + name
}
Invocar funciones
Para invocar una función, se especifica el nombre de la función y se pasan argumentos para cada uno de los parámetros de la función entre paréntesis.
import "fmt"
// No parameters, no return value
func PrintHello() {
fmt.Println("Hello")
}
// Called like this:
PrintHello()
// One parameter, one return value
func Hello(name string) string {
return "Hello " + name
}
// Called like this:
greeting := Hello("Dave")
// Multiple parameters, multiple return values
func SumAndMultiply(a, b int) (int, int) {
return a+b, a*b
}
// Called like this:
aplusb, atimesb := SumAndMultiply(a, b)
Valores de retorno con nombre y retorno desnudo
Además de los parámetros, los valores de retorno también pueden tener nombre.
Si se usan valores de retorno con nombre, una sentencia return sin argumentos devolverá esos valores.
Esto se conoce como un retorno «desnudo».
func SumAndMultiplyThenMinus(a, b, c int) (sum, mult int) {
sum, mult = a+b, a*b
sum -= c
mult -= c
return
}
Paso por valor vs. paso por referencia
También es importante aclarar el concepto de pasar por valor y pasar por referencia.
Primero, aclaremos el paso por valor.
En el ejemplo de abajo, cuando pasamos la variable val a la función MultiplyByTwo, pasamos una copia de val.
Por eso, newVal tiene el valor actualizado 4, pero la variable original val sigue siendo 2.
Detrás de escena, Go hace básicamente una copia del valor original para que solo esta copia, también conocida como v, sea la que modifica la función.
val := 2
func MultiplyByTwo(v int) int {
v = v * 2
return v
}
newVal := MultiplyByTwo(val)
// newval is 4, val is still 2 because only a copy of its value was passed into the function
En sentido estricto, en Go todos los argumentos se pasan por valor, es decir, se hace una copia del valor o de los datos que se le proporcionan a la función.
Pero si no quieres hacer una copia de los datos que se pasan a una función y quieres cambiar esos datos dentro de la función, entonces deberías usar pointers como argumentos, también conocido como paso por referencia.
Punteros
Usamos un pointer para lograr el paso por referencia.
Al pasar argumentos pointer a una función, podemos modificar los datos subyacentes que se pasan a la función en lugar de operar solo sobre una copia de los datos.
Por ahora, basta con saber que los tipos puntero se reconocen por el * delante del tipo en la firma de la función.
func HandlePointers(x, y *int) {
// Some logic to handle integer values referenced by pointers x and y
}
Si el concepto de pointer te resulta confuso, no te preocupes.
Más adelante en el temario tenemos una sección dedicada a ayudarte a dominar los punteros.
Excepciones
Ten en cuenta que slices y maps son excepciones a la regla mencionada arriba.
Cuando pasamos un slice o un map como argumentos a una función, se tratan como tipos puntero aunque no haya un * explícito en el tipo.
Esto significa que si pasamos un slice o un map a una función y modificamos sus datos subyacentes, los cambios se verán reflejados en el slice o map original.
Ejercicio de aprendizaje
