Funciones variadicas y retornos con nombre

Funciones variadicas y retornos con nombre.

Las funciones variadicas nos permiten utilizar como slices los argumentos de funciones de los cuales no sabemos su longitud exacta.

Los retornos con nombre nos permiten definir variables antes de definir el cuerpo de la función, por lo cual utilizaremos return para devolverlos.

Codigo con comentarios y alguna linea extra de ejemplo.

package main

import "fmt"

// recibe un slice de valores enteros y devuelve un entero.
func sum(values ...int) int {
	total := 0
	for _, num := range values {
		total += num
	}

	return total
}

// recibe un slice de valores string y los imprime.
func printNames(names ...string) {
	for _, name := range names {
		fmt.Println(name)
	}
}

// Funcion que retorna multiples valores.
func getValues(x int) (double int, triple int, quad int) {
	// return 2 * x, 3 * x, 4 * x // vieja forma.
	double = 2 * x
	triple = 3 * x
	quad = 4 * x
	return
}

func main() {
	// pasando datos en el argumento.
	fmt.Println(sum(3, 5, 7, 10, 25, 4))

	// Enviando datos en un arreglo.
	numbers := []int{4, 7, 3}
	fmt.Println(sum(numbers...))

	// Llamando a la funcion y pasando strings
	printNames("Carlos", "Jose", "Maria", "Laura")

	// Imprimiento multiples returns:
	fmt.Println(getValues(5))

	// capturando multiples returns:
	d, t, q := getValues(5)
	fmt.Println(d, t, q)
}

Go se siente como un lenguaje pensado para el desarrollador.

Improvement: retorna error cuando no se le pasa parametros:

package main

import "fmt"

func sum(values ... int) (int, error) {

	if len(values) > 0 {
		total := 0
		for _, v := range values {
			total += v
		}

		return total, nil
	} else {
		return 0, fmt.Errorf("This function receive at least one argument")
	}
}

func main() {
	fmt.Println(sum(1))
}

me encantó esta clase :’)

Código de la clase con comentarios explicando:

package functions

import (
	"fmt"
	"time"
)

// anon func's are not very recommended for DRY purposes. Only use it when it is necessary.
func anon() {
	x := 5

	// Anonymous func 1
	y := func(x int) int {
		return x * 2
	}
	fmt.Println("y anon func: ", y(x))

	// Anonymous func 2 (it calls directly the param and calls itself)
	z := func() int {
		return x * 2
	}()
	fmt.Println("y anon func: ", z)

	// 3rd Anonymous way: lambda Goroutine in a channel
	// Create channel for blocking Gorouting until msg arrives
	c := make(chan int)
	// anon Goroutine
	go func() {
		// Exec func logic in Goroutine
		fmt.Println("Starting Goroutine anon func...")
		time.Sleep(1 * time.Second)
		fmt.Println("Goroutine ended")

		// Send int to c channel
		c <- 1
	}() // calls itself
	// Waits until receiving the msg in c channel
	<-c

}

///////////////////////

/* Variadic funcs */
// Variadic func able us to insert a dinamic amount of params
// The param is a slice of the defined type
func sum(numbers ...int) int {
	totalSum := 0
	for _, num := range numbers {
		totalSum += num
	}

	return totalSum
}

func getNames(names ...string) {
	for _, name := range names {
		fmt.Println(name)
	}
}

///////////////////////
/* Named returns func's */
func multiples(a int8) (double, triple, quad int8) {
	double = a * 2
	triple = a * 3
	quad = a * 4
	return
}

func Functions() {
	anon()

	fmt.Println("----------------")
	fmt.Println(sum(1, 2, 3))
	fmt.Println(sum(1, 2, 3, 4, 5, 6))

	fmt.Println("----------------")
	getNames("Nico", "Pedro")
	getNames("Nico", "Pedro", "Facu")

	fmt.Println("----------------")
	double, triple, quad := multiples(2)
	// %o is for base 8 int
	fmt.Printf("Double: %o, triple: %o, quad: %o ", double, triple, quad)

}

Interesante forma de nombrar los valores que regresa la función para después tener un solo return vacío. Sin duda es más claro y será útil en el futuro.

¡Excelente clase! 😃

Las funciones variadicas son equivalentes a los varargs (variable arguments) de Java

Las funciones variadicas en Go me recuerdan a los *args de Python

No tenia ni idea sobre los retornos con nombre! Excelente clase

package main

import "fmt"

// Funciones variadicas
func sum(values ...int) int {
	total := 0
	for _, value := range values {
		total += value
	}

	return total
}

func printNames(names ...string) {
	for _, name := range names {
		fmt.Println(name)
	}
}

// Retornos con nombres
func getValues(x int) (double int, triple int, quad int) {
	double = x * 2
	triple = x * 3
	quad = x * 4

	return
}

func main() {
	fmt.Println(sum(1, 2, 3, 4, 5))
	printNames("Juan", "Pedro", "Maria")
	fmt.Println(getValues(2))
}

package main

func getCalculadora(x, y int) (suma int, resta int, multiplicacion int) {
	suma = x + y
	resta = x - y
	multiplicacion = x * y
	return
}

func main() {
	println(getCalculadora(5, 2))
}

Un pequeño aporte de lo aprendido en este vídeo. Excelente curso Néstor Escoto