咔叽游戏

 找回密码
 立即注册

QQ登录

只需一步,快速开始

搜索
查看: 400|回复: 0

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

[复制链接]
  • TA的每日心情
    无聊
    2019-6-2 14:11
  • 签到天数: 4 天

    [LV.2]圆转纯熟

    发表于 2020-12-19 14:37:10 | 显示全部楼层 |阅读模式
    完整系列教程详见:http://golang.iswbm.com
    在 Golang 中用于执行命令的库是 os/exec,exec.Command 函数返回一个 Cmd 对象,根据不同的需求,可以将命令的执行分为三种情况
      只执行命令,不获取结果执行命令,并获取结果(不区分 stdout 和 stderr)执行命令,并获取结果(区分 stdout 和 stderr)
    第一种:只执行命令,不获取结果
    直接调用 Cmd 对象的 Run 函数,返回的只有成功和失败,获取不到任何输出的结果。
    1. package main
    2. import (
    3.         "log"
    4.         "os/exec"
    5. )
    6. func main() {
    7.         cmd := exec.Command("ls", "-l", "/var/log/")
    8.         err := cmd.Run()
    9.         if err != nil {
    10.                 log.Fatalf("cmd.Run() failed with %s\n", err)
    11.         }
    12. }
    复制代码
    第二种:执行命令,并获取结果
    有时候我们执行一个命令就是想要获取输出结果,此时你可以调用 Cmd 的 CombinedOutput 函数。
    1. package main
    2. import (
    3. "fmt"
    4. "log"
    5. "os/exec"
    6. )
    7. func main() {
    8.         cmd := exec.Command("ls", "-l", "/var/log/")
    9.         out, err := cmd.CombinedOutput()
    10.         if err != nil {
    11. fmt.Printf("combined out:\n%s\n", string(out))
    12.                 log.Fatalf("cmd.Run() failed with %s\n", err)
    13.         }
    14.         fmt.Printf("combined out:\n%s\n", string(out))
    15. }
    复制代码
    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 也能执行。
    比如我只想查看 /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
    复制代码
    按照这个写法将它放入到 exec.Command
    1. package main
    2. import (
    3. "fmt"
    4. "log"
    5. "os/exec"
    6. )
    7. func main() {
    8.         cmd := exec.Command("ls", "-l", "/var/log/*.log")
    9.         out, err := cmd.CombinedOutput()
    10.         if err != nil {
    11. fmt.Printf("combined out:\n%s\n", string(out))
    12.                 log.Fatalf("cmd.Run() failed with %s\n", err)
    13.         }
    14.         fmt.Printf("combined out:\n%s\n", string(out))
    15. }
    复制代码
    什么情况?居然不行,报错了。
    1. $ go run demo.go
    2. combined out:
    3. ls: cannot access /var/log/*.log: No such file or directory
    4. 2020/11/11 19:46:00 cmd.Run() failed with exit status 2
    5. exit status 1
    复制代码
    为什么会报错呢?shell 明明没有问题啊
    其实很简单,原来 ls -l /var/log/*.log 并不等价于下面这段代码。
    1. exec.Command("ls", "-l", "/var/log/*.log")
    复制代码
    上面这段代码对应的 Shell 命令应该是下面这样,如果你这样子写,ls 就会把参数里的内容当成具体的文件名,而忽略通配符 *
    1. $ ls -l "/var/log/*.log"
    2. ls: cannot access /var/log/*.log: No such file or directory
    复制代码
    第三种:执行命令,并区分stdout 和 stderr
    上面的写法,无法实现区分标准输出和标准错误,只要换成下面种写法,就可以实现。
    1. package main
    2. import (
    3.         "bytes"
    4.         "fmt"
    5.         "log"
    6.         "os/exec"
    7. )
    8. func main() {
    9.         cmd := exec.Command("ls", "-l", "/var/log/*.log")
    10.         var stdout, stderr bytes.Buffer
    11.         cmd.Stdout = &stdout // 标准输出
    12.         cmd.Stderr = &stderr // 标准错误
    13.         err := cmd.Run()
    14.         outStr, errStr := string(stdout.Bytes()), string(stderr.Bytes())
    15.         fmt.Printf("out:\n%s\nerr:\n%s\n", outStr, errStr)
    16.         if err != nil {
    17.                 log.Fatalf("cmd.Run() failed with %s\n", err)
    18.         }
    19. }
    复制代码
    输出如下,可以看到前面的报错内容被归入到标准错误里
    1. $ go run demo.go
    2. out:
    3. err:
    4. ls: cannot access /var/log/*.log: No such file or directory
    5. 2020/11/11 19:59:31 cmd.Run() failed with exit status 2
    6. exit status 1
    复制代码
    第四种:多条命令组合,请使用管道
    将上一条命令的执行输出结果,做为下一条命令的参数。在 Shell 中可以使用管道符 | 来实现。
    比如下面这条命令,统计了 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. }
    复制代码
    只要在这个进程里,NAME 这个变量的值都会是 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. func ChangeYourCmdEnvironment(cmd * exec.Cmd) error {
    8.         env := os.Environ()
    9.         cmdEnv := []string{}
    10.         for _, e := range env {
    11.                 cmdEnv = append(cmdEnv, e)
    12.         }
    13.         cmdEnv = append(cmdEnv, "NAME=wangbm")
    14.         cmd.Env = cmdEnv
    15.         return nil
    16. }
    17. func main() {
    18.         cmd1 := exec.Command("bash", "/home/wangbm/demo.sh")
    19. ChangeYourCmdEnvironment(cmd1) // 添加环境变量到 cmd1 命令: NAME=wangbm
    20.         out1, _ := cmd1.CombinedOutput()
    21.         fmt.Printf("output: %s", out1)
    22.         cmd2 := exec.Command("bash", "/home/wangbm/demo.sh")
    23.         out2, _ := cmd2.CombinedOutput()
    24.         fmt.Printf("output: %s", out2)
    25. }
    复制代码
    执行后,可以看到第二次执行的命令,是没有输出 NAME 的变量值。
    1. $ go run demo.go
    2. output: wangbm
    3. output:
    复制代码
    到此这篇关于Go语言中用 os/exec 执行命令的五种方法的文章就介绍到这了,更多相关Go语言执行命令内容请搜索咔叽论坛以前的文章或继续浏览下面的相关文章希望大家以后多多支持咔叽论坛!

    原文地址:https://www.jb51.net/article/199819.htm

    QQ|免责声明|小黑屋|手机版|Archiver|咔叽游戏

    GMT+8, 2024-3-29 23:19

    Powered by Discuz! X3.4

    © 2001-2023 Discuz! Team.

    快速回复 返回顶部 返回列表