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 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用例的资料请关注脚本之家其它相关文章!