web-dev-qa-db-fra.com

Comment puis-je passer une tranche en tant que saisie variadique?

J'ai une fonction func more(... t). Je me demande s'il est possible d'utiliser une tranche pour remplir une liste d'arguments .... 

J'essaie de résoudre le programme suivant. Fondamentalement, imiter un shell normal qui reçoit la commande sous forme de chaîne . Commande function nécessite une "liste" d'arguments et je ne vois pas comment convertir une chaîne en une telle liste 

    import "os/exec"
    import "strings"
    func main(){
        plainCommand  := "echo hello world"
        sliceA := strings.Fields(plainCommand)
        cmd := exec.Command(sliceA)
    }
go
41
The user with no hat

La spécification du langage de programmation Go

Passer des arguments à ... paramètres

Si f est variadic avec le type de paramètre final ... T, dans le function, l'argument est équivalent à un paramètre de type [] T. À à chaque appel de f, l’argument passé au paramètre final est un nouveau tranche de type [] T dont les éléments successifs sont les arguments réels, qui doivent tous être assignables au type T. La longueur de la tranche est de donc le nombre d'arguments liés au paramètre final et may diffèrent pour chaque site d’appel.

Paquet exec

func Command

func Command(name string, arg ...string) *Cmd

La commande retourne la structure Cmd pour exécuter le programme nommé avec le arguments donnés.

Le champ Args de Cmd renvoyé est construit à partir du nom de la commande suivi des éléments de arg, alors arg ne doit pas inclure la commande se nommer. Par exemple, Command ("echo", "hello")

Par exemple,

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    name := "echo"
    args := []string{"hello", "world"}
    cmd := exec.Command(name, args...)
    out, err := cmd.Output()
    if err != nil {
        fmt.Println(err)
    }
    fmt.Println(string(out))
}

Sortie:

hello world
62
peterSO

Une liste d'arguments de commande peut être extraite du paquet indicateur package Args() fonction . Vous pouvez ensuite le transmettre à une fonction en utilisant le style de saisie variadique (func(input...)).

De le Spec :

Si f est variadic avec le type de paramètre final ... T, alors, dans la fonction, l'argument est équivalent à un paramètre de type [] T. À chaque appel de f, l'argument transmis au paramètre final est une nouvelle tranche de type [] T dont les éléments successifs sont les arguments réels, qui doivent tous être assignables au type T.

Exemple:

package main

import "fmt"

func echo(strings ...string) {
    for _, s := range strings {
        fmt.Println(s)
    }
}

func main() {
    strings := []string{"a", "b", "c"}
    echo(strings...) // Treat input to function as variadic
}

Voir La spécification Go pour plus de détails.

Cour de récréation

5
Intermernet

func Command

func Command(name string, arg ...string) *Cmd

La commande retourne la structure Cmd pour exécuter le programme nommé avec les arguments donnés.

Il faut donc extraire la commande qui se trouve à sliceA[0] et ensuite passer tous les arguments avec un variadique en supprimant la commande sliceA[1:]....

import "os/exec"
import "strings"
func main(){
    plainCommand  := "echo hello world"
    sliceA := strings.Fields(plainCommand)
    cmd := exec.Command(sliceA[0], sliceA[1:]...)
}
0
Nathenapse