详解Go语言中用 os/exec 执行命令的五种方法

郗珠

完整系列教程详见：http://golang.iswbm.com
在 Golang 中用于执行命令的库是

1. os/exec

复制代码

，exec.Command 函数返回一个

1. Cmd

复制代码

对象，根据不同的需求，可以将命令的执行分为三种情况

  

• 只执行命令，不获取结果  
  
• 执行命令，并获取结果（不区分 stdout 和 stderr）  
  
• 执行命令，并获取结果（区分 stdout 和 stderr）
  

第一种：只执行命令，不获取结果
直接调用 Cmd 对象的 Run 函数，返回的只有成功和失败，获取不到任何输出的结果。

1. package main
   
2. 
   
3. import (
   
4.         "log"
   
5.         "os/exec"
   
6. )
   
7. 
   
8. func main() {
   
9.         cmd := exec.Command("ls", "-l", "/var/log/")
   
10.         err := cmd.Run()
    
11.         if err != nil {
    
12.                 log.Fatalf("cmd.Run() failed with %s\n", err)
    
13.         }
    
14. }

复制代码

第二种：执行命令，并获取结果
有时候我们执行一个命令就是想要获取输出结果，此时你可以调用 Cmd 的 CombinedOutput 函数。

1. package main
   
2. 
   
3. import (
   
4. "fmt"
   
5. "log"
   
6. "os/exec"
   
7. )
   
8. 
   
9. func main() {
   
10.         cmd := exec.Command("ls", "-l", "/var/log/")
    
11.         out, err := cmd.CombinedOutput()
    
12.         if err != nil {
    
13. fmt.Printf("combined out:\n%s\n", string(out))
    
14.                 log.Fatalf("cmd.Run() failed with %s\n", err)
    
15.         }
    
16.         fmt.Printf("combined out:\n%s\n", string(out))
    
17. }

复制代码

CombinedOutput 函数，只返回 out，并不区分 stdout 和 stderr。如果你想区分他们，可以直接看第三种方法。

1. $ go run demo.go
   
2. combined out:
   
3. total 11540876
   
4. -rw-r--r-- 2 root root  4096 Oct 29 2018 yum.log
   
5. drwx------ 2 root root  94 Nov 6 05:56 audit
   
6. -rw-r--r-- 1 root root 185249234 Nov 28 2019 message
   
7. -rw-r--r-- 2 root root 16374 Aug 28 10:13 boot.log

复制代码

不过在那之前，我却发现一个小问题：有时候，shell 命令能执行，并不代码 exec 也能执行。
比如我只想查看

1. /var/log/

复制代码

目录下的 log 后缀名的文件呢？有点 Linux 基础的同学，都会用这个命令

1. $ ls -l /var/log/*.log
   
2. total 11540
   
3. -rw-r--r-- 2 root root  4096 Oct 29 2018 /var/log/yum.log
   
4. -rw-r--r-- 2 root root 16374 Aug 28 10:13 /var/log/boot.log

复制代码

按照这个写法将它放入到

1. exec.Command

复制代码

1. package main
   
2. 
   
3. import (
   
4. "fmt"
   
5. "log"
   
6. "os/exec"
   
7. )
   
8. 
   
9. func main() {
   
10.         cmd := exec.Command("ls", "-l", "/var/log/*.log")
    
11.         out, err := cmd.CombinedOutput()
    
12.         if err != nil {
    
13. fmt.Printf("combined out:\n%s\n", string(out))
    
14.                 log.Fatalf("cmd.Run() failed with %s\n", err)
    
15.         }
    
16.         fmt.Printf("combined out:\n%s\n", string(out))
    
17. }

复制代码

什么情况？居然不行，报错了。

1. $ go run demo.go
   
2. combined out:
   
3. ls: cannot access /var/log/*.log: No such file or directory
   
4. 
   
5. 2020/11/11 19:46:00 cmd.Run() failed with exit status 2
   
6. exit status 1

复制代码

为什么会报错呢？shell 明明没有问题啊
其实很简单，原来

1. ls -l /var/log/*.log

复制代码

并不等价于下面这段代码。

1. exec.Command("ls", "-l", "/var/log/*.log")

复制代码

上面这段代码对应的 Shell 命令应该是下面这样，如果你这样子写，ls 就会把参数里的内容当成具体的文件名，而忽略通配符

1. *

复制代码

1. $ ls -l "/var/log/*.log"
   
2. ls: cannot access /var/log/*.log: No such file or directory

复制代码

第三种：执行命令，并区分stdout 和 stderr
上面的写法，无法实现区分标准输出和标准错误，只要换成下面种写法，就可以实现。

1. package main
   
2. 
   
3. import (
   
4.         "bytes"
   
5.         "fmt"
   
6.         "log"
   
7.         "os/exec"
   
8. )
   
9. 
   
10. func main() {
    
11.         cmd := exec.Command("ls", "-l", "/var/log/*.log")
    
12.         var stdout, stderr bytes.Buffer
    
13.         cmd.Stdout = &stdout // 标准输出
    
14.         cmd.Stderr = &stderr // 标准错误
    
15.         err := cmd.Run()
    
16.         outStr, errStr := string(stdout.Bytes()), string(stderr.Bytes())
    
17.         fmt.Printf("out:\n%s\nerr:\n%s\n", outStr, errStr)
    
18.         if err != nil {
    
19.                 log.Fatalf("cmd.Run() failed with %s\n", err)
    
20.         }
    
21. }

复制代码

输出如下，可以看到前面的报错内容被归入到标准错误里

1. $ go run demo.go
   
2. out:
   
3. 
   
4. err:
   
5. ls: cannot access /var/log/*.log: No such file or directory
   
6. 
   
7. 2020/11/11 19:59:31 cmd.Run() failed with exit status 2
   
8. exit status 1

复制代码

第四种：多条命令组合，请使用管道
将上一条命令的执行输出结果，做为下一条命令的参数。在 Shell 中可以使用管道符

1. |

复制代码

来实现。
比如下面这条命令，统计了 message 日志中 ERROR 日志的数量。

1. $ grep ERROR /var/log/messages | wc -l
   
2. 19

复制代码

类似的，在 Golang 中也有类似的实现。

1. package main
   
2. import (
   
3. "os"
   
4. "os/exec"
   
5. )
   
6. func main() {
   
7. c1 := exec.Command("grep", "ERROR", "/var/log/messages")
   
8. c2 := exec.Command("wc", "-l")
   
9. c2.Stdin, _ = c1.StdoutPipe()
   
10. c2.Stdout = os.Stdout
    
11. _ = c2.Start()
    
12. _ = c1.Run()
    
13. _ = c2.Wait()
    
14. }

复制代码

输出如下

1. $ go run demo.go
   
2. 19

复制代码

第五种：设置命令级别的环境变量
使用 os 库的 Setenv 函数来设置的环境变量，是作用于整个进程的生命周期的。

1. package main
   
2. import (
   
3.         "fmt"
   
4.         "log"
   
5.         "os"
   
6.         "os/exec"
   
7. )
   
8. func main() {
   
9.         os.Setenv("NAME", "wangbm")
   
10.         cmd := exec.Command("echo", os.ExpandEnv("$NAME"))
    
11.         out, err := cmd.CombinedOutput()
    
12.         if err != nil {
    
13.                 log.Fatalf("cmd.Run() failed with %s\n", err)
    
14.         }
    
15.         fmt.Printf("%s", out)
    
16. }

复制代码

只要在这个进程里，

1. NAME

复制代码

这个变量的值都会是

1. wangbm

复制代码

，无论你执行多少次命令

1. $ go run demo.go
   
2. wangbm

复制代码

如果想把环境变量的作用范围再缩小到命令级别，也是有办法的。
为了方便验证，我新建个 sh 脚本，内容如下

1. $ cat /home/wangbm/demo.sh
   
2. echo $NAME
   
3. $ bash /home/wangbm/demo.sh # 由于全局环境变量中没有 NAME，所以无输出

复制代码

另外，demo.go 里的代码如下

1. package main
   
2. import (
   
3.         "fmt"
   
4.         "os"
   
5.         "os/exec"
   
6. )
   
7. 
   
8. 
   
9. func ChangeYourCmdEnvironment(cmd * exec.Cmd) error {
   
10.         env := os.Environ()
    
11.         cmdEnv := []string{}
    
12. 
    
13.         for _, e := range env {
    
14.                 cmdEnv = append(cmdEnv, e)
    
15.         }
    
16.         cmdEnv = append(cmdEnv, "NAME=wangbm")
    
17.         cmd.Env = cmdEnv
    
18. 
    
19.         return nil
    
20. }
    
21. 
    
22. func main() {
    
23.         cmd1 := exec.Command("bash", "/home/wangbm/demo.sh")
    
24. ChangeYourCmdEnvironment(cmd1) // 添加环境变量到 cmd1 命令: NAME=wangbm
    
25.         out1, _ := cmd1.CombinedOutput()
    
26.         fmt.Printf("output: %s", out1)
    
27. 
    
28.         cmd2 := exec.Command("bash", "/home/wangbm/demo.sh")
    
29.         out2, _ := cmd2.CombinedOutput()
    
30.         fmt.Printf("output: %s", out2)
    
31. }

复制代码

执行后，可以看到第二次执行的命令，是没有输出 NAME 的变量值。

1. $ go run demo.go
   
2. output: wangbm
   
3. output:

复制代码

到此这篇关于Go语言中用 os/exec 执行命令的五种方法的文章就介绍到这了,更多相关Go语言执行命令内容请搜索晓枫资讯以前的文章或继续浏览下面的相关文章希望大家以后多多支持晓枫资讯！

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

胜子妍荷

感谢楼主分享。

安道尔1

感谢楼主，顶。

安飒飒多么忻

顶顶更健康！！！