GO语言：与Shell进程通信

huangapple
go评论125阅读模式
英文:

GO lang : Communicate with shell process

问题

你可以使用io.WriteString函数将输入写入到in中，然后通过in.Close()关闭输入流。这样，你就可以执行shell脚本并读取结果了。以下是一个示例代码：

  1. package main
  3. import (
  4. 	"fmt"
  5. 	"io"
  6. 	"os/exec"
  7. )
  9. func main() {
  10. 	cmd := exec.Command("python", "add.py")
  11. 	in, _ := cmd.StdinPipe()
  13. 	go func() {
  14. 		defer in.Close()
  15. 		io.WriteString(in, "your_input_here")
  16. 	}()
  18. 	out, _ := cmd.Output()
  19. 	fmt.Println(string(out))
  20. }

在上面的代码中，我们使用io.WriteString将输入写入到in中，并通过in.Close()关闭输入流。然后，我们使用cmd.Output()获取脚本的输出结果，并将其打印出来。你可以将"your_input_here"替换为你想要提供给脚本的输入。

英文:

I want to execute a shell script from Go.
The shell script takes standard input and echoes the result.

I want to supply this input from GO and use the result.

What I am doing is:

  1.   cmd := exec.Command("python","add.py")  
  2.   in, _ := cmd.StdinPipe()

But how do I read from in?

答案1

得分: 7

以下是一段写入进程并从中读取的代码：

  1. package main
  3. import (
  4.     "bufio"
  5.     "fmt"
  6.     "os/exec"
  7. )
  9. func main() {
  10.     // 要计算的内容
  11.     calcs := make([]string, 2)
  12.     calcs[0] = "3*3"
  13.     calcs[1] = "6+6"
  15.     // 存储结果
  16.     results := make([]string, 2)
  18.     cmd := exec.Command("/usr/bin/bc")
  20.     in, err := cmd.StdinPipe()
  21.     if err != nil {
  22.         panic(err)
  23.     }
  25.     defer in.Close()
  27.     out, err := cmd.StdoutPipe()
  28.     if err != nil {
  29.         panic(err)
  30.     }
  32.     defer out.Close()
  34.     // 逐行读取
  35.     bufOut := bufio.NewReader(out)
  37.     // 启动进程
  38.     if err = cmd.Start(); err != nil {
  39.         panic(err)
  40.     }
  42.     // 将操作写入进程
  43.     for _, calc := range calcs {
  44.         _, err := in.Write([]byte(calc + "\n"))
  45.         if err != nil {
  46.             panic(err)
  47.         }
  48.     }
  50.     // 从进程中读取结果
  51.     for i := 0; i < len(results); i++ {
  52.         result, _, err := bufOut.ReadLine()
  53.         if err != nil {
  54.             panic(err)
  55.         }
  56.         results[i] = string(result)
  57.     }
  59.     // 查看计算结果
  60.     for _, result := range results {
  61.         fmt.Println(result)
  62.     }
  63. }

你可能希望在不同的 goroutine 中进行读写操作。

英文:

Here is some code writing to a process, and reading from it:

  1. package main
  2. import (
  3. &quot;bufio&quot;
  4. &quot;fmt&quot;
  5. &quot;os/exec&quot;
  6. )
  7. func main() {
  8. // What we want to calculate
  9. calcs := make([]string, 2)
  10. calcs[0] = &quot;3*3&quot;
  11. calcs[1] = &quot;6+6&quot;
  12. // To store the results
  13. results := make([]string, 2)
  14. cmd := exec.Command(&quot;/usr/bin/bc&quot;)
  15. in, err := cmd.StdinPipe()
  16. if err != nil {
  17. panic(err)
  18. }
  19. defer in.Close()
  20. out, err := cmd.StdoutPipe()
  21. if err != nil {
  22. panic(err)
  23. }
  24. defer out.Close()
  25. // We want to read line by line
  26. bufOut := bufio.NewReader(out)
  27. // Start the process
  28. if err = cmd.Start(); err != nil {
  29. panic(err)
  30. }
  31. // Write the operations to the process
  32. for _, calc := range calcs {
  33. _, err := in.Write([]byte(calc + &quot;\n&quot;))
  34. if err != nil {
  35. panic(err)
  36. }
  37. }
  38. // Read the results from the process
  39. for i := 0; i &lt; len(results); i++ {
  40. result, _, err := bufOut.ReadLine()
  41. if err != nil {
  42. panic(err)
  43. }
  44. results[i] = string(result)
  45. }
  46. // See what was calculated
  47. for _, result := range results {
  48. fmt.Println(result)
  49. }
  50. }

You might want to read/write from/to the process in different goroutines.

huangapple
  • 本文由 发表于 2014年3月7日 15:44:11
  • 转载请务必保留本文链接：https://go.coder-hub.com/22244341.html
  • go
  • ipc
  • process
  • stdin
  • stdout
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定