No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Funciones variadicas y retornos con nombre

14/30
Recursos

Aportes 12

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

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

Aqui un ejemplo por si quieren pasar un entero o un decimal como parametro:`func getValues(x interface{}) (double float64, triple int, quad int) {` ```js func getValues(x interface{}) (double float64, triple int, quad int) { switch v := x.(type) { case int: double = 2 * float64(v) triple = 3 * v quad = 4 * v case float64: double = 2 * v triple = int(3 * v) quad = int(4 * v) default: fmt.Println("No se admite este tipo de dato") } return } ``` ` switch v := x.(type) {` ` case int:` ` double = 2 * float64(v)` ` triple = 3 * v` ` quad = 4 * v` ` case float64:` ` double = 2 * v` ` triple = int(3 * v)` ` quad = int(4 * v)` ` default:` ` fmt.Println("No se admite este tipo de dato")` ` }` ` return` `}`

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