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
}``````

• 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
}
}

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
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
}
}

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.