Como Executar Comandos da Shell com Go

Dando continuidade a Série Go veremos que executar comandos da shell com e obter conteúdo de variáveis de ambiente Go.

Executar Comandos da Shell

Para executar comandos da shell, você pode usar o pacote os/exec, que fornece funcionalidades para criar, executar e manipular comandos externos. Aqui está um exemplo de como executar um comando da shell e capturar sua saída:

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    // Comando a ser executado (exemplo: "ls -l")
    cmd := exec.Command("ls", "-l")

    // Executa o comando e captura a saída
    output, err := cmd.Output()
    if err != nil {
        fmt.Println("Erro ao executar o comando:", err)
        return
    }

    // Imprime a saída do comando
    fmt.Println(string(output))
}

Neste exemplo, o comando ls -l é executado e a saída é capturada e impressa. Vamos detalhar os passos:

Criação do Comando:

cmd := exec.Command("ls", "-l")

Aqui, exec.Command cria um comando para ser executado. O primeiro argumento é o nome do comando (ls) e os demais são os argumentos do comando (-l).

Execução do Comando e Captura da Saída:

output, err := cmd.Output()
cmd.Output() executa o comando e captura sua saída padrão. Se houver algum erro durante a execução, ele será retornado em err.

Tratamento de Erro:

if err != nil {
    fmt.Println("Erro ao executar o comando:", err)
    return
}

Se ocorrer um erro, ele é impresso e a função retorna.

Impressão da Saída:

fmt.Println(string(output))

A saída capturada, que é um slice de bytes, é convertida para string e impressa.

Executando Comandos com Input, Output e Error Separados

Se você precisar de mais controle sobre o comando, como separar a saída padrão e a saída de erro, pode usar os métodos cmd.StdoutPipe e cmd.StderrPipe. Aqui está um exemplo:

package main

import (
    "fmt"
    "io"
    "os"
    "os/exec"
)

func main() {
    // Comando a ser executado (exemplo: "ls -l")
    cmd := exec.Command("ls", "-l")

    // Obtém os pipes para stdout e stderr
    stdout, err := cmd.StdoutPipe()
    if err != nil {
        fmt.Println("Erro ao obter o pipe stdout:", err)
        return
    }

    stderr, err := cmd.StderrPipe()
    if err != nil {
        fmt.Println("Erro ao obter o pipe stderr:", err)
        return
    }

    // Inicia o comando
    if err := cmd.Start(); err != nil {
        fmt.Println("Erro ao iniciar o comando:", err)
        return
    }

    // Lê e imprime stdout
    go func() {
        if _, err := io.Copy(os.Stdout, stdout); err != nil {
            fmt.Println("Erro ao copiar stdout:", err)
        }
    }()

    // Lê e imprime stderr
    go func() {
        if _, err := io.Copy(os.Stderr, stderr); err != nil {
            fmt.Println("Erro ao copiar stderr:", err)
        }
    }()

    // Espera pelo término do comando
    if err := cmd.Wait(); err != nil {
        fmt.Println("Erro ao esperar pelo comando:", err)
    }
}

Neste exemplo, o comando ls -l é executado novamente, mas a saída padrão e a saída de erro são lidas e impressas separadamente em goroutines, proporcionando mais flexibilidade na manipulação da saída do comando.

Obter variáveis de ambiente com Go

Nesse exemplo básico obteremos o conteúdo da variável $PATH:

package main

import (
	"fmt"
	"os"
)

func main() {
	valor, existe := os.LookupEnv("SHELL")
	if existe {
		fmt.Println("Valor:", valor)
	} else {
		fmt.Println("Variável não encontrada")
	}
}

Até o próximo artigo da série!

series-go go