如何在 Go 中操作系統

👨‍💻 簡介

昨天講到 os package，今天繼續補充 os package底下的 exec package，這個package主要用來執行外部指令和處理指令的輸入和輸出，包括如何設定指令、執行指令以及處理輸出等等。

設定指令

要執行外部指令，首先需要設定要執行的主要指令：

• exec.Command：接受一個指令名稱和多個參數，並返回一個 Cmd 對象。

語法如下：

func exec.Command(name string, arg ...string) *exec.Cmd

第一個參數是放要執行的命令名稱，第二個則是放參數。 接著來看看exec.Cmd是甚麼東西：

type Cmd struct {
	Path string        // the path of the command to run
	Args []string      // holds command line arguments
	Env []string       // the environment of the process
	Dir string         // the working directory of the command.
	Stdin io.Reader    // the process's standard input.
        Stdout io.Writer   // the process's standard output and error.
        Stderr io.Writer
        ....
}

可以看到exec.Command會回傳一個Cmd的struct。

以下是一個設定指令的簡單範例：

package main

import (
       "fmt"
       "os/exec"
)

func main() {

       cmd := exec.Command("ls", "-al")
       err := cmd.Run()
       if err != nil {
              fmt.Printf("failed to call cmd.Run(): %v", err)
       }
}

執行完沒有任何輸出是正常的，因為這個範例並沒有將標準輸出印出。如果要印出執行結果將cmd.Run改為cmd.Output即可：

package main

import (
       "fmt"
       "os/exec"
)

func main() {

       cmd := exec.Command("ls", "-al")
       output, err := cmd.Output()
       if err != nil {
              fmt.Printf("failed to call cmd.Output(): %v", err)
              return
       }

       fmt.Println("Command Output:")
       fmt.Println(string(output))
}

接著來快速介紹Cmd struct常用的欄位：

package main

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

func main() {
       cmd := exec.Command("ls", "-l")

       // 設定執行位置
       cmd.Dir = "/"
       
       // 將標準輸出和標準錯誤輸出到終端機
       cmd.Stdout = os.Stdout
       cmd.Stderr = os.Stderr

       // 執行並等待其完成
       err := cmd.Run()
       if err != nil {
              fmt.Println(err)
              return
       }
}

執行指令

• cmd.Run：執行指令並會等待指令完成，是cmd.Start和cmd.Wait的結合。
• cmd.Start：執行指令但不會等待指令完成。
• cmd.Wait：等待已經執行的指令，會阻塞程式，職到指令執行完畢。

package main

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

func main() {
       cmd := exec.Command("ls", "-l")

       // 執行指令
       err := cmd.Start()
       if err != nil {
              fmt.Println(err)
              return
       }
       // 等待指令完成
       err = cmd.Wait()
       if err != nil {
           log.Fatal(err)
       }
}

處理輸出

• cmd.Output：取得執行的標準輸出。
• cmd.CombinedOutput：取得執行的標準輸出和標準錯誤的合併結果。

取得標準輸出

package main

import (
       "fmt"
       "os/exec"
)

func main() {
       cmd := exec.Command("echo", "Hello, World!")

       // 取得執行的標準輸出
       output, err := cmd.Output()
       if err != nil {
              fmt.Println("failed to call cmd.Output(): %v", err)
              return
       }

       fmt.Println("Command Output:")
       fmt.Println(string(output))
}

取得標準輸出和標準錯誤的合併結果

package main

import (
       "fmt"
       "os/exec"
)

func main() {
       cmd := exec.Command("ls", "non-existent-directory")

       // 取得執行的標準輸出和標準錯誤的合併結果
       output, err := cmd.CombinedOutput()
       if err != nil {
              fmt.Println("Error:", err)
              return
       }

       fmt.Println("Command Output:")
       fmt.Println(string(output))
}

輸出的多種方式

因為cmd 的struct包含以下三個欄位，分別代表執行的標準輸入，標準輸出以及標準錯誤輸出，而io.Reader以及io.Writer皆為interface，因此只要滿足interface method的struct，即可完成讀取跟寫入

type Cmd struct {
	Stdin io.Reader    // the process's standard input.
        Stdout io.Writer   // the process's standard output and error.
        Stderr io.Writer
        ....
}

• 寫入檔案

package main

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

func main() {
       // 建立一個檔案，用於存儲標準輸出
       outFile, err := os.Create("output.txt")
       if err != nil {
              fmt.Println(err)
              return
       }
       defer outFile.Close()

       // 建立一個檔案，用於存儲標準錯誤
       errFile, err := os.Create("error.txt")
       if err != nil {
              fmt.Println(err)
              return
       }
       defer errFile.Close()

       // 設定執行指令，將標準輸出和標準錯誤重定向到檔案
       cmd := exec.Command("ls", "-l")
       cmd.Stdout = outFile
       cmd.Stderr = errFile

       // 執行並等待其完成
       err = cmd.Run()
       if err != nil {
              fmt.Println(err)
              return
       }
}

• 寫到終端

package main

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

func main() {
       cmd := exec.Command("ls", "-l")

       // 將標準輸出和標準錯誤輸出到終端機
       cmd.Stdout = os.Stdout
       cmd.Stderr = os.Stderr

       // 執行指令
       err := cmd.Start()
       if err != nil {
              fmt.Println(err)
              return
       }

       // 等待指令完成
       err = cmd.Wait()
       if err != nil {
           log.Fatal(err)
       }
}

因os.Create、os.Stdout和os.Stderr都會返回一個File struct，而該struct有滿足io.Writer的method -> Write，因此可以將標準輸出以及標準錯誤輸出給寫入檔案或是終端裡。

處理輸入

透過wc指令讀取main.go檔案，並計算總共多少行。

package main

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

func main() {
       stdin, err := os.Open("main.go")
       if err != nil {
              log.Fatalf("failed to open file: %v", err)
       }
       cmd := exec.Command("wc", "-l")
       cmd.Stdin = stdin
       cmd.Stdout = os.Stdout
       cmd.Stderr = os.Stderr
       err = cmd.Run()
       if err != nil {
              log.Fatalf("failed to call cmd.Run(): %v", err)
       }
}

Pipeline操作

• cmd.StderrPipe：返回一個連接到執行的標準錯誤的pipeline。
• cmd.StdinPipe：返回一個連接到執行的標準輸入的pipeline。
• cmd.StdoutPipe：返回一個連接到執行的標準輸出的pipeline。

package main

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

func main() {
       cmdCat := exec.Command("cat", "main.go")
       cmdWC := exec.Command("wc", "-l")

       // 建立一個pipeline，將 cat main.go 的輸出內容存放到 catout
       catout, err := cmdCat.StdoutPipe()
       if err != nil {
              log.Fatalf("failed to get StdoutPipe of cat: %v", err)
       }

       cmdWC.Stdin = catout     // 將 catout 當作 wc -l 的輸入
       cmdWC.Stdout = os.Stdout // 將 wc -l 的結果印到終端機上
       
       err = cmdCat.Start()
       if err != nil {
              log.Fatalf("failed to call cmdCat.Start():%v", err)
       }

       err = cmdWC.Start()
       if err != nil {
              log.Fatalf("failed to call cmdWC.Start():%v", err)
       }

       cmdCat.Wait()
       cmdWC.Wait()
}

通用pipeline方法

package main

import (
       "fmt"
       "os/exec"
)

func main() {
       cmdCat := exec.Command("cat", "main.go")
       cmdWC := exec.Command("wc", "-l")
       data, err := pipeCommands(cmdCat, cmdWC)
       if err != nil {
              fmt.Printf("failed to call pipeCommands(): %v", err)
       }
       fmt.Printf("output: %s", data)
}

func pipeCommands(commands ...*exec.Cmd) ([]byte, error) {
       for i, command := range commands[:len(commands)-1] {
              out, err := command.StdoutPipe()
              if err != nil {
                     return nil, err
              }
              command.Start()
              commands[i+1].Stdin = out
       }
       final, err := commands[len(commands)-1].Output()
       if err != nil {
              return nil, err
       }
       return final, nil
}

bash pipeline

cmd := exec.Command("bash", "-c", "cat main.go| wc -l")
data, err := cmd.CombinedOutput()
if err != nil {
	log.Fatalf("failed to call pipeCommands(): %v", err)
}
   log.Printf("output: %s", data)

📚 參考資料

• os/exec package - exec - Go packages
• Go os.exec 執行外部指令 - Gary Liao - Medium
• go os/exec 简明教程 (colobu.com)