run - Ejecutar un comando de shell en Go

shellexecute vb6

Question

Estoy buscando ejecutar un comando de shell en Go y obtener el resultado resultante como una cadena en mi programa. Vi la versión del Código Rosetta :

package main
import "fmt"
import "exec"

func main() {
  cmd, err := exec.Run("/bin/ls", []string{"/bin/ls"}, []string{}, "", exec.DevNull, exec.PassThrough, exec.PassThrough)
  if (err != nil) {
    fmt.Println(err)
    return
  }
  cmd.Close()

Pero esto no captura el estándar real ni se equivoca de una manera a la que puedo acceder mediante programación, los que aún se imprimen en la entrada estándar stdout / stderr. Vi que usar Pipe como salida o error podría ayudar en otra parte, pero no hay ejemplo de cómo hacerlo. ¿Algunas ideas?

Answer 1

Aquí hay una función simple que ejecutará su comando y capturará el error, stdout y stderr para que los inspeccione. Puede ver fácilmente cualquier cosa que pueda salir mal o que se le informe.

// RunCMD is a simple wrapper around terminal commands
func RunCMD(path string, args []string, debug bool) (out string, err error) {

    cmd := exec.Command(path, args...)

    var b []byte
    b, err = cmd.CombinedOutput()
    out = string(b)

    if debug {
        fmt.Println(strings.Join(cmd.Args[:], " "))

        if err != nil {
            fmt.Println("RunCMD ERROR")
            fmt.Println(out)
        }
    }

    return
}

Puedes usarlo así (Convertir un archivo de medios):

args := []string{"-y", "-i", "movie.mp4", "movie_audio.mp3", "INVALID-ARG!"}
output, err := RunCMD("ffmpeg", args, true)

if err != nil {
    fmt.Println("Error:", output)
} else {
    fmt.Println("Result:", output)
}

He usado esto con Go 1.2-1.7

Answer 2

El paquete "exec" fue changed un poco. El siguiente code funcionó para mí.

package main

import "os/exec"

func main() {
    app := "echo"
    //app := "buah"

    arg0 := "-e"
    arg1 := "Hello world"
    arg2 := "/n/tfrom"
    arg3 := "golang"

    cmd := exec.Command(app, arg0, arg1, arg2, arg3)
    stdout, err := cmd.Output()

    if err != nil {
        println(err.Error())
        return
    }

    print(string(stdout))
}

¡Espero que esto ayude!

Answer 3

Ninguna de las respuestas proporcionadas permite separar stdout y stderr así que intento otra respuesta.

Primero obtiene toda la información que necesita, si observa la documentación del tipo exec.Cmd en el paquete os/exec . Mire aquí: https://golang.org/pkg/os/exec/#Cmd

Especialmente los miembros Stdin y Stdout , Stderr donde se puede usar cualquier io.Reader para alimentar la stdin de su proceso recién creado y cualquier io.Writer se puede usar para consumir stdout y stderr de su comando.

La función Shellout en el siguiente programa ejecutará su comando y le entregará su salida y la salida de error separadamente como cadenas:

package main

import (
    "bytes"
    "fmt"
    "log"
    "os/exec"
)

const ShellToUse = "bash"

func Shellout(command string) (error, string, string) {
    var stdout bytes.Buffer
    var stderr bytes.Buffer
    cmd := exec.Command(ShellToUse, "-c", command)
    cmd.Stdout = &stdout
    cmd.Stderr = &stderr
    err := cmd.Run()
    return err, stdout.String(), stderr.String()
}

func main() {
    err, out, errout := Shellout("ls -ltr")
    if err != nil {
        log.Printf("error: %v/n", err)
    }
    fmt.Println("--- stdout ---")
    fmt.Println(out)
    fmt.Println("--- stderr ---")
    fmt.Println(errout)
}

Answer 4

No obtuve el ejemplo de Rosetta para trabajar en mi Windows Go. Finalmente, logré pasar el formato antiguo del Subproceso con este comando para iniciar el archivo en el bloc de notas en Windows. El parámetro de constante de espera mencionado en un manual no existía, así que simplemente lo dejé en espera. El usuario cerrará el programa por sí mismo o lo dejará abierto para volver a utilizarlo.

p, err := os.StartProcess(`c:/windows/system32/notepad.EXE`,
    []string{`c:/windows/system32/notepad.EXE`, outfile},
    &os.ProcAttr{Env: nil, Dir: "", Files:  []*os.File{os.Stdin, os.Stdout, os.Stderr}})

Cambiaría os.Stdout ... a os.Pipe como respuesta anterior

EDIT: Finalmente lo obtuve de godoc os Wait, que Wait ha cambiado de método y lo logré:

   defer p.Wait(0)

Entonces decidí finalmente poner

   defer p.Release()

en lugar.

Answer 5

Esta respuesta no representa el estado actual de la biblioteca estándar de Go. ¡Por favor, eche un vistazo a la respuesta de @ Lourenco para obtener un método actualizado!

Tu ejemplo no lee realmente los datos de la salida estándar. Esto funciona para mi

package main

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

func main() {
    app := "/bin/ls"
    cmd, err := exec.Run(app, []string{app, "-l"}, nil, "", exec.DevNull, exec.Pipe, exec.Pipe)

    if (err != nil) {
       fmt.Fprintln(os.Stderr, err.String())
       return
    }

    var b bytes.Buffer
    io.Copy(&b, cmd.Stdout)
    fmt.Println(b.String())

    cmd.Close()
}

Answer 6

// 封装exec ，有shell= true 这样的选项

func Cmd(cmd string, shell bool) []byte {

if shell {
    out, err := exec.Command("bash", "-c", cmd).Output()
    if err != nil {
        panic("some error found")
    }
    return out
} else {
    out, err := exec.Command(cmd).Output()
    if err != nil {
        panic("some error found")
    }
    return out

}
}

puedes probar esto