Golang Exec

El paquete EXEC se define en el paquete del sistema operativo. Es simplemente un subpackaje que le permite ejecutar comandos externos usando Go.

En esta guía, exploraremos cómo podemos usar el paquete EXEC para ejecutar comandos externos.

Importando el paquete EXEC

Para usar el paquete ejecutivo, necesitamos importarlo. Podemos hacer esto usando un comando de importación simple como:

Importar "OS/Exec"

Una vez importado, puede ejecutar comandos, como veremos en este artículo.

Comandos de ejecución de Golang

Comencemos con una llamada de comando básica para ilustrar cómo usar el paquete EXEC. Un código de ejemplo es como se muestra a continuación:

paquete principal
importar (
"FMT"
"registro"
"OS/Exec"
)
funcmain ()
cmd: = ejecutor.Comando ("Dir")
salida, err: = cmd.CombinedOutput ()
Si err != nulo
registro.Fatal (err)

fmt.Printf ("Salida: \ n%s \ n", cadena (salida))

En el ejemplo anterior, usamos el comando EXEC para obtener la lista de archivos y directorios utilizando el comando Dir.

Comenzamos definiendo el comando para ejecutar usando el método de comando. La sintaxis es como se muestra:

comando func (name string, arg ... cadena) *cmd

La función toma los comandos para ejecutar como argumento de cadena. Luego devuelve una estructura de comando para ejecutar el comando con los argumentos proporcionados.

El siguiente paso es ejecutar el comando usando el método combinado. La sintaxis del método es como se muestra:

func (c *cmd) combinedOutput () ([] byte, error)

El método ejecuta el comando y devuelve el STDOUT combinado y stderr. Esto devuelve una porción de byte, que convertimos en una cadena utilizando el método de cadena.

Una vez que ejecute el código anterior, debe devolver los archivos y directorios en el directorio de trabajo actual.

Establezca el directorio de trabajo actual

Podemos definir el directorio de trabajo actual en el que ejecutar el comando utilizando el CMD.Variable Dir. Un ejemplo es como se muestra:

paquete principal
importar (
"FMT"
"registro"
"OS/Exec"
)
funcmain ()
cmd: = ejecutor.Comando ("Dir")
CMD.Dir = "..."
salida, err: = cmd.CombinedOutput ()
Si err != nulo
registro.Fatal (err)

fmt.Printf ("Salida: \ n%s \ n", cadena (salida))

Capturar Stdout y Stderr por separado.

En lugar de combinar Stdout y Stderr, puede capturarlos por separado como se muestra en el código a continuación:

cmd: = ejecutor.Comando ("Dir")
CMD.Dir = "..."
var stdout, stderr bytes.Buffer
CMD.Stderr = & stderr
CMD.Stdout = & stdout
err: = cmd.Correr()
Si err != nulo
registro.Fatal (err)

salida, err: = string (stdout.Bytes ()), cadena (stderr.Bytes ())

Especificar OS

También puede definir comandos personalizados para un sistema operativo diferente utilizando el tiempo de ejecución.Método Goos. Por ejemplo:

ifruntime.Goos == "Windows"
cmd = ejecutor.Comando ("Dir")

Comandos de tubería

También puede abordar la salida de un comando anterior como se muestra en el ejemplo anterior:

paquete principal
importar (
"FMT"
"registro"
"OS/Exec"
)
funcmain ()
First_CMD: = 'echo "Hello World" | WC -C '
cmd: = ejecutor.Comando ("bash", "-c", first_cmd)
salida, err: = cmd.CombinedOutput ()
Si err != nulo
registro.Fatal (err)

fmt.Printf ("salida \ n%s \ n", cadena (salida))

El comando anterior debe devolver el número de caracteres del comando echo.

Clausura

Esta breve guía ilustra cómo comenzar con el paquete EXEC en Golang.