What is the difference between []string and ...string in golang?

Question

In the Go language,

[]string is a string array

and we also use ...string as a parameter.

What is the difference?

Function definition:

func f(args ...string) {}

Can I call this function like below?

args := []string{"a", "b"}

f(args)

score 140 · Accepted Answer · edited Jun 20 '20 at 09:12

140

[]string is a string array

Technically it's a slice that references an underlying array

and we also use ...string as a parameter.

What is the difference?

With respect to the structure, nothing really. The data type resulting from both syntax is the same.

The ... parameter syntax makes a variadic parameter. It will accept zero or more string arguments, and reference them as a slice.

With respect to calling f, you can pass a slice of strings into the variadic parameter with the following syntax:

func f(args ...string) {
    fmt.Println(len(args))
}


args := []string{"a", "b"}

f(args...)

This syntax is available for either the slice built using the literal syntax, or the slice representing the variadic parameter (since there's really no difference between them).

http://play.golang.org/p/QWmzgIWpF8

edited Jun 20 '20 at 09:12

Community

1
1

answered Oct 16 '12 at 04:54

I Hate Lazy

47,415
13
86
77

12

`[]string` is a slice, not an array. The differences between an array and slice are subtle but important. – Stephen Weinberg Oct 16 '12 at 06:02
@StephenWeinberg: Yes, my "nothing really" answer to the "what's the difference" quote is answering the question that was asked about the difference between the slice generated by the variadic function parameter, and the one created using the `[]string` syntax. I'll add more of the quote to my answer to make it clearer. :-) – I Hate Lazy Oct 16 '12 at 11:16
@IHateLazy Is there a way to make builtin `println` work with ellipsis? [Here](http://play.golang.org/p/lJKJbhC1a1) you can find my experiments. If someone wishes some debug print functions, go watch my playgound. – vault Aug 12 '14 at 16:48

score 16 · Answer 2 · answered Oct 16 '12 at 04:51

16

Both create an array of strings, but the difference is in how it is called.

func f(args ...string) {

}
// Would be called like this:

f("foo","bar","baz");

This allows you to accept a variable number of arguments (all of the same type)

A great example of this is fmt.Print and friends, which can accept as few or as many arugments as you want.

answered Oct 16 '12 at 04:51

tylerl

30,197
13
80
113

I'm no Go expert, but isn't one variadic arguments and the other a single array argument, and aren't the two distinct like in other languages? – Lightness Races in Orbit Oct 16 '12 at 04:55
1

@LightnessRacesinOrbit Yup. If that's not clear then sorry for the confusion. The first line about both creating an array just means that the resultant argument in both instances is an array. It's nearly identical to python's `def fn(*args)` construction. – tylerl Oct 16 '12 at 06:13
So Go exposes variadic arguments as an instance of an array type? That's pleasing. – Lightness Races in Orbit Oct 16 '12 at 16:38
Actually they both create a slice of strings, Not an array. They are different things in golang. – PointerToConstantChar May 05 '17 at 16:22
Both don't create an "array" of strings, they create a "slice" of strings. – Inanc Gumus Nov 01 '17 at 18:43
Helpful for me ... +1 – Sahil Gulati Jan 23 '18 at 05:52

score 6 · Answer 3 · answered Nov 19 '15 at 20:43

6

Here is what you want:

var args []string = []string{"A", "B", "C"}

func Sample(args ...string) {
    for _, arg := range args {
        fmt.Println(arg)
    }
}

func main() {
    Sample(args...)
}

Play: http://play.golang.org/p/N1ciDUKfG1

answered Nov 19 '15 at 20:43

Ertuğrul

69
1
1

score 2 · Answer 4 · answered Nov 28 '16 at 12:36

It simplifies your function parameters. Here is an example(https://play.golang.org/p/euMuy6IvaM): Method SampleEllipsis accepts from zero to many parameters of the same type but in the method SampleArray it is mandatory args to be declared.

package main

import "fmt"

func SampleEllipsis(args ...string) {
    fmt.Printf("Sample ellipsis : %+v\n",args)
}


func SampleArray(args []string) {
    fmt.Println("Sample array ")
    SampleEllipsis(args...)
}

func main() {
    // Method one
    SampleEllipsis([]string{"A", "B", "C"}...)
    // Method two
    SampleEllipsis("A", "B", "C")
    // Method three
    SampleEllipsis()

    // Simple array
    SampleArray([]string{"A", "B", "C"})

    // Simple array
    SampleArray([]string{})

}

Returns :

Sample ellipsis : [A B C]
Sample ellipsis : [A B C]
Sample ellipsis : []
Sample array 
Sample ellipsis : [A B C]
Sample array 
Sample ellipsis : []

What is the difference between []string and ...string in golang?

4 Answers4

Linked