web-dev-qa-db-fra.com

quelle est la différence entre [] chaîne et ... chaîne dans golang?

en langue Go

[]string est un tableau de chaînes

et nous utilisons aussi ...string comme paramètre

quelle est la difference?

définition de la fonction:

func f(args ...string) {}

et puis-je appeler cette fonction comme ci-dessous?

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

f(args)
go
68
user1746360

[]string est un tableau de chaînes

Techniquement, c'est une tranche qui référence un tableau sous-jacent

et nous utilisons aussi ...string comme paramètre

quelle est la difference?

En ce qui concerne la structure, rien vraiment. Le type de données résultant de la syntaxe est le même.

La syntaxe du paramètre ... crée un paramètre variadique. Il acceptera zéro ou plusieurs arguments string et les référencera comme une tranche.

En ce qui concerne l'appel f, vous pouvez transmettre une tranche de chaînes au paramètre variadic avec la syntaxe suivante:

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


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

f(args...)

Cette syntaxe est disponible pour la tranche construite à l'aide de la syntaxe littérale ou pour la tranche représentant le paramètre variadique (puisqu'il n'y a pas vraiment de différence entre eux).

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

106
I Hate Lazy

Les deux créent un tableau de chaînes, mais la différence réside dans la façon dont il est appelé.

func f(args ...string) {

}
// Would be called like this:

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

Cela vous permet d'accepter un nombre variable d'arguments (tous du même type)

Un bon exemple de cela est fmt.Print et ses amis, qui peuvent accepter autant de réponses que vous le souhaitez.

13
tylerl

Voici ce que tu veux:

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

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

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

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

4
Ertuğrul

Cela simplifie les paramètres de votre fonction. Voici un exemple ( https://play.golang.org/p/euMuy6IvaM ): Method SampleEllipsis accepte de zéro à plusieurs paramètres du même type mais dans la méthode SampleArray, il est obligatoire args à déclarer.

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

}

Résultats :

Sample Ellipsis : [A B C]
Sample Ellipsis : [A B C]
Sample Ellipsis : []
Sample array 
Sample Ellipsis : [A B C]
Sample array 
Sample Ellipsis : []
0
Petre Sosa