In der Go-Sprache
[]string ist ein String-Array
und wir verwenden auch ...stringals Parameter.
Was ist der Unterschied?
Funktionsdefinition:
func f(args ...string) {}
Kann ich diese Funktion wie folgt aufrufen?
args := []string{"a", "b"}
f(args)
Antworten:
[]stringist ein String-Array
Technisch gesehen ist es ein Slice, das auf ein zugrunde liegendes Array verweist
und wir verwenden auch
...stringals Parameter.Was ist der Unterschied?
In Bezug auf die Struktur nichts wirklich. Der aus beiden Syntax resultierende Datentyp ist der gleiche.
Die ...Parametersyntax erstellt einen variadischen Parameter. Es werden null oder mehr stringArgumente akzeptiert und als Slice referenziert.
In Bezug auf den Aufruf fkönnen Sie ein Stück Zeichenfolgen mit der folgenden Syntax an den variadischen Parameter übergeben:
func f(args ...string) {
fmt.Println(len(args))
}
args := []string{"a", "b"}
f(args...)
Diese Syntax ist entweder für das Slice verfügbar, das mit der Literal-Syntax erstellt wurde, oder für das Slice, das den variadischen Parameter darstellt (da es wirklich keinen Unterschied zwischen ihnen gibt) .
[]stringSyntax erstellten Slice gestellt wurde . Ich werde meiner Antwort mehr von dem Zitat hinzufügen, um es klarer zu machen. :-)
Beide erstellen ein Array von Zeichenfolgen, aber der Unterschied besteht darin, wie es aufgerufen wird.
func f(args ...string) {
}
// Would be called like this:
f("foo","bar","baz");
Auf diese Weise können Sie eine variable Anzahl von Argumenten akzeptieren (alle vom gleichen Typ).
Ein fmt.Printgutes Beispiel dafür sind Freunde, die so wenige oder so viele Arugments akzeptieren können, wie Sie möchten.
def fn(*args)Konstruktion.
Folgendes möchten Sie:
var args []string = []string{"A", "B", "C"}
func Sample(args ...string) {
for _, arg := range args {
fmt.Println(arg)
}
}
func main() {
Sample(args...)
}
Spielen: http://play.golang.org/p/N1ciDUKfG1
Es vereinfacht Ihre Funktionsparameter. Hier ist ein Beispiel ( https://play.golang.org/p/euMuy6IvaM ): Methode SampleEllipsis nimmt von Null auf viele Parameter desselben Typs , aber in dem Verfahren ist es zwingend sample args deklariert werden.
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{})
}
Kehrt zurück :
Sample ellipsis : [A B C]
Sample ellipsis : [A B C]
Sample ellipsis : []
Sample array
Sample ellipsis : [A B C]
Sample array
Sample ellipsis : []
[]stringist ein Slice, kein Array. Die Unterschiede zwischen einem Array und einem Slice sind subtil, aber wichtig.