Variadic functions in Golang

Orignallly posted this on medium.

Overview

Variadic functions are a powerful feature in Go that allow you to pass a variable number of arguments to a function. Let's dive deep into how they work and explore some practical examples.

What are Variadic Functions?

A variadic function is a function that accepts a variable number of arguments of the same type. In Go, we denote this using the ... syntax followed by the type. Basic Example Let's start with a simple example:

func myFunc(params ...int) {
    for _, num := range params {
        fmt.Println(num)
    }
}

When you call this function, you can pass any number of integer arguments:

myFunc(1, 2, 3, 4)  // Pass multiple arguments

Behind the Scenes What's interesting is how Go handles these arguments internally:

• The values passed as comma-separated arguments (1, 2, 3, 4) are automatically converted into a slice

• Inside the function, params becomes []int{1, 2, 3, 4}

• You can then iterate over this slice like any other slice in Go

Passing Slices to Variadic Functions

But what if you already have a slice and want to pass it to a variadic function? Let's look at another example:

func secondFunc(params ...int) {
    for _, num := range params {
        fmt.Println("Number in second function:", num)
    }
}

To pass a slice to a variadic function, Go provides a special syntax using the ... operator:

numbers := []int{1, 2, 3, 4}
secondFunc(numbers...)  // Unpack the slice into individual arguments

Important Points to Remember

The ... has different meanings based on where it's used:

• In function parameters (func myFunc(params ...int)): It means "accept variable number of arguments"
• When calling a function (secondFunc(numbers...)): It means "unpack this slice into individual arguments"

You can only have one variadic parameter per function, and it must be the last parameter.

Practical Example

Here's a more practical example combining both concepts:

func sum(numbers ...int) int {
    total := 0
    for _, num := range numbers {
        total += num
    }
    return total
}

func main() {
    // Direct arguments
    fmt.Println(sum(1, 2, 3))  // Output: 6

    // Using a slice
    numbers := []int{4, 5, 6}
    fmt.Println(sum(numbers...))  // Output: 15
}

Common Use Cases

Variadic functions are commonly used in Go for:

• Logging functions that accept multiple values
• String formatting functions
• Collection operations where the number of items is variable
• Building flexible APIs that need to handle varying numbers of inputs

Conclusion

Variadic functions in Go provide a clean and flexible way to handle multiple arguments. Understanding how to use them both with direct arguments and slices makes your Go code more elegant and maintainable.