Go语言入门exec的基本使用示例

  • A+
所属分类:编程茶楼

Exec 是 os 包中的一个子包,它可用于使用 Go 运行外部命令。Go exec 命令教程展示了如何在 Golang 中执行 shell 命令和程序。

要使用这个包,我们需要按如下方式导入:

使用 GoLang exec 包运行命令

我们可以运行任何我们希望的命令。就像我们使用 CMD、bash 或其他一些 shell 来运行命令一样,它可以运行这些命令。

这是运行 ls 命令的示例。新建一个 main.go :

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

package main

import (

  "fmt"

  "os/exec"

)

func main() {

  cmd := exec.Command("ls")

  e := cmd.Run()

  CheckError(e)

}

func CheckError(e error) {

  if e != nil {

    fmt.Println(e)

  }

}

Run 函数启动指定命令并等待它完成,而 Start 启动指定命令但不等待它完成;我们需要使用Wait with Start。

然后新建一个 go.mod 文件:

1

2

3

4

$ go mod init main.go

go: creating new go.mod: module main.go

go: to add module requirements and sums:

  go mod tidy

现在,程序将运行,但我们不会看到控制台的任何输出。原因是命令运行,输出没有发送到标准输出。

所以,我们需要修复它。添加下面显示的两行以查看控制台的任何输出。

1

2

cmd.Stdout = os.Stdout

cmd.Stderr = os.Stderr

输出将显示当前目录中的文件。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

package main

import (

  "fmt"

  "os"

  "os/exec"

)

func main() {

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

  cmd.Stdout = os.Stdout

  cmd.Stderr = os.Stderr

  e := cmd.Run()

  CheckError(e)

}

func CheckError(e error) {

  if e != nil {

    fmt.Println(e)

  }

}

然后我们再程序,可以看到标准台输出如下的文件:

1

2

3

4

5

6

$ go run main.go

total 16

drwxr-xr-x   4 yuzhou_1su  staff   128B  5 15 22:56 .

drwxr-xr-x  23 yuzhou_1su  staff   736B  5 15 22:53 ..

-rw-r--r--   1 yuzhou_1su  staff    24B  5 15 22:56 go.mod

-rw-r--r--   1 yuzhou_1su  staff   248B  5 15 23:18 main.go

利用直接 ls 直接运行该命令,可以看到结果正确:

1

2

3

4

5

6

$ ls -alh

total 16

drwxr-xr-x   4 yuzhou_1su  staff   128B  5 15 22:56 .

drwxr-xr-x  23 yuzhou_1su  staff   736B  5 15 22:53 ..

-rw-r--r--   1 yuzhou_1su  staff    24B  5 15 22:56 go.mod

-rw-r--r--   1 yuzhou_1su  staff   248B  5 15 23:18 main.go

为不同的操作系统指定命令

我们可以指定针对不同操作系统运行不同的命令(例如 Linux 上的 bash 命令)。这是一个例子。

1

2

3

if runtime.GOOS == "linux" {

    cmd = exec.Command("ls")

}

为此,我们还需要导入运行时包。

要查看所有可能的操作系统,我们可以运行 go tool dist list ,它将显示所有可能的操作系统和 ARCH 组合。

Go exec 命令捕获输出

输出运行命令并返回其标准输出:

1

2

3

4

5

6

7

8

9

10

11

12

13

package main

import (

    "fmt"

    "log"

    "os/exec"

)

func main() {

    out, err := exec.Command("ls", "-l").Output()

    if err != nil {

        log.Fatal(err)

    }

    fmt.Println(string(out))

}

运行该程序:

1

2

3

4

$ go run main.go

total 16

-rw-r--r--  1 yuzhou_1su  staff   24  5 15 22:56 go.mod

-rw-r--r--  1 yuzhou_1su  staff  180  5 15 23:33 main.go

Go语言入门exec的基本使用示例

Go cmd.StdinPipe

管道允许我们将一个命令的输出发送到另一个命令。 StdinPipe 返回一个管道,该管道将在命令启动时连接到命令的标准输入。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

package main

import (

    "fmt"

    "io"

    "log"

    "os/exec"

)

func main() {

    cmd := exec.Command("cat")

    stdin, err := cmd.StdinPipe()

    if err != nil {

        log.Fatal(err)

    }

    go func() {

        defer stdin.Close()

        io.WriteString(stdin, "an old falcon")

    }()

    out, err := cmd.CombinedOutput()

    if err != nil {

        log.Fatal(err)

    }

    fmt.Printf("%s\n", out)

}

在代码示例中,我们将字符串写入 goroutine 内的标准输入。

1

cmd := exec.Command("cat")

cat 命令将给定的文件连接到标准输出。当没有给定文件或带有 - 时,该命令读取标准输入并将其打印到标准输出。

1

stdin, err := cmd.StdinPipe()

我们得到 cat 命令的标准输入管道。

1

2

3

4

go func() {

    defer stdin.Close()

    io.WriteString(stdin, "an old falcon")

}()

在 goroutine 内部,我们将一个字符串写入标准输入管道。

1

2

$ go run stdinpipe.go

an old falcon

Go cmd.StdoutPipe

StdoutPipe 返回一个管道,该管道将在命令启动时连接到命令的标准输出。

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

package main

import (

    "fmt"

    "io/ioutil"

    "log"

    "os/exec"

    "strings"

)

func upper(data string) string {

    return strings.ToUpper(data)

}

func main() {

    cmd := exec.Command("echo", "an old falcon")

    stdout, err := cmd.StdoutPipe()

    if err != nil {

        log.Fatal(err)

    }

    if err := cmd.Start(); err != nil {

        log.Fatal(err)

    }

    data, err := ioutil.ReadAll(stdout)

    if err != nil {

        log.Fatal(err)

    }

    if err := cmd.Wait(); err != nil {

        log.Fatal(err)

    }

    fmt.Printf("%s\n", upper(string(data)))

}

该示例通过管道读取 echo 命令的输出并将其转换为大写字母。

1

cmd := exec.Command("echo", "an old falcon")

要运行的命令是带有单个字符串参数的 echo 命令。

1

stdout, err := cmd.StdoutPipe()

我们得到标准输出管道。

1

2

3

if err := cmd.Start(); err != nil {

    log.Fatal(err)

}

该命令使用 Start 函数执行;它不会等待它完成。

1

data, err := ioutil.ReadAll(stdout)

我们从管道中读取数据。

1

2

3

if err := cmd.Wait(); err != nil {

    log.Fatal(err)

}

Wait 等待命令退出并等待任何复制到 stdin 或从 stdout 或 stderr 复制完成。它在看到命令退出后关闭管道。

运行该程序:

1

2

$ go run stdoutpipe.go

AN OLD FALCON

总结

os/exec 包运行外部命令。它包装了 os.StartProcess 以便更轻松地重新映射标准输入和标准输出、将 I/O 与管道连接以及进行其他调整。

参考链接:

https://zetcode.com/golang/exec-command/

以上就是Go语言入门exec的基本使用示例的详细内容,更多关于Go语言exec用例的资料请关注脚本之家其它相关文章!

  • 我的微信
  • 这是我的微信扫一扫
  • weinxin
  • 我的微信公众号
  • 我的微信公众号扫一扫
  • weinxin