Go: declarando funciones (3)

 Continuando con lo expuesto en el anterior post sobre Go(lang) vamos a repasar la declaración de funciones.

Veamos un ejemplo:

func dobleTriple(x int32, y int32) (int32, int32) {
	return x * x, y * y * y
}

Como se puede observar:

• Declaramos una función con dos variables como parámetros de entrada
• Definimos que no solo devolverá un valor sino dos.
• El primer valor devuelto será el resultado de multiplicar x*x
• El segundo valor a devolver será la multiplicación de y tres veces

Otro aspecto importante es que no es necesario declarar el tipo de la primera variable, basta con la declaramos al final. Esta declaración en la función sería válida:

func dobleTriple(x, y int32) (int32, int32) {
	return x * x, y * y * y
}

¿Cómo emplear ésta función?

// Esto es válido en Go(lang)
// Asignamos valores
var x, y = 2, 3
var dobleX, tripleY = dobleTriple(int32(x), int32(y))
// Mostramos resultados
fmt.Printf("Doble(%d): %d\n", x, dobleX)
fmt.Printf("Triple(%d): %d\n", y, tripleY)

Como se puede ver la declaración de variables y su valor es similar a Python. Basta una sola línea para ahorrarnos esa tarea. Otro aspecto es que no es forzoso usar el especificador %d para imprimir las variables de tipo int. Podríamos usar el especificador %v para hacer exactamente lo mismo.

// Esto es válido en Go(lang)
// Asignamos valores
var x, y = 2, 3
var dobleX, tripleY = dobleTriple(int32(x), int32(y))
// Mostramos resultados
// Usamos %v en vez de %d
fmt.Printf("Doble(%v): %v\n", x, dobleX)
fmt.Printf("Triple(%v): %v\n", y, tripleY)

También podríamos usar %T para conocer el tipo de la variable:

// Esto es válido en Go(lang)
// Asignamos valores
var x, y = 2, 3
var dobleX, tripleY = dobleTriple(int32(x), int32(y))
// Mostramos resultados
// Usamos %v en vez de %d
fmt.Printf("Doble(%v): %v, tipo: %T\n", x, dobleX,dobleX)
fmt.Printf("Triple(%v): %v, tipo: %T\n", y, tripleY, tripleY)

Ahora, ¿se podrá definir una función que devuelva tres valores? En Go(lang) sí se puede:

func sumaRestaMultiplica(x, y int32) (int32, int32, int32) {
	return (x + y), (x - y), (x * y)
}

En esta función tenemos dos parámetros de entrada y devolverá tres resultados(suma, resta y multiplicación):

// Declaramos nuestras variables
var sumaF, restaF, multF = sumaRestaMultiplica(3, 4)

// Mostramos los resultados
fmt.Printf("Suma(3,4) = %d, tipo: %T\n", sumaF, sumaF)     // 7
fmt.Printf("Resta(3,4) = %d, tipo: %T\n", restaF, restaF)  // -1
fmt.Printf("Producto(3,4) = %d, tipo: %T\n", multF, multF) // 12
	

En próximos post vermos más ejemplos.

Enlaces:

https://go.dev/