Una función te permite agrupar código en una unidad reutilizable.
Consta de 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 función
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 por defecto, 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 única declaración de tipo.
import "fmt"
func PrintGreetingName(greeting, name string) {
fmt.Println(greeting + " " + name)
}
Parámetros frente a argumentos
Vamos a repasar 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 la invocamos.
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 devueltos
A los parámetros de la función les siguen cero o más valores devueltos, que también deben tener un tipo explícito.
Un único valor devuelto se escribe tal cual; varios valores devueltos se envuelven entre paréntesis.
Los valores se devuelven al código que hizo la llamada usando la palabra clave return.
Puede haber varias instrucciones return en una función.
La ejecución de la función termina en cuanto se topa con una de esas instrucciones return.
Si una función debe devolver varios valores, estos se separan por 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 sus parámetros 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 devueltos con nombre y retorno desnudo
Al igual que los parámetros, los valores devueltos pueden tener nombre de forma opcional.
Si se usan valores devueltos con nombre, una instrucción return sin argumentos devolverá esos valores.
Esto se conoce como 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 frente a paso por referencia
También es importante aclarar el concepto de paso por valor y paso por referencia.
Primero, vamos a aclarar 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.
En realidad, Go básicamente hace una copia del valor original para que la función solo modifique esa copia, también conocida como v.
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 pasan 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, lo que también se conoce como paso por referencia.
Punteros
Usamos un pointer para conseguir el paso por referencia.
Al pasar argumentos de tipo pointer a una función,
podríamos modificar los datos subyacentes que se le pasan en lugar de operar solo sobre una copia de esos datos.
Por ahora basta con saber que los tipos puntero se reconocen por el * que precede al 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 hay una sección dedicada en el temario que te ayudará a dominar los punteros.
Excepciones
Ten en cuenta que slices y maps son excepciones a la regla mencionada antes.
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 reflejarán en el slice o el map originales.
Ejercicio de aprendizaje
