Variadic Function

A variadic function in Go is a function that accepts a variable number of arguments (zero or more) for its final parameter. This is achieved using the ellipsis operator (...) as a prefix to the parameter’s type, which instructs the Go compiler to pack the provided arguments into a slice of that type.

func functionName(standardParam string, variadicParam ...int) {
    // Inside the function, variadicParam is evaluated as []int
}

Technical Constraints and Rules

1. Terminal Position: The variadic parameter must be the final parameter in the function signature. Declaring parameters after a variadic parameter results in a compilation error.
2. Singular Arity: A function signature can contain a maximum of one variadic parameter.
3. Type Uniformity: All arguments passed to the variadic parameter must match the declared type. To accept arguments of heterogeneous types, the parameter must be typed as the empty interface (...any or ...interface{}).
4. Nil Evaluation: If no arguments are provided to the variadic parameter during invocation, the resulting slice inside the function evaluates to nil.

Invocation and Slice Unfurling

Variadic functions can be invoked in two distinct ways: by passing discrete, comma-separated arguments, or by “unfurling” an existing slice using the ... suffix operator at the call site.

func process(values ...int) {
    // values is []int
}

func main() {
    // 1. Passing discrete arguments
    process(1, 2, 3) 
    process() // values evaluates to nil

    // 2. Unfurling an existing slice
    data := []int{4, 5, 6}
    process(data...) 
}

Memory Allocation and Mutation Behavior

The method of invocation dictates how the Go compiler handles memory allocation for the variadic slice:

• Discrete Arguments: When passing individual arguments (e.g., process(1, 2)), the compiler allocates a new hidden array, populates it with the arguments, and passes a slice referencing this new array to the function.
• Slice Unfurling: When passing an unfurled slice (e.g., process(data...)), the compiler does not allocate a new array. The variadic parameter directly references the backing array of the original slice. Consequently, any mutations made to the elements of the variadic slice within the function will directly mutate the original slice at the call site.

func mutate(values ...int) {
    if len(values) > 0 {
        values[0] = 99
    }
}

func main() {
    data := []int{1, 2, 3}
    
    // Unfurling: operates on the same backing array
    mutate(data...) 
    // data is now []int{99, 2, 3}
}

Master Go with Deep Grasping Methodology!

Learn More