Golang Exec

Il pacchetto Exec è definito nel pacchetto del sistema operativo. È semplicemente un sotto-pacchetto che consente di eseguire comandi esterni usando GO.

In questa guida, esploreremo come possiamo utilizzare il pacchetto Exec in per eseguire comandi esterni.

Importazione del pacchetto Exec

Per utilizzare il pacchetto Exec, dobbiamo importarlo. Possiamo farlo usando un semplice comando di importazione come:

Importa "OS/Exec"

Una volta importato, è possibile eseguire comandi, come vedremo in questo articolo.

Golang Esegui comandi

Iniziamo con una chiamata di comando di base per illustrare come utilizzare il pacchetto Exec. Un codice di esempio è come mostrato di seguito:

Pacchetto principale
importazione (
"FMT"
"tronco d'albero"
"OS/EXEC"
)
funcmain ()
cmd: = exec.Comando ("dir")
output, err: = cmd.CombineDOutput ()
Se err != nil
tronco d'albero.Fatale (err)

fmt.Printf ("output: \ n%s \ n", stringa (output))

Nell'esempio sopra, utilizziamo il comando EXEC per ottenere l'elenco di file e directory utilizzando il comando DIR.

Iniziamo definendo il comando in esecuzione usando il metodo di comando. La sintassi è come mostrata:

comando func (nome stringa, arg stringa) *cmd

La funzione prende l'esecuzione dei comandi come argomento stringa. Restituisce quindi una struttura di comando per eseguire il comando con gli argomenti forniti.

Il prossimo passo è eseguire il comando utilizzando il metodo combinato. La sintassi del metodo è come mostrato:

func (c *cmd) combinatoutput () ([] byte, errore)

Il metodo esegue il comando e restituisce StDout combinati e Stderr. Questo restituisce una fetta di byte, che convertiamo in una stringa usando il metodo stringa.

Una volta eseguito il codice sopra, dovrebbe restituire i file e le directory nella directory di lavoro corrente.

Imposta la directory di lavoro corrente

Possiamo definire la directory di lavoro corrente su cui eseguire il comando usando il CMD.Dir variabile. Un esempio è come mostrato:

Pacchetto principale
importazione (
"FMT"
"tronco d'albero"
"OS/EXEC"
)
funcmain ()
cmd: = exec.Comando ("dir")
cmd.Dir = "..."
output, err: = cmd.CombineDOutput ()
Se err != nil
tronco d'albero.Fatale (err)

fmt.Printf ("output: \ n%s \ n", stringa (output))

Catturare separatamente stdout e stderr.

Invece di combinare StDout e Stderr, puoi catturarli separatamente come mostrato nel codice seguente:

cmd: = exec.Comando ("dir")
cmd.Dir = "..."
var stdout, byte Stderr.Respingente
cmd.Stderr = & Stderr
cmd.Stdout = & stdout
err: = cmd.Correre()
Se err != nil
tronco d'albero.Fatale (err)

output, err: = string (stdout.Bytes ()), stringa (stderr.Bytes ())

Specificare il sistema operativo

Puoi anche definire i comandi personalizzati per un sistema operativo diverso utilizzando il runtime.Metodo goos. Per esempio:

ifruntime.Goos == "Windows"
cmd = exec.Comando ("dir")

Comandi a tubo

È inoltre possibile tubolare l'output di un comando precedente come mostrato nell'esempio sopra:

Pacchetto principale
importazione (
"FMT"
"tronco d'albero"
"OS/EXEC"
)
funcmain ()
First_cmd: = 'echo "Hello World" | wc -c '
cmd: = exec.Comando ("bash", "-c", first_cmd)
output, err: = cmd.CombineDOutput ()
Se err != nil
tronco d'albero.Fatale (err)

fmt.Printf ("output \ n%s \ n", stringa (output))

Il comando sopra dovrebbe restituire il numero di caratteri dal comando Echo.

Chiusura

Questa breve guida illustra come iniziare con il pacchetto Exec in Golang.