Golang Exec

O pacote EXEC é definido no pacote do sistema operacional. É simplesmente uma sub-pacote que permite executar comandos externos usando go.

Neste guia, exploraremos como podemos usar o pacote EXEC para executar comandos externos.

Importando o pacote EXEC

Para usar o pacote EXEC, precisamos importá -lo. Podemos fazer isso usando um comando de importação simples como:

importar "OS/EXEC"

Uma vez importado, você pode executar comandos, como veremos neste artigo.

GOLANG EXECUTE COMANDOS

Vamos começar com uma chamada de comando básica para ilustrar como usar o pacote EXEC. Um código de exemplo é como mostrado abaixo:

Pacote principal
importação (
"FMT"
"registro"
"OS/EXEC"
)
funcmain ()
cmd: = executivo.Comando ("dir")
saída, err: = cmd.CombinedOutput ()
se err != nil
registro.Fatal (ERR)

fmt.Printf ("saída: \ n%s \ n", string (saída))

No exemplo acima, usamos o comando EXEC para obter a lista de arquivos e diretórios usando o comando dir Dir.

Começamos definindo o comando a ser executado usando o método de comando. A sintaxe é como mostrado:

Comando func (string name, arg… string) *cmd

A função leva os comandos para executar como um argumento de string. Em seguida, ele retorna uma estrutura de comando para executar o comando com os argumentos fornecidos.

A próxima etapa é executar o comando usando o método combinado. A sintaxe do método é como mostrado:

func (c *cmd) combinadaputput () ([] byte, erro)

O método executa o comando e retorna o stdout combinado e o stderr. Isso retorna uma fatia de byte, que convertemos em uma string usando o método da string.

Depois de executar o código acima, ele deve retornar os arquivos e diretórios no diretório de trabalho atual.

Defina o diretório de trabalho atual

Podemos definir o diretório de trabalho atual para executar o comando usando o CMD.Variável DIR. Um exemplo é como mostrado:

Pacote principal
importação (
"FMT"
"registro"
"OS/EXEC"
)
funcmain ()
cmd: = executivo.Comando ("dir")
cmd.Dir = "..."
saída, err: = cmd.CombinedOutput ()
se err != nil
registro.Fatal (ERR)

fmt.Printf ("saída: \ n%s \ n", string (saída))

Capture stdout e stderr separadamente.

Em vez de combinar o stdout e o stderr, você pode capturá -los separadamente, como mostrado no código abaixo:

cmd: = executivo.Comando ("dir")
cmd.Dir = "..."
var stdout, stderr bytes.Amortecedor
cmd.Stderr = & stderr
cmd.Stdout = & stdout
err: = cmd.Correr()
se err != nil
registro.Fatal (ERR)

saída, err: = string (stdout.Bytes ()), string (stderr.Bytes ())

Especifique o OS

Você também pode definir comandos personalizados para um sistema operacional diferente usando o tempo de execução.Método de gansas. Por exemplo:

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

Comandos de tubo

Você também pode colocar a saída de um comando anterior, como mostrado no exemplo acima:

Pacote principal
importação (
"FMT"
"registro"
"OS/EXEC"
)
funcmain ()
First_CMD: = 'Echo "Hello World" | WC -C '
cmd: = executivo.Command ("Bash", "-C", First_CMD)
saída, err: = cmd.CombinedOutput ()
se err != nil
registro.Fatal (ERR)

fmt.Printf ("output \ n%s \ n", string (saída))

O comando acima deve retornar o número de caracteres do comando echo.

Fechamento

Este curto guia ilustra como começar com o pacote EXEC em Golang.