Go Em Exemplos: Spawning Processes

Por vezes é necessário que programas em Go invoquem processos ou programas não-Go.
	package main
	import ( "fmt" "io" "os/exec" )
	func main() {
De início será utilizado um simples comando que não recebe nenhum argumento ou input e apenas imprime algo no `stdout`. O comando `exec.Command` cria um objeto para representar este processo externo.	dateCmd := exec.Command("date")
O método `Output` executa o comando, aguarda sua finalização e coleta o output padrão. Se não houver nenhum erro, `dateOut` terá os bytes com informação da data.	dateOut, err := dateCmd.Output() if err != nil { panic(err) } fmt.Println("> date") fmt.Println(string(dateOut))
`Output` e outros métodos de `Command` retornarão um `exec.Error` se houver algum problema ao executar o comando, como por exemplo caminho errado, e `exec.ExitError` se o comando foi executado mas retornou com um código não-zero.	_, err = exec.Command("date", "-x").Output() if err != nil { switch e := err.(type) { case exec.Error: fmt.Println("failed executing:", err) case exec.ExitError: fmt.Println("command exit rc =", e.ExitCode()) default: panic(err) } }
Agora será apresentado um caso um pouco mais complexo em que é enviado um dado para o processo externo em seu `stdin`, através de um pipe e coletado o resultado a partir de seu `stdout` também a partir de um pipe.	grepCmd := exec.Command("grep", "hello")
Aqui se instancia os pipes, inicializa o próprio processo, então escreve e envia algum input, lê o resultado de saída e, finalmente, aguarda o processo finalizar.	grepIn, _ := grepCmd.StdinPipe() grepOut, _ := grepCmd.StdoutPipe() grepCmd.Start() grepIn.Write([]byte("hello grep\ngoodbye grep")) grepIn.Close() grepBytes, _ := io.ReadAll(grepOut) grepCmd.Wait()
Verificação de erros foram omitidas no exemplo acima, mas é possível utilizar o padrão usual `if err != nil` para todos eles. Também foi coletado apenas o resultado de `StdoutPipe`, mas é possível também coletar de `StderrPipe` exatamente do mesmo jeito.	fmt.Println("> grep hello") fmt.Println(string(grepBytes))
Note que, ao invocar comandos, é necessário fornecer um comando explicitamente delineado e um array de argumentos ao invés de passar apenas uma string de linha de comando command-line string. Se a intenção for gerar um comando com uma string, é possível utilizar a flag `-c` do `bash`.	lsCmd := exec.Command("bash", "-c", "ls -a -l -h") lsOut, err := lsCmd.Output() if err != nil { panic(err) } fmt.Println("> ls -a -l -h") fmt.Println(string(lsOut)) }

Os processos invocados retornam o mesmo output que
retornaria se fosse executado diretamente da linha de comando.

$ go run spawning-processes.go 
> date
Thu 05 May 2022 10:10:12 PM PDT

date não possui uma flag -x, então será finalizado com mensagem de erro e código de retorno não-zero.

command exited with rc = 1
> grep hello
hello grep

> ls -a -l -h
drwxr-xr-x  4 mark 136B Oct 3 16:29 .
drwxr-xr-x 91 mark 3.0K Oct 3 12:50 ..
-rw-r--r--  1 mark 1.3K Oct 3 16:28 spawning-processes.go

Próximo exemplo: Executing Processes.