何时使用 Ruby 中启动子进程的每种方法

Question

1. `` 反引号

• 在 内核

1. a) %x{} 百分比 X < 在 parse.y 中定义的反引号的替代语法

• ，请参阅 讨论

2. system()

• Kernel#system

3. fork ()

• Kernel#fork、Process#fork

4. open()

• 打开管道
• Kernel#open

4.a。 IO.popen() IO.popen() IO.popen() 相同

• 行为与 open()打开管道
• IO#popen

4.b。 open("|-")

• 分叉到管道

4.c. IO.popen("-") < 行为相同

• 与 open("|-") fork 到管道的
• ，请参阅

5. Open3.popen3()

• require 'open3'
• stdlib Open3

6. PTY.spawn()

• 需要'pty'
• stdlib PTY

7. Shell.transact()

• require 'shell'
• stdlib Shell

什么时候应该放弃可靠的反勾号以使用一种更复杂的方法？

编辑1。 非常感谢 Avdi Grimm 描述每种方法示例用法的帖子：#1 (& 要点); #2（& 要点）； #3。

它们是回答如何的绝佳资源，但没有明确地回答何时使用或为什么，因此恕我直言，它们不是这个问题的完整答案。

Answer 1

1. 当您想要轻松捕获变量中的程序输出时，请使用反引号。您可能只想将其用于短期运行的程序，因为这会阻塞。

2. system 在两种不同的情况下很方便：

   a.您有一个长时间运行的程序，并且希望在运行时打印输出（例如 system("tar zxvf some_big_tarball.tar.gz"))

   b. system 可以像 exec 一样绕过 shell 扩展（比较 system "echo *" 和 system "echo", "* “)

   系统会阻塞，直到子进程退出。

3. fork 也有几个不同的用例：

   a.您想要在单独的进程中运行一些 ruby​​ 代码（例如 fork { .... }

   b.您希望运行子进程（或不同的程序）而不阻止脚本的进度 fork { exec "bash" }。

   如果您想守护程序，

   fork 是您的朋友。

4. IO.popen 在您需要时很有用。与程序的标准输出和标准输入交互。它不会捕获标准错误，因此如果您关心的话，您需要使用 2>&1 重定向它。

5. popen3 为您提供一个单独的标准错误文件描述符（当您需要从标准输出中单独捕获该文件时）

6. 当您希望生成的程序像从终端运行一样时，

   PTY.spawn 是必需的。查看使用 system 生成时 grep --color=auto pat file 与 PTY.spawn

   PTY 的区别

Answer 2

这是基于此答案的流程图。另请参阅使用脚本模拟终端。

Answer 3

除了上面的流程图https://stackoverflow.com/a/30463900/1211266，以防有人想要它markdown 中的可编辑流程图（由 美人鱼），这里是：

```mermaid
flowchart TD

A{{"Do I want to return to my ruby script, ever?"}} -- No --> B(["Use exec()"])
A -- Yes --> C{{"Is it OK to block until the process completes?"}}
C -- Yes --> D{{"Do I need the program's output to be returned?"}}
D -- Yes --> E(["Use backticks `` or %x{}"])
D -- No --> F(["Use system()"])
C -- No --> H{{"Do I need to interact with the output?"}}
H -- Yes --> J{{"Do I want STDERR?"}}
H -- No --> I(["Use fork()"])
J -- Yes --> L{{"Do I want STDERR in its own separate stream?"}}
J -- No --> K(["Use IO.popen()"])
L -- Yes --> M(["Use Open3.popen3()"])
L -- No --> N{{"Use PTY.spawn()"}}

O>"Outputs to STDOUT"] -.- F
P>"You can always emulate a terminal with the BSD utility called script"] -.- H
Q>"Separate child process; good for daemonizing"] -.- I
R>"You can still use 2>&1 to combine STDERR with STDOUT"] -.- K
S>"Emulates a terminal unconditionally"] -.- M

classDef decision fill:#f8fb99;
classDef action fill:#ffaead;
classDef note fill:#ddd,opacity:0.9,font-weight:200;

class A,C,D,H,J,L decision;
class B,E,F,I,K,M,N action;
class O,P,Q,R,S note;
```

Answer 4

另外，还有 Process.spawn。来自文档：

此方法与 Kernel#system 类似，但它不等待
命令完成。

父进程应该使用Process.wait来收集终止信息
其子级的状态或使用 Process.detach 来注册不感兴趣
他们的地位；否则，操作系统可能会积累僵尸
流程。