[] string 和... string 在 golang 中的区别是什么？

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.

[]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

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

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 : []