Wie kann ich ein Slice als variadische Eingabe übergeben?

Ich habe eine Funktion func more(... t). Ich frage mich, ob es möglich ist, ein Slice zum Auffüllen einer Liste von Argumenten zu verwenden ....

Ich versuche das folgende Programm zu lösen. Grundsätzlich, um eine normale Shell nachzuahmen, die den Befehl als Zeichenfolge empfängt. Die Befehlsfunktion erfordert eine "Liste" von Argumenten und ich sehe nicht, wie ich eine Zeichenfolge in eine solche Liste konvertieren kann

    import "os/exec"
    import "strings"
    func main(){
        plainCommand  := "echo hello world"
        sliceA := strings.Fields(plainCommand)
        cmd := exec.Command(sliceA)
    }

Die Go-Programmiersprachenspezifikation

Argumente an ... Parameter übergeben

Wenn f mit dem endgültigen Parametertyp ... T variadisch ist, entspricht das Argument innerhalb der Funktion einem Parameter vom Typ [] T. Bei jedem Aufruf von f ist das an den letzten Parameter übergebene Argument ein neues Slice vom Typ [] T, dessen aufeinanderfolgende Elemente die tatsächlichen Argumente sind, die alle dem Typ T zugeordnet werden müssen. Die Länge des Slice ist daher die Anzahl von Argumente, die an den letzten Parameter gebunden sind und für jede Aufrufstelle unterschiedlich sein können.

Paket exec

func Befehl

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

Der Befehl gibt die Cmd-Struktur zurück, um das benannte Programm mit den angegebenen Argumenten auszuführen.

Das Args-Feld des zurückgegebenen Cmd besteht aus dem Befehlsnamen, gefolgt von den Elementen von arg, daher sollte arg den Befehlsnamen selbst nicht enthalten. Zum Beispiel Befehl ("Echo", "Hallo")

Zum Beispiel,

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

Ausgabe:

hello world

Eine Liste von Befehlsargumenten kann aus der Flag-PaketfunktionArgs() abgerufen werden . Sie können dies dann mit dem variadischen Eingabestil ( func(input...)) an eine Funktion übergeben.

Aus der Spezifikation :

Wenn f mit dem endgültigen Parametertyp ... T variadisch ist, entspricht das Argument innerhalb der Funktion einem Parameter vom Typ [] T. Bei jedem Aufruf von f ist das an den letzten Parameter übergebene Argument eine neue Schicht vom Typ [] T, deren aufeinanderfolgende Elemente die tatsächlichen Argumente sind, die alle dem Typ T zugewiesen werden müssen.

Beispiel:

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
}

Weitere Informationen finden Sie in der Go-Spezifikation .

Spielplatz

func Befehl

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

Der Befehl gibt die Cmd-Struktur zurück, um das benannte Programm mit den angegebenen Argumenten auszuführen.

Sie müssen also den Befehl extrahieren, der unter gefunden wird, sliceA[0]und dann alle Argumente mit einer Variablen übergeben, aber den Befehl entfernen sliceA[1:]....

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