Variadic Functions in Go

In Go, a variadic function is a special type of function that can accept a variable number of arguments of the same type. It allows you to pass any number of arguments to the function, including none, making the function flexible and adaptable to different use cases. Variadic functions are denoted by using an ellipsis ... before the type of the last parameter in the function signature.

The basic syntax of a variadic function in Go is as follows:

func functionName(parameter ...Type) {
    // Function body - code that uses the variadic parameter
}

Here are some key points about variadic functions in Go:

The variadic parameter acts as a slice within the function, allowing you to use it as if it were a slice of the specified type.
The variadic parameter must be the last parameter in the function signature.
You can pass zero or more arguments of the specified type to the variadic parameter when calling the function.
When calling the variadic function, you can pass individual arguments or a slice of the specified type.
Inside the function, you can loop over the variadic parameter just like a regular slice to process each argument.

Example of a variadic function that calculates the sum of multiple integers:

package main

import "fmt"

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

func main() {
    result := sum(1, 2, 3, 4, 5)
    fmt.Println("Sum:", result)

    // You can also pass a slice as an argument
    nums := []int{10, 20, 30}
    result = sum(nums...)
    fmt.Println("Sum:", result)
}

Output :

Sum: 15
Sum: 60

In this example, we define a variadic function sum that takes a variable number of integers as arguments. Inside the function, we use a for loop to iterate over the variadic parameter numbers (which acts like a slice) and calculate the total sum.

In the main function, we call the sum function with multiple integers as arguments. In the first call, we directly pass five individual integers. In the second call, we pass a slice nums using the ... syntax.

Variadic functions are useful when you need to create functions that can handle a flexible number of arguments, such as calculating sums, finding averages, or formatting strings with various elements. They offer a convenient way to work with multiple values and improve code readability and simplicity.

Here are a few more examples of variadic functions in Go:

Find Maximum Number:

package main

import "fmt"

func max(numbers ...int) int {
    if len(numbers) == 0 {
        return 0
    }
    max := numbers[0]
    for _, num := range numbers[1:] {
        if num > max {
            max = num
        }
    }
    return max
}

func main() {
    result := max(10, 5, 8, 20, 3)
    fmt.Println("Maximum number:", result)

    result = max(7, 12, 4)
    fmt.Println("Maximum number:", result)

    result = max()
    fmt.Println("Maximum number:", result)
}

Output:

Maximum number: 20
Maximum number: 12
Maximum number: 0

Concatenate Strings:

package main

import "fmt"

func concatenateStrings(sep string, strings ...string) string {
    result := ""
    for i, str := range strings {
        if i > 0 {
            result += sep
        }
        result += str
    }
    return result
}

func main() {
    result := concatenateStrings(", ", "apple", "banana", "orange")
    fmt.Println("Fruits:", result)

    result = concatenateStrings(" - ", "red", "green", "blue")
    fmt.Println("Colors:", result)
}

Output:

Fruits: apple, banana, orange
Colors: red - green - blue

Calculate Average:

package main

import "fmt"

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

func main() {
    result := average(10, 20, 30, 40, 50)
    fmt.Println("Average:", result)

    result = average(3.5, 7.2, 5.9)
    fmt.Println("Average:", result)

    result = average()
    fmt.Println("Average:", result)
}

Output:

Average: 30
Average: 5.2
Average: 0

Variadic functions are versatile and allow you to create flexible and reusable code that can handle different numbers of arguments. You can use them in various scenarios where the number of arguments may vary, making your code more efficient and adaptable.