在 Go 中执行 shell 命令

Question

我希望在 Go 中执行 shell 命令，并在程序中以字符串形式获取结果输出。我看到了 Rosetta Code 版本：

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()

但这并没有捕获实际的标准输出或错误我可以以编程方式访问的方式 - 这些仍然打印到常规标准输出/标准错误。我发现使用 Pipe 作为 out 或 err 可以在其他地方有所帮助，但没有说明如何这样做的示例。有什么想法吗？

Answer 1

“exec”包改变了一点。以下代码对我有用。

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    app := "echo"

    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 {
        fmt.Println(err.Error())
        return
    }

    // Print the output
    fmt.Println(string(stdout))
}

Answer 2

提供的答案都不允许将 stdout 和 stderr 分开，所以我尝试另一个答案。

首先，如果您查看 os/exec 包中的 exec.Cmd 类型的文档，您将获得所需的所有信息。看这里：https://golang.org/pkg/os/exec/#Cmd

尤其是成员 Stdin 和 Stdout、Stderr，其中任何 io.Reader 都可以用于提供 新创建进程的 stdin 和任何 io.Writer 都可用于使用命令的 stdout 和 stderr。

以下程序中的函数 Shellout 将运行您的命令，并将其输出和错误输出分别作为字符串传递给您。

由于参数值作为 shell 命令执行，因此需要清理
参数构造中使用的所有外部输入
价值。

可能不会在生产中以这种形式使用它。

package main

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

const ShellToUse = "bash"

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

func main() {
    out, errout, err := 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 3

此答案并不代表 Go 标准库的当前状态。请查看 @Lourenco 的回答以获取最新方法！

---

您的示例实际上并未读取来自标准输出的数据。这对我有用。

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 4

// Wrap exec, with option to use bash shell

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
    }
}

你可以试试这个。

Answer 5

package main

import (
    "fmt"
    "os/exec"
)

func main() {
    cmd := exec.Command("cmd", "/C", "dir")
    output, err := cmd.Output()

    if err != nil {
        fmt.Println("Error executing command:", err)
        return
    }

    fmt.Println(string(output))
}

使用 exec.Command 函数创建一个新的 cmd 进程，并使用 /C 标志和 dir 命令作为其参数
使用output()方法捕获输出并打印它。

Answer 6

这是一个简单的函数，它将运行您的命令并捕获错误、标准输出和标准错误以供您检查。您可以轻松地看到任何可能出现问题或向您报告的情况。

// 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
}

你可以像这样使用它（转换媒体文件）：

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)
}

我在 Go 1.2-1.7 中使用过它

Answer 7

如果您希望异步运行长时间运行的脚本并显示执行进度，您可以使用io.MultiWriter捕获命令输出并将其转发到stdout/stderr ：

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

var stdoutBuf, stderrBuf bytes.Buffer

cmd := exec.Command("/some-command")

cmd.Stdout = io.MultiWriter(os.Stdout, &stdoutBuf)
cmd.Stderr = io.MultiWriter(os.Stderr, &stderrBuf)

err := cmd.Start()  // Starts command asynchronously

if err != nil {
    fmt.Printf(err.Error())
}

Answer 8

import (
    "github.com/go-cmd/cmd"
)

const DefaultTimeoutTime = "1m"

func RunCMD(name string, args ...string) (err error, stdout, stderr []string) {
    c := cmd.NewCmd(name, args...)
    s := <-c.Start()
    stdout = s.Stdout
    stderr = s.Stderr
    return
}

去测试

import (
    "fmt"
    "gotest.tools/assert"
    "testing"
)

func TestRunCMD(t *testing.T) {
    err, stdout, stderr := RunCMD("kubectl", "get", "pod", "--context", "cluster")
    assert.Equal(t, nil, err)
    for _, out := range stdout {
        fmt.Println(out)
    }
    for _, err := range stderr {
        fmt.Println(err)
    }
}

Answer 9

我没有让 Rosetta 示例在我的 Windows Go 中运行。最后，我设法使用此命令超越子进程的旧格式，在 Windows 的记事本中启动 outfile。一本手册中提到的 wait 常量参数并不存在，所以我只是省略了 Wait，因为用户将自行关闭程序或将其保持打开状态以供重用。

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}})

您可以将 os.Stdout.. 更改为 os.Pipe 作为先前的答案

编辑：我终于从 godoc os 等待中得到了它，等待已更改为方法，并且我成功地做到了：

   defer p.Wait(0)

然后我最终决定改为放置

   defer p.Release()

。

Answer 10

我最终这样做是为了获取退出错误代码、命令输出和错误：

parts := strings.Split("netstat -tupln", " ")
cmd := exec.Command(parts[0], parts[1:]...)
out, err := cmd.Output()
exitCode := cmd.ProcessState.ExitCode()

在上面答案（以及 stackoverflow 上的其他问题）的帮助下，希望这对某人有帮助。

Answer 11

这是使用 cmdx 库的一个很好的替代方案，它使执行命令和捕获输出更简单、更

package main

import (
    "github.com/kgs19/cmdx"
    "log"
)

func main() {
    command := "date"
    args := []string{"+%H:%M"}
    out, err := cmdx.RunCommandReturnOutput(command, args...)
    if err != nil {
        log.Fatalf("Error executing 'date' command: %v", err)
    }
    println("cmd output: " + out)
}

：

• 直观 code>cmdx.RunCommandReturnOutput(command, args...)：此函数使用给定参数运行指定命令，并将输出作为字符串返回。

有关更多信息，请查看 GitHub 存储库。