Funciones variadic en Go con tres puntos

Contenido del curso

Introducción y Configuración

Fundamentos de Go

Estructuras de Datos y Funciones

Manejo de Errores y Concurrencia

Buenas Prácticas en Go

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:007:10

Funciones variadic en Go con tres puntos

Curso de Go

Clase 14 de 28

Clase 14 / 28

Comentarios (7)7 comentarios

Victor Reyes

Hace un año

Los tres puntos '...' después de 'arreglo' se conocen como "spread operator" o "unpack operator" permite que los elementos de un slice se traten como argumentos separados cuando se pasan a una función variádica.

Es decir, se pasan a la función suma como si hubieras llamado a la función individualmente con cada uno de ellos: suma(1, 2, 3, 4, 5)

Yamid Horacio Rodríguez

Hace un año

Me está empezando a gustar Go uwu

Samuel Soto Hoyos

Hace un año

Go es el mejor lenguaje de programación!

Jehú Frayle

Hace un año

Un ejemplo sencillo de función variádica es la función "promedio", necesitamos recibir una cantidad indeterminada de números y aplicar un procedimiento, quedaría algo así:

func average(numbers ...int) float64 {
	total := 0
	for _, number := range numbers {
		total += number
	}
	return float64(total) / float64(len(numbers))
}

Miguel Angel Reyes Moreno

Hace un año

Genial esto de Go :o

Ronaldo Jiménez

Hace un año

package main

import (
	"fmt"
)

// println simula la función print de Python, aceptando un número variable de argumentos.
func println(a ...interface{}) {
	fmt.Println(a...)
}

func main() {
	// Llamadas a la función println con diferentes números y tipos de argumentos.
	println("Hola, mundo!")
	println("El número es:", 42)
	println("El valor de pi es:", 3.14159)
	println("Podemos combinar:", "texto", "y", 123, "con flotantes", 45.67)

	// La función original fmt.Println es en sí misma una función variádica.
	// Nuestra función println simplemente envuelve a fmt.Println.
}

Ronaldo Jiménez

Hace un año

// Función con parámetros variables (variadic)
package functions

import "fmt"

// Acepta un número variable de argumentos
// Los argumentos se tratan como un slice dentro de la función
// Se indica con ... antes del tipo del parámetro
func sumarTodos(numeros ...int) int {
	total := 0
	for _, num := range numeros {
		total += num
	}
	return total
}

func Variadic() {
	fmt.Println("Función variadic:")
	fmt.Println(sumarTodos(1, 2, 3))       // Suma: 6
	fmt.Println(sumarTodos(5, 10, 15, 20)) // Suma: 50
	fmt.Println()
}

Moises Almonte

Hace un año

Después de ver este video, me surgió la duda, ¿Como funciona la función fmt.Println()?

Entonces realice varios ejemplos:

Primero: como aceptar varios tipos de datos en la misma función.

Se utiliza la palabra clave any, que es un alias de interface{}:

func detectar_tipo_dato(dato any){
  switch dt_type := dato.(type) { 
    case int:
      fmt.Println("Es un entero", dato)
    case string:
      fmt.Println("Es una cadena", dato)
    case bool:
      fmt.Println("Es un booleano", dato)
    case float64:
      fmt.Println("Es un decimal", dato)
    case [5]int:
      fmt.Println("Es un arreglo de entero, de tamaño 5", dato)
    default:
      fmt.Println("Es un dato no soportado")
  }
}
```Podemos restringir los tipos de datos que la función puede aceptar, ejemplo:

```js
func isString(dato any) bool{
  _, test_dat := dato.(string)
  return test_dat
}
```También podemos restringir los tipos de datos aceptados, por media de una interface y una función genérica:

```js
// Interface para los datos aceptados
type N_Positivos interface{
  ~uint8 | ~uint16
}

func suma_numeros_peqn N_Positivos uint16{
  var resultdo uint16 = 0
  for _, valor := range nums{
    resultado += uint16(valor)
  }
  return resultado
}

//Llamando la funcion
res_suma := suma_numeros_peq(uint8(100), uint8(98), uint8(45), uint8(34))
fmt.Println(res_suma)

Recursos

Las funciones variadic en Go te permiten recibir una cantidad indefinida de parámetros del mismo tipo dentro de una sola función, sin tener que duplicar código para cada caso. Si alguna vez creaste una función suma y luego una sumaLarga para más argumentos, esta es la solución que te ahorra líneas y mantiene tu código limpio.

¿Qué es una función variadic en Go y por qué deberías usarla?

Una función variadic acepta un número variable de argumentos del mismo tipo. En lugar de fijar dos, tres o cinco parámetros, declaras uno solo precedido por tres puntos ... y Go se encarga de tratarlo como un slice internamente.

El ejemplo más conocido lo usas todos los días: fmt.Println. Puedes pasarle un solo string como "Hello, world", o combinarlo con variables como name y age, y la función responde igual de bien con uno, dos o cinco elementos.

¿Qué significa el operador ... en Go? Indica que el parámetro acepta cero o más valores del tipo declarado. Internamente, Go los empaqueta como un slice que puedes recorrer con for range.

¿Cómo se declara una función variadic paso a paso?

La sintaxis es directa: declaras el parámetro con tres puntos antes del tipo. Así le dices al compilador que ese argumento puede recibir cualquier cantidad de valores.

Mira cómo se ve una función sum que acepta enteros indefinidos:

go func sum(numbers ...int) { fmt.Println(numbers) total := 0 for _, number := range numbers { total = total + number } fmt.Println("La suma es", total) }

Dentro de la función, numbers se comporta como un slice. Por eso puedes recorrerlo con for range, ignorando el índice con el guion bajo _ y acumulando cada valor en total.

¿Cómo invocas una función variadic con valores sueltos?

La llamas como cualquier función, pero pasando los argumentos separados por coma. No hay un límite fijo: puedes mandar dos, tres o los que necesites.

sum(1, 2) devuelve la suma 3.
sum(1, 2, 3) devuelve 6.
sum(10, 20, 30, 40) devuelve 100.

Cada llamada usa la misma función, sin sobrecargas ni versiones alternativas.

¿Cómo paso un array o slice a una función variadic?

Aquí viene lo interesante. Si ya tienes un slice con los valores, no necesitas extraerlos uno por uno. Usas el operador ... al momento de la llamada para expandirlos.

go numbers := []int{1, 2, 3, 4, 5} sum(numbers...)

Esa expansión le dice a Go: "toma cada elemento del slice y pásalo como argumento individual". El resultado de ese ejemplo es 15.

¿Cuándo conviene usar una función variadic en tus proyectos?

La pista está en cuántas versiones de la misma función estás creando. Si te encuentras escribiendo suma, sumaLarga y luego sumaMasLarga, es señal de que necesitas una variadic.

¿Cuál es la diferencia entre una función normal y una variadic? La normal exige una cantidad exacta de parámetros. La variadic acepta desde cero hasta los que quieras, todos del mismo tipo, agrupados como slice.

Algunos escenarios donde brillan:

Funciones de logging o impresión donde no sabes cuántos valores vas a mostrar.
Operaciones matemáticas como sumas, promedios o máximos sobre cantidades dinámicas.
Constructores que reciben una lista opcional de configuraciones.

El propio fmt.Println es la prueba viva de cuán versátil resulta esta característica: una sola función adaptándose a prácticamente cualquier entrada.

¿Qué pasa dentro de la función cuando recibes los parámetros?

Go convierte automáticamente los argumentos en un slice del tipo declarado. Eso significa que puedes usar todas las herramientas que ya conoces: len() para contar, for range para iterar, indexación directa, etc.

En el ejemplo de sum, el for _, number := range numbers ignora el índice con _ (el famoso guion bajo para saltar el primer valor del rango) y acumula cada número en total. Al final, fmt.Println("La suma es", total) imprime el resultado.

Practica creando tus propias variadic: una que concatene strings, otra que encuentre el valor máximo, una más que reciba structs. Cada vez que reduzcas funciones duplicadas, vas a sentir el ahorro real en tu base de código.

¿Ya identificaste en tu proyecto actual alguna función que podrías refactorizar como variadic? Cuéntame en los comentarios cuál fue y cuántas líneas te ahorraste.

package main

import (
	"fmt"
)

// println simula la función print de Python, aceptando un número variable de argumentos.
func println(a ...interface{}) {
	fmt.Println(a...)
}

func main() {
	// Llamadas a la función println con diferentes números y tipos de argumentos.
	println("Hola, mundo!")
	println("El número es:", 42)
	println("El valor de pi es:", 3.14159)
	println("Podemos combinar:", "texto", "y", 123, "con flotantes", 45.67)

	// La función original fmt.Println es en sí misma una función variádica.
	// Nuestra función println simplemente envuelve a fmt.Println.
}

// Función con parámetros variables (variadic)
package functions

import "fmt"

// Acepta un número variable de argumentos
// Los argumentos se tratan como un slice dentro de la función
// Se indica con ... antes del tipo del parámetro
func sumarTodos(numeros ...int) int {
	total := 0
	for _, num := range numeros {
		total += num
	}
	return total
}

func Variadic() {
	fmt.Println("Función variadic:")
	fmt.Println(sumarTodos(1, 2, 3))       // Suma: 6
	fmt.Println(sumarTodos(5, 10, 15, 20)) // Suma: 50
	fmt.Println()
}

func detectar_tipo_dato(dato any){
  switch dt_type := dato.(type) { 
    case int:
      fmt.Println("Es un entero", dato)
    case string:
      fmt.Println("Es una cadena", dato)
    case bool:
      fmt.Println("Es un booleano", dato)
    case float64:
      fmt.Println("Es un decimal", dato)
    case [5]int:
      fmt.Println("Es un arreglo de entero, de tamaño 5", dato)
    default:
      fmt.Println("Es un dato no soportado")
  }
}
```Podemos restringir los tipos de datos que la función puede aceptar, ejemplo:

```js
func isString(dato any) bool{
  _, test_dat := dato.(string)
  return test_dat
}
```También podemos restringir los tipos de datos aceptados, por media de una interface y una función genérica:

```js
// Interface para los datos aceptados
type N_Positivos interface{
  ~uint8 | ~uint16
}

func suma_numeros_peqn N_Positivos uint16{
  var resultdo uint16 = 0
  for _, valor := range nums{
    resultado += uint16(valor)
  }
  return resultado
}

//Llamando la funcion
res_suma := suma_numeros_peq(uint8(100), uint8(98), uint8(45), uint8(34))
fmt.Println(res_suma)

Resumen

¿Qué es una función variadic en Go y por qué deberías usarla?

¿Qué significa el operador ... en Go? Indica que el parámetro acepta cero o más valores del tipo declarado. Internamente, Go los empaqueta como un slice que puedes recorrer con for range.

¿Cómo se declara una función variadic paso a paso?

La sintaxis es directa: declaras el parámetro con tres puntos antes del tipo. Así le dices al compilador que ese argumento puede recibir cualquier cantidad de valores.

Mira cómo se ve una función sum que acepta enteros indefinidos:

go func sum(numbers ...int) { fmt.Println(numbers) total := 0 for _, number := range numbers { total = total + number } fmt.Println("La suma es", total) }

Dentro de la función, numbers se comporta como un slice. Por eso puedes recorrerlo con for range, ignorando el índice con el guion bajo _ y acumulando cada valor en total.

¿Cómo invocas una función variadic con valores sueltos?

La llamas como cualquier función, pero pasando los argumentos separados por coma. No hay un límite fijo: puedes mandar dos, tres o los que necesites.

sum(1, 2) devuelve la suma 3.
sum(1, 2, 3) devuelve 6.
sum(10, 20, 30, 40) devuelve 100.

Cada llamada usa la misma función, sin sobrecargas ni versiones alternativas.

¿Cómo paso un array o slice a una función variadic?

Aquí viene lo interesante. Si ya tienes un slice con los valores, no necesitas extraerlos uno por uno. Usas el operador ... al momento de la llamada para expandirlos.

go numbers := []int{1, 2, 3, 4, 5} sum(numbers...)

Esa expansión le dice a Go: "toma cada elemento del slice y pásalo como argumento individual". El resultado de ese ejemplo es 15.

¿Cuándo conviene usar una función variadic en tus proyectos?

La pista está en cuántas versiones de la misma función estás creando. Si te encuentras escribiendo suma, sumaLarga y luego sumaMasLarga, es señal de que necesitas una variadic.

¿Cuál es la diferencia entre una función normal y una variadic? La normal exige una cantidad exacta de parámetros. La variadic acepta desde cero hasta los que quieras, todos del mismo tipo, agrupados como slice.

Algunos escenarios donde brillan:

Funciones de logging o impresión donde no sabes cuántos valores vas a mostrar.
Operaciones matemáticas como sumas, promedios o máximos sobre cantidades dinámicas.
Constructores que reciben una lista opcional de configuraciones.

El propio fmt.Println es la prueba viva de cuán versátil resulta esta característica: una sola función adaptándose a prácticamente cualquier entrada.

¿Qué pasa dentro de la función cuando recibes los parámetros?

¿Ya identificaste en tu proyecto actual alguna función que podrías refactorizar como variadic? Cuéntame en los comentarios cuál fue y cuántas líneas te ahorraste.

Introducción y Configuración

Características y ventajas del lenguaje de programación Go

Instala Go en WSL con un comando

Paquetes en Go sin npm ni pip

Fundamentos de Go

Formas de declarar variables en Go

Conversión de tipos en Go

if else y operador módulo en Go

Cuatro formas de usar for en Go

Estructuras de Datos y Funciones

Sentencia switch en Go con ejemplos reales

Arreglos en Go: fijos e inferidos

Creación y uso de slices dinámicos en Go

Mapas en Go: creación, acceso y manipulación de datos clave-valor

Cómo crear y usar funciones personalizadas en Go

Retorno de múltiples valores en Go

Funciones variadic en Go con tres puntos

Funciones recursivas en Go con Fibonacci

Punteros en Go para optimizar rendimiento del sistema

Runas en Go: bytes vs caracteres reales

Declaración y uso de estructuras de datos en Go

Implementación de enumeradores en Go para controlar estados

Manejo de Errores y Concurrencia

Errores personalizados en Go

Goroutines y channels en Go

Select para ordenar goroutines en Go

Timeouts en goroutines con time.After

Workers en Go con goroutines y channels

Buenas Prácticas en Go

JSON con Marshal y Unmarshal en Go

Conversión de texto plano a hash con SHA256 en Go

Variables de ambiente en Go con paquetes externos

Cierre de curso de Go: consejos para consolidar el aprendizaje

Funciones variadic en Go con tres puntos