模块 Open3

模块 Open3 支持创建可以访问其 $stdin、$stdout 和 $stderr 流的子进程。

这里有什么¶ ↑

这些方法中的每一个都在新进程或子 shell 中执行给定的命令，或者在新进程和/或子 shell 中执行多个命令

这些方法中的每一个都在进程或子 shell 中执行单个命令，接受字符串作为 $stdin 的输入，并从 $stdout、$stderr 或两者返回字符串输出
- Open3.capture2：执行命令；返回来自 $stdout 的字符串。
- Open3.capture2e：执行命令；返回来自合并的 $stdout 和 $stderr 的字符串。
- Open3.capture3：执行命令；返回来自 $stdout 和 $stderr 的字符串。
这些方法中的每一个都在进程或子 shell 中执行单个命令，并返回用于 $stdin、$stdout 和/或 $stderr 的管道
- Open3.popen2：执行命令；返回用于 $stdin 和 $stdout 的管道。
- Open3.popen2e：执行命令；返回用于 $stdin 和合并的 $stdout 和 $stderr 的管道。
- Open3.popen3：执行命令；返回用于 $stdin、$stdout 和 $stderr 的管道。
这些方法中的每一个都在进程和/或子 shell 中执行一个或多个命令，并返回用于第一个 $stdin、最后一个 $stdout 或两者的管道
- Open3.pipeline_r：返回用于最后一个 $stdout 的管道。
- Open3.pipeline_rw：返回用于第一个 $stdin 和最后一个 $stdout 的管道。
- Open3.pipeline_w：返回用于第一个 $stdin 的管道。
- Open3.pipeline_start：不等待进程完成。
- Open3.pipeline：等待进程完成。

上述每个方法都接受

环境变量名称和值的可选哈希；请参阅执行环境。
必需的字符串参数，它是 command_line 或 exe_path；请参阅参数 command_line 或 exe_path。
执行选项的可选哈希；请参阅执行选项。

常量

VERSION

公共类方法

capture2([env, ] command_line, options = {}) → [stdout_s, status]

capture2([env, ] exe_path, *args, options = {}) → [stdout_s, status]

源

# File lib/open3.rb, line 775
def capture2(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data)
  binmode = opts.delete(:binmode)

  popen2(*cmd, opts) {|i, o, t|
    if binmode
      i.binmode
      o.binmode
    end
    out_reader = Thread.new { o.read }
    if stdin_data
      begin
        if stdin_data.respond_to? :readpartial
          IO.copy_stream(stdin_data, i)
        else
          i.write stdin_data
        end
      rescue Errno::EPIPE
      end
    end
    i.close
    [out_reader.value, t.value]
  }
end

基本上是 Open3.popen3 的包装器，它

通过使用给定的参数（除了哈希 options 中的某些条目；请参见下文）调用 Open3.popen3 来创建子进程。
以字符串 stdout_s 的形式返回子进程的标准输出。
以 status 的形式返回一个 Process::Status 对象，该对象表示子进程的退出状态。

返回数组 [stdout_s, status]

stdout_s, status = Open3.capture2('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326047 exit 0>]

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Open3.popen3 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Open3.popen3 中的尾随参数 options；请参阅执行选项。

给出哈希 options；两个选项在方法 Open3.capture2 中具有局部作用

如果存在条目 options[:stdin_data]，则删除该条目，并将其字符串值发送到命令的标准输入
```
Open3.capture2('tee', stdin_data: 'Foo')

# => ["Foo", #<Process::Status: pid 2326087 exit 0>]
```
如果存在条目 options[:binmode]，则删除该条目，并将内部流设置为二进制模式。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.capture2('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", #<Process::Status: pid 2326131 exit 0>]
Open3.capture2('echo')                         # Built-in.
# => ["\n", #<Process::Status: pid 2326139 exit 0>]
Open3.capture2('date > date.tmp')              # Contains meta character.
# => ["", #<Process::Status: pid 2326174 exit 0>]

命令行也可能包含命令的参数和选项

Open3.capture2('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326183 exit 0>]

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.capture2('/usr/bin/date')
# => ["Fri Sep 29 01:00:39 PM CDT 2023\n", #<Process::Status: pid 2326222 exit 0>]

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.capture2('doesnt_exist') # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.capture2('echo', 'C #')
# => ["C #\n", #<Process::Status: pid 2326267 exit 0>]
Open3.capture2('echo', 'hello', 'world')
# => ["hello world\n", #<Process::Status: pid 2326299 exit 0>]

capture2e([env, ] command_line, options = {}) → [stdout_and_stderr_s, status]

capture2e([env, ] exe_path, *args, options = {}) → [stdout_and_stderr_s, status]

源

# File lib/open3.rb, line 902
def capture2e(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data)
  binmode = opts.delete(:binmode)

  popen2e(*cmd, opts) {|i, oe, t|
    if binmode
      i.binmode
      oe.binmode
    end
    outerr_reader = Thread.new { oe.read }
    if stdin_data
      begin
        if stdin_data.respond_to? :readpartial
          IO.copy_stream(stdin_data, i)
        else
          i.write stdin_data
        end
      rescue Errno::EPIPE
      end
    end
    i.close
    [outerr_reader.value, t.value]
  }
end

基本上是 Open3.popen3 的包装器，它

通过使用给定的参数（除了哈希 options 中的某些条目；请参见下文）调用 Open3.popen3 来创建子进程。
以字符串 stdout_and_stderr_s 的形式返回子进程的合并标准输出和标准错误。
以 status 的形式返回一个 Process::Status 对象，该对象表示子进程的退出状态。

返回数组 [stdout_and_stderr_s, status]

stdout_and_stderr_s, status = Open3.capture2e('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2371692 exit 0>]

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Open3.popen3 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Open3.popen3 中的尾随参数 options；请参阅执行选项。

给出哈希 options；两个选项在方法 Open3.capture2e 中具有局部作用

如果存在条目 options[:stdin_data]，则删除该条目，并将其字符串值发送到命令的标准输入
```
Open3.capture2e('tee', stdin_data: 'Foo')
# => ["Foo", #<Process::Status: pid 2371732 exit 0>]
```
如果存在条目 options[:binmode]，则删除该条目，并将内部流设置为二进制模式。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.capture2e('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", #<Process::Status: pid 2371740 exit 0>]
Open3.capture2e('echo')                         # Built-in.
# => ["\n", #<Process::Status: pid 2371774 exit 0>]
Open3.capture2e('date > date.tmp')              # Contains meta character.
# => ["", #<Process::Status: pid 2371812 exit 0>]

命令行也可能包含命令的参数和选项

Open3.capture2e('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326183 exit 0>]

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.capture2e('/usr/bin/date')
# => ["Sat Sep 30 09:01:46 AM CDT 2023\n", #<Process::Status: pid 2371820 exit 0>]

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.capture2e('doesnt_exist') # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.capture2e('echo', 'C #')
# => ["C #\n", #<Process::Status: pid 2371856 exit 0>]
Open3.capture2e('echo', 'hello', 'world')
# => ["hello world\n", #<Process::Status: pid 2371894 exit 0>]

capture3([env, ] command_line, options = {}) → [stdout_s, stderr_s, status]

capture3([env, ] exe_path, *args, options = {}) → [stdout_s, stderr_s, status]

源

# File lib/open3.rb, line 648
def capture3(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data) || ''
  binmode = opts.delete(:binmode)

  popen3(*cmd, opts) {|i, o, e, t|
    if binmode
      i.binmode
      o.binmode
      e.binmode
    end
    out_reader = Thread.new { o.read }
    err_reader = Thread.new { e.read }
    begin
      if stdin_data.respond_to? :readpartial
        IO.copy_stream(stdin_data, i)
      else
        i.write stdin_data
      end
    rescue Errno::EPIPE
    end
    i.close
    [out_reader.value, err_reader.value, t.value]
  }
end

基本上是 Open3.popen3 的包装器，它

通过使用给定的参数（除了哈希 options 中的某些条目；请参见下文）调用 Open3.popen3 来创建子进程。
以字符串 stdout_s 和 stderr_s 的形式返回子进程的标准输出和标准错误。
以 status 的形式返回一个 Process::Status 对象，该对象表示子进程的退出状态。

返回数组 [stdout_s, stderr_s, status]

stdout_s, stderr_s, status = Open3.capture3('echo "Foo"')
# => ["Foo\n", "", #<Process::Status: pid 2281954 exit 0>]

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Open3.popen3 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Open3.popen3 中的尾随参数 options；请参阅执行选项。

给出哈希 options；两个选项在方法 Open3.capture3 中具有局部作用

如果存在条目 options[:stdin_data]，则删除该条目，并将其字符串值发送到命令的标准输入
```
Open3.capture3('tee', stdin_data: 'Foo')
# => ["Foo", "", #<Process::Status: pid 2319575 exit 0>]
```
如果存在条目 options[:binmode]，则删除该条目，并将内部流设置为二进制模式。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.capture3('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", "", #<Process::Status: pid 2282025 exit 0>]
Open3.capture3('echo')                         # Built-in.
# => ["\n", "", #<Process::Status: pid 2282092 exit 0>]
Open3.capture3('date > date.tmp')              # Contains meta character.
# => ["", "", #<Process::Status: pid 2282110 exit 0>]

命令行也可能包含命令的参数和选项

Open3.capture3('echo "Foo"')
# => ["Foo\n", "", #<Process::Status: pid 2282092 exit 0>]

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.capture3('/usr/bin/date')
# => ["Thu Sep 28 05:03:51 PM CDT 2023\n", "", #<Process::Status: pid 2282300 exit 0>]

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.capture3('doesnt_exist') # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.capture3('echo', 'C #')
# => ["C #\n", "", #<Process::Status: pid 2282368 exit 0>]
Open3.capture3('echo', 'hello', 'world')
# => ["hello world\n", "", #<Process::Status: pid 2282372 exit 0>]

pipeline([env, ] *cmds, options = {}) → array_of_statuses

源

# File lib/open3.rb, line 1334
def pipeline(*cmds)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  pipeline_run(cmds, opts, [], []) {|ts|
    ts.map(&:value)
  }
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
将每个子进程的 stdout 管道到下一个子进程的 stdin，或者，对于最后一个子进程，管道到调用者的 stdout。
等待子进程退出。
返回 Process::Status 对象的数组（每个子进程一个）。

示例

wait_threads = Open3.pipeline('ls', 'grep R')
# => [#<Process::Status: pid 2139200 exit 0>, #<Process::Status: pid 2139202 exit 0>]

输出

Rakefile
README.md

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

pipeline_r([env, ] *cmds, options = {}) → [last_stdout, wait_threads]

源

# File lib/open3.rb, line 1104
def pipeline_r(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  pipeline_run(cmds, opts, [out_w], [out_r], &block)
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
将每个子进程的 stdout 管道到下一个子进程的 stdin，或者，对于最后一个子进程，管道到调用者的 stdout。

该方法不等待子进程退出，因此调用者必须这样做。

在未给出块的情况下，返回一个包含 2 个元素的数组，其中包含

最后一个子进程的 stdout 流。
所有子进程的等待线程数组。

示例

last_stdout, wait_threads = Open3.pipeline_r('ls', 'grep R')
# => [#<IO:fd 5>, [#<Process::Waiter:0x000055e8de2f9898 dead>, #<Process::Waiter:0x000055e8de2f94b0 sleep>]]
puts last_stdout.read
wait_threads.each do |wait_thread|
  wait_thread.join
end

输出

Rakefile
README.md

在给出块的情况下，使用最后一个子进程的 stdout 流和等待进程的数组调用该块

Open3.pipeline_r('ls', 'grep R') do |last_stdout, wait_threads|
  puts last_stdout.read
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

输出

Rakefile
README.md

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

pipeline_rw([env, ] *cmds, options = {}) → [first_stdin, last_stdout, wait_threads]

源

# File lib/open3.rb, line 1014
def pipeline_rw(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  pipeline_run(cmds, opts, [in_r, out_w], [in_w, out_r], &block)
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
将每个子进程的 stdout 管道到下一个子进程的 stdin，或者，对于第一个子进程，从调用者的 stdin，或者，对于最后一个子进程，管道到调用者的 stdout。

该方法不等待子进程退出，因此调用者必须这样做。

在未给出块的情况下，返回一个包含 3 个元素的数组，其中包含

第一个子进程的 stdin 流。
最后一个子进程的 stdout 流。
所有子进程的等待线程数组。

示例

first_stdin, last_stdout, wait_threads = Open3.pipeline_rw('sort', 'cat -n')
# => [#<IO:fd 20>, #<IO:fd 21>, [#<Process::Waiter:0x000055e8de29ab40 sleep>, #<Process::Waiter:0x000055e8de29a690 sleep>]]
first_stdin.puts("foo\nbar\nbaz")
first_stdin.close # Send EOF to sort.
puts last_stdout.read
wait_threads.each do |wait_thread|
  wait_thread.join
end

输出

1 bar
2 baz
3 foo

在给出块的情况下，使用第一个子进程的 stdin 流、最后一个子进程的 stdout 流和等待进程的数组调用该块

Open3.pipeline_rw('sort', 'cat -n') do |first_stdin, last_stdout, wait_threads|
  first_stdin.puts "foo\nbar\nbaz"
  first_stdin.close # send EOF to sort.
  puts last_stdout.read
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

输出

1 bar
2 baz
3 foo

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

pipeline_start([env, ] *cmds, options = {}) → [wait_threads]

源

# File lib/open3.rb, line 1272
def pipeline_start(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  if block
    pipeline_run(cmds, opts, [], [], &block)
  else
    ts, = pipeline_run(cmds, opts, [], [])
    ts
  end
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
不等待子进程退出。

在未给出块的情况下，返回所有子进程的等待线程数组。

示例

wait_threads = Open3.pipeline_start('ls', 'grep R')
# => [#<Process::Waiter:0x000055e8de9d2bb0 run>, #<Process::Waiter:0x000055e8de9d2890 run>]
wait_threads.each do |wait_thread|
  wait_thread.join
end

输出

Rakefile
README.md

在给出块的情况下，使用等待进程的数组调用该块

Open3.pipeline_start('ls', 'grep R') do |wait_threads|
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

输出

Rakefile
README.md

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

pipeline_w([env, ] *cmds, options = {}) → [first_stdin, wait_threads]

源

# File lib/open3.rb, line 1195
def pipeline_w(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  pipeline_run(cmds, opts, [in_r], [in_w], &block)
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
将每个子进程的 stdout 管道到下一个子进程的 stdin，或者，对于第一个子进程，将调用者的 stdout 管道到子进程的 stdin。

该方法不等待子进程退出，因此调用者必须这样做。

在未给出块的情况下，返回一个包含 2 个元素的数组，其中包含

第一个子进程的 stdin 流。
所有子进程的等待线程数组。

示例

first_stdin, wait_threads = Open3.pipeline_w('sort', 'cat -n')
# => [#<IO:fd 7>, [#<Process::Waiter:0x000055e8de928278 run>, #<Process::Waiter:0x000055e8de923e80 run>]]
first_stdin.puts("foo\nbar\nbaz")
first_stdin.close # Send EOF to sort.
wait_threads.each do |wait_thread|
  wait_thread.join
end

输出

1 bar
2 baz
3 foo

在给出块的情况下，使用第一个子进程的 stdin 流和等待进程的数组调用该块

Open3.pipeline_w('sort', 'cat -n') do |first_stdin, wait_threads|
  first_stdin.puts("foo\nbar\nbaz")
  first_stdin.close # Send EOF to sort.
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

输出

1 bar
2 baz
3 foo

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

popen2([env, ] command_line, options = {}) → [stdin, stdout, wait_thread]

popen2([env, ] exe_path, *args, options = {}) → [stdin, stdout, wait_thread]

popen2([env, ] command_line, options = {}) {|stdin, stdout, wait_thread| ... } → object

popen2([env, ] exe_path, *args, options = {}) {|stdin, stdout, wait_thread| ... } → object

源

# File lib/open3.rb, line 365
def popen2(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
end

基本上是 Process.spawn 的包装器，它

通过使用给定的参数调用 Process.spawn 来创建一个子进程。
创建流 stdin 和 stdout，它们是子进程中的标准输入和标准输出流。
创建等待子进程退出的线程 wait_thread；该线程具有方法 pid，该方法返回子进程的进程 ID。

在未给出块的情况下，返回数组 [stdin, stdout, wait_thread]。调用者应关闭返回的两个流中的每一个。

stdin, stdout, wait_thread = Open3.popen2('echo')
# => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f58d52dbe98 run>]
stdin.close
stdout.close
wait_thread.pid   # => 2263572
wait_thread.value # => #<Process::Status: pid 2263572 exit 0>

如果提供了代码块，则使用三个变量（两个流和一个等待线程）调用该代码块，并返回该代码块的返回值。调用者无需关闭流。

Open3.popen2('echo') do |stdin, stdout, wait_thread|
  p stdin
  p stdout
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

输出

#<IO:fd 6>
#<IO:fd 7>
#<Process::Waiter:0x00007f58d59a34b0 sleep>
2263636
#<Process::Status: pid 2263636 exit 0>

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Process.spawn 时前置的参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Process.spawn 时末尾的参数 options；请参阅执行选项。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.popen2('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen2('echo') {|*args| p args }                         # Built-in.
Open3.popen2('date > date.tmp') {|*args| p args }              # Contains meta character.

输出（每次调用类似）

# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577dfe410 dead>]

命令行也可能包含命令的参数和选项

Open3.popen2('echo "Foo"') { |i, o, t| o.gets }
"Foo\n"

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.popen2('/usr/bin/date') { |i, o, t| o.gets }
# => "Thu Sep 28 09:41:06 AM CDT 2023\n"

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.popen2('doesnt_exist') { |i, o, t| o.gets } # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.popen2('echo', 'C #') { |i, o, t| o.gets }
# => "C #\n"
Open3.popen2('echo', 'hello', 'world') { |i, o, t| o.gets }
# => "hello world\n"

相关

Open3.popen2e：将子进程的标准输入和标准输出与标准错误流的合并流作为单独的流提供。
Open3.popen3：将子进程的标准输入、标准输出和标准错误流作为单独的流提供。

popen2e([env, ] command_line, options = {}) → [stdin, stdout_and_stderr, wait_thread]

popen2e([env, ] exe_path, *args, options = {}) → [stdin, stdout_and_stderr, wait_thread]

popen2e([env, ] command_line, options = {}) {|stdin, stdout_and_stderr, wait_thread| ... } → object

popen2e([env, ] exe_path, *args, options = {}) {|stdin, stdout_and_stderr, wait_thread| ... } → object

源

# File lib/open3.rb, line 508
def popen2e(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[[:out, :err]] = out_w

  popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
ensure
  if block
    in_r.close
    in_w.close
    out_r.close
    out_w.close
  end
end

基本上是 Process.spawn 的包装器，它

通过使用给定的参数调用 Process.spawn 来创建一个子进程。
创建流 stdin 和 stdout_and_stderr，它们是子进程中的标准输入和标准输出与标准错误流的合并流。
创建等待子进程退出的线程 wait_thread；该线程具有方法 pid，该方法返回子进程的进程 ID。

如果没有提供代码块，则返回数组 [stdin, stdout_and_stderr, wait_thread]。调用者应关闭返回的两个流中的每一个。

stdin, stdout_and_stderr, wait_thread = Open3.popen2e('echo')
# => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f7577da4398 run>]
stdin.close
stdout_and_stderr.close
wait_thread.pid   # => 2274600
wait_thread.value # => #<Process::Status: pid 2274600 exit 0>

如果提供了代码块，则使用三个变量（两个流和一个等待线程）调用该代码块，并返回该代码块的返回值。调用者无需关闭流。

Open3.popen2e('echo') do |stdin, stdout_and_stderr, wait_thread|
  p stdin
  p stdout_and_stderr
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

输出

#<IO:fd 6>
#<IO:fd 7>
#<Process::Waiter:0x00007f75777578c8 sleep>
2274763
#<Process::Status: pid 2274763 exit 0>

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Process.spawn 时前置的参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Process.spawn 时末尾的参数 options；请参阅执行选项。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.popen2e('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen2e('echo') {|*args| p args }                         # Built-in.
Open3.popen2e('date > date.tmp') {|*args| p args }              # Contains meta character.

输出（每次调用类似）

# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577d8a1f0 dead>]

命令行也可能包含命令的参数和选项

Open3.popen2e('echo "Foo"') { |i, o_and_e, t| o_and_e.gets }
"Foo\n"

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.popen2e('/usr/bin/date') { |i, o_and_e, t| o_and_e.gets }
# => "Thu Sep 28 01:58:45 PM CDT 2023\n"

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.popen2e('doesnt_exist') { |i, o_and_e, t| o_and_e.gets } # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.popen2e('echo', 'C #') { |i, o_and_e, t| o_and_e.gets }
# => "C #\n"
Open3.popen2e('echo', 'hello', 'world') { |i, o_and_e, t| o_and_e.gets }
# => "hello world\n"

相关

Open3.popen2：将子进程的标准输入和标准输出流作为单独的流提供，无法访问标准错误流。
Open3.popen3：将子进程的标准输入、标准输出和标准错误流作为单独的流提供。

popen3([env, ] command_line, options = {}) → [stdin, stdout, stderr, wait_thread]

popen3([env, ] exe_path, *args, options = {}) → [stdin, stdout, stderr, wait_thread]

popen3([env, ] command_line, options = {}) {|stdin, stdout, stderr, wait_thread| ... } → object

popen3([env, ] exe_path, *args, options = {}) {|stdin, stdout, stderr, wait_thread| ... } → object

源

# File lib/open3.rb, line 218
def popen3(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  err_r, err_w = IO.pipe
  opts[:err] = err_w

  popen_run(cmd, opts, [in_r, out_w, err_w], [in_w, out_r, err_r], &block)
end

基本上是 Process.spawn 的包装器，它

通过使用给定的参数调用 Process.spawn 来创建一个子进程。
创建流 stdin、stdout 和 stderr，它们是子进程中的标准输入、标准输出和标准错误流。
创建等待子进程退出的线程 wait_thread；该线程具有方法 pid，该方法返回子进程的进程 ID。

如果没有提供代码块，则返回数组 [stdin, stdout, stderr, wait_thread]。调用者应关闭返回的三个流中的每一个。

stdin, stdout, stderr, wait_thread = Open3.popen3('echo')
# => [#<IO:fd 8>, #<IO:fd 10>, #<IO:fd 12>, #<Process::Waiter:0x00007f58d5428f58 run>]
stdin.close
stdout.close
stderr.close
wait_thread.pid   # => 2210481
wait_thread.value # => #<Process::Status: pid 2210481 exit 0>

如果提供了代码块，则使用四个变量（三个流和一个等待线程）调用该代码块，并返回该代码块的返回值。调用者无需关闭流。

Open3.popen3('echo') do |stdin, stdout, stderr, wait_thread|
  p stdin
  p stdout
  p stderr
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

输出

#<IO:fd 6>
#<IO:fd 7>
#<IO:fd 9>
#<Process::Waiter:0x00007f58d53606e8 sleep>
2211047
#<Process::Status: pid 2211047 exit 0>

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Process.spawn 时前置的参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Process.spawn 时末尾的参数 options；请参阅执行选项。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.popen3('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen3('echo') {|*args| p args }                         # Built-in.
Open3.popen3('date > date.tmp') {|*args| p args }              # Contains meta character.

输出（每次调用类似）

[#<IO:(closed)>, #<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f58d52f28c8 dead>]

命令行也可能包含命令的参数和选项

Open3.popen3('echo "Foo"') { |i, o, e, t| o.gets }
"Foo\n"

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.popen3('/usr/bin/date') { |i, o, e, t| o.gets }
# => "Wed Sep 27 02:56:44 PM CDT 2023\n"

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.popen3('doesnt_exist') { |i, o, e, t| o.gets } # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.popen3('echo', 'C #') { |i, o, e, t| o.gets }
# => "C #\n"
Open3.popen3('echo', 'hello', 'world') { |i, o, e, t| o.gets }
# => "hello world\n"

注意避免死锁。输出流 stdout 和 stderr 具有固定大小的缓冲区，因此如果大量读取其中一个流，而不读取另一个流，则当未读取的缓冲区填满时可能会导致死锁。为避免这种情况，应同时读取 stdout 和 stderr （使用线程或 IO.select）。

相关

Open3.popen2：将子进程的标准输入和标准输出流作为单独的流提供，无法访问标准错误流。
Open3.popen2e：将子进程的标准输入和标准输出与标准错误流的合并流作为单独的流提供。

私有实例方法

capture2([env, ] command_line, options = {}) → [stdout_s, status]

capture2([env, ] exe_path, *args, options = {}) → [stdout_s, status]

源

# File lib/open3.rb, line 775
def capture2(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data)
  binmode = opts.delete(:binmode)

  popen2(*cmd, opts) {|i, o, t|
    if binmode
      i.binmode
      o.binmode
    end
    out_reader = Thread.new { o.read }
    if stdin_data
      begin
        if stdin_data.respond_to? :readpartial
          IO.copy_stream(stdin_data, i)
        else
          i.write stdin_data
        end
      rescue Errno::EPIPE
      end
    end
    i.close
    [out_reader.value, t.value]
  }
end

基本上是 Open3.popen3 的包装器，它

通过使用给定的参数（除了哈希 options 中的某些条目；请参见下文）调用 Open3.popen3 来创建子进程。
以字符串 stdout_s 的形式返回子进程的标准输出。
以 status 的形式返回一个 Process::Status 对象，该对象表示子进程的退出状态。

返回数组 [stdout_s, status]

stdout_s, status = Open3.capture2('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326047 exit 0>]

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Open3.popen3 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Open3.popen3 中的尾随参数 options；请参阅执行选项。

给出哈希 options；两个选项在方法 Open3.capture2 中具有局部作用

如果存在条目 options[:stdin_data]，则删除该条目，并将其字符串值发送到命令的标准输入
```
Open3.capture2('tee', stdin_data: 'Foo')

# => ["Foo", #<Process::Status: pid 2326087 exit 0>]
```
如果存在条目 options[:binmode]，则删除该条目，并将内部流设置为二进制模式。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.capture2('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", #<Process::Status: pid 2326131 exit 0>]
Open3.capture2('echo')                         # Built-in.
# => ["\n", #<Process::Status: pid 2326139 exit 0>]
Open3.capture2('date > date.tmp')              # Contains meta character.
# => ["", #<Process::Status: pid 2326174 exit 0>]

命令行也可能包含命令的参数和选项

Open3.capture2('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326183 exit 0>]

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.capture2('/usr/bin/date')
# => ["Fri Sep 29 01:00:39 PM CDT 2023\n", #<Process::Status: pid 2326222 exit 0>]

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.capture2('doesnt_exist') # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.capture2('echo', 'C #')
# => ["C #\n", #<Process::Status: pid 2326267 exit 0>]
Open3.capture2('echo', 'hello', 'world')
# => ["hello world\n", #<Process::Status: pid 2326299 exit 0>]

capture2e([env, ] command_line, options = {}) → [stdout_and_stderr_s, status]

capture2e([env, ] exe_path, *args, options = {}) → [stdout_and_stderr_s, status]

源

# File lib/open3.rb, line 902
def capture2e(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data)
  binmode = opts.delete(:binmode)

  popen2e(*cmd, opts) {|i, oe, t|
    if binmode
      i.binmode
      oe.binmode
    end
    outerr_reader = Thread.new { oe.read }
    if stdin_data
      begin
        if stdin_data.respond_to? :readpartial
          IO.copy_stream(stdin_data, i)
        else
          i.write stdin_data
        end
      rescue Errno::EPIPE
      end
    end
    i.close
    [outerr_reader.value, t.value]
  }
end

基本上是 Open3.popen3 的包装器，它

通过使用给定的参数（除了哈希 options 中的某些条目；请参见下文）调用 Open3.popen3 来创建子进程。
以字符串 stdout_and_stderr_s 的形式返回子进程的合并标准输出和标准错误。
以 status 的形式返回一个 Process::Status 对象，该对象表示子进程的退出状态。

返回数组 [stdout_and_stderr_s, status]

stdout_and_stderr_s, status = Open3.capture2e('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2371692 exit 0>]

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Open3.popen3 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Open3.popen3 中的尾随参数 options；请参阅执行选项。

给出哈希 options；两个选项在方法 Open3.capture2e 中具有局部作用

如果存在条目 options[:stdin_data]，则删除该条目，并将其字符串值发送到命令的标准输入
```
Open3.capture2e('tee', stdin_data: 'Foo')
# => ["Foo", #<Process::Status: pid 2371732 exit 0>]
```
如果存在条目 options[:binmode]，则删除该条目，并将内部流设置为二进制模式。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.capture2e('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", #<Process::Status: pid 2371740 exit 0>]
Open3.capture2e('echo')                         # Built-in.
# => ["\n", #<Process::Status: pid 2371774 exit 0>]
Open3.capture2e('date > date.tmp')              # Contains meta character.
# => ["", #<Process::Status: pid 2371812 exit 0>]

命令行也可能包含命令的参数和选项

Open3.capture2e('echo "Foo"')
# => ["Foo\n", #<Process::Status: pid 2326183 exit 0>]

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.capture2e('/usr/bin/date')
# => ["Sat Sep 30 09:01:46 AM CDT 2023\n", #<Process::Status: pid 2371820 exit 0>]

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.capture2e('doesnt_exist') # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.capture2e('echo', 'C #')
# => ["C #\n", #<Process::Status: pid 2371856 exit 0>]
Open3.capture2e('echo', 'hello', 'world')
# => ["hello world\n", #<Process::Status: pid 2371894 exit 0>]

capture3([env, ] command_line, options = {}) → [stdout_s, stderr_s, status]

capture3([env, ] exe_path, *args, options = {}) → [stdout_s, stderr_s, status]

源

# File lib/open3.rb, line 648
def capture3(*cmd)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  stdin_data = opts.delete(:stdin_data) || ''
  binmode = opts.delete(:binmode)

  popen3(*cmd, opts) {|i, o, e, t|
    if binmode
      i.binmode
      o.binmode
      e.binmode
    end
    out_reader = Thread.new { o.read }
    err_reader = Thread.new { e.read }
    begin
      if stdin_data.respond_to? :readpartial
        IO.copy_stream(stdin_data, i)
      else
        i.write stdin_data
      end
    rescue Errno::EPIPE
    end
    i.close
    [out_reader.value, err_reader.value, t.value]
  }
end

基本上是 Open3.popen3 的包装器，它

通过使用给定的参数（除了哈希 options 中的某些条目；请参见下文）调用 Open3.popen3 来创建子进程。
以字符串 stdout_s 和 stderr_s 的形式返回子进程的标准输出和标准错误。
以 status 的形式返回一个 Process::Status 对象，该对象表示子进程的退出状态。

返回数组 [stdout_s, stderr_s, status]

stdout_s, stderr_s, status = Open3.capture3('echo "Foo"')
# => ["Foo\n", "", #<Process::Status: pid 2281954 exit 0>]

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Open3.popen3 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Open3.popen3 中的尾随参数 options；请参阅执行选项。

给出哈希 options；两个选项在方法 Open3.capture3 中具有局部作用

如果存在条目 options[:stdin_data]，则删除该条目，并将其字符串值发送到命令的标准输入
```
Open3.capture3('tee', stdin_data: 'Foo')
# => ["Foo", "", #<Process::Status: pid 2319575 exit 0>]
```
如果存在条目 options[:binmode]，则删除该条目，并将内部流设置为二进制模式。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.capture3('if true; then echo "Foo"; fi') # Shell reserved word.
# => ["Foo\n", "", #<Process::Status: pid 2282025 exit 0>]
Open3.capture3('echo')                         # Built-in.
# => ["\n", "", #<Process::Status: pid 2282092 exit 0>]
Open3.capture3('date > date.tmp')              # Contains meta character.
# => ["", "", #<Process::Status: pid 2282110 exit 0>]

命令行也可能包含命令的参数和选项

Open3.capture3('echo "Foo"')
# => ["Foo\n", "", #<Process::Status: pid 2282092 exit 0>]

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.capture3('/usr/bin/date')
# => ["Thu Sep 28 05:03:51 PM CDT 2023\n", "", #<Process::Status: pid 2282300 exit 0>]

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.capture3('doesnt_exist') # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.capture3('echo', 'C #')
# => ["C #\n", "", #<Process::Status: pid 2282368 exit 0>]
Open3.capture3('echo', 'hello', 'world')
# => ["hello world\n", "", #<Process::Status: pid 2282372 exit 0>]

pipeline([env, ] *cmds, options = {}) → array_of_statuses

源

# File lib/open3.rb, line 1334
def pipeline(*cmds)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  pipeline_run(cmds, opts, [], []) {|ts|
    ts.map(&:value)
  }
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
将每个子进程的 stdout 管道到下一个子进程的 stdin，或者，对于最后一个子进程，管道到调用者的 stdout。
等待子进程退出。
返回 Process::Status 对象的数组（每个子进程一个）。

示例

wait_threads = Open3.pipeline('ls', 'grep R')
# => [#<Process::Status: pid 2139200 exit 0>, #<Process::Status: pid 2139202 exit 0>]

输出

Rakefile
README.md

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

pipeline_r([env, ] *cmds, options = {}) → [last_stdout, wait_threads]

源

# File lib/open3.rb, line 1104
def pipeline_r(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  pipeline_run(cmds, opts, [out_w], [out_r], &block)
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
将每个子进程的 stdout 管道到下一个子进程的 stdin，或者，对于最后一个子进程，管道到调用者的 stdout。

该方法不等待子进程退出，因此调用者必须这样做。

在未给出块的情况下，返回一个包含 2 个元素的数组，其中包含

最后一个子进程的 stdout 流。
所有子进程的等待线程数组。

示例

last_stdout, wait_threads = Open3.pipeline_r('ls', 'grep R')
# => [#<IO:fd 5>, [#<Process::Waiter:0x000055e8de2f9898 dead>, #<Process::Waiter:0x000055e8de2f94b0 sleep>]]
puts last_stdout.read
wait_threads.each do |wait_thread|
  wait_thread.join
end

输出

Rakefile
README.md

在给出块的情况下，使用最后一个子进程的 stdout 流和等待进程的数组调用该块

Open3.pipeline_r('ls', 'grep R') do |last_stdout, wait_threads|
  puts last_stdout.read
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

输出

Rakefile
README.md

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

pipeline_rw([env, ] *cmds, options = {}) → [first_stdin, last_stdout, wait_threads]

源

# File lib/open3.rb, line 1014
def pipeline_rw(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  pipeline_run(cmds, opts, [in_r, out_w], [in_w, out_r], &block)
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
将每个子进程的 stdout 管道到下一个子进程的 stdin，或者，对于第一个子进程，从调用者的 stdin，或者，对于最后一个子进程，管道到调用者的 stdout。

该方法不等待子进程退出，因此调用者必须这样做。

在未给出块的情况下，返回一个包含 3 个元素的数组，其中包含

第一个子进程的 stdin 流。
最后一个子进程的 stdout 流。
所有子进程的等待线程数组。

示例

first_stdin, last_stdout, wait_threads = Open3.pipeline_rw('sort', 'cat -n')
# => [#<IO:fd 20>, #<IO:fd 21>, [#<Process::Waiter:0x000055e8de29ab40 sleep>, #<Process::Waiter:0x000055e8de29a690 sleep>]]
first_stdin.puts("foo\nbar\nbaz")
first_stdin.close # Send EOF to sort.
puts last_stdout.read
wait_threads.each do |wait_thread|
  wait_thread.join
end

输出

1 bar
2 baz
3 foo

在给出块的情况下，使用第一个子进程的 stdin 流、最后一个子进程的 stdout 流和等待进程的数组调用该块

Open3.pipeline_rw('sort', 'cat -n') do |first_stdin, last_stdout, wait_threads|
  first_stdin.puts "foo\nbar\nbaz"
  first_stdin.close # send EOF to sort.
  puts last_stdout.read
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

输出

1 bar
2 baz
3 foo

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

pipeline_start([env, ] *cmds, options = {}) → [wait_threads]

源

# File lib/open3.rb, line 1272
def pipeline_start(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  if block
    pipeline_run(cmds, opts, [], [], &block)
  else
    ts, = pipeline_run(cmds, opts, [], [])
    ts
  end
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
不等待子进程退出。

在未给出块的情况下，返回所有子进程的等待线程数组。

示例

wait_threads = Open3.pipeline_start('ls', 'grep R')
# => [#<Process::Waiter:0x000055e8de9d2bb0 run>, #<Process::Waiter:0x000055e8de9d2890 run>]
wait_threads.each do |wait_thread|
  wait_thread.join
end

输出

Rakefile
README.md

在给出块的情况下，使用等待进程的数组调用该块

Open3.pipeline_start('ls', 'grep R') do |wait_threads|
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

输出

Rakefile
README.md

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

pipeline_w([env, ] *cmds, options = {}) → [first_stdin, wait_threads]

源

# File lib/open3.rb, line 1195
def pipeline_w(*cmds, &block)
  if Hash === cmds.last
    opts = cmds.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  pipeline_run(cmds, opts, [in_r], [in_w], &block)
end

基本上是 Process.spawn 的包装器，它

通过调用 Process.spawn 为给定的每个 cmds 创建一个子进程。
将每个子进程的 stdout 管道到下一个子进程的 stdin，或者，对于第一个子进程，将调用者的 stdout 管道到子进程的 stdin。

该方法不等待子进程退出，因此调用者必须这样做。

在未给出块的情况下，返回一个包含 2 个元素的数组，其中包含

第一个子进程的 stdin 流。
所有子进程的等待线程数组。

示例

first_stdin, wait_threads = Open3.pipeline_w('sort', 'cat -n')
# => [#<IO:fd 7>, [#<Process::Waiter:0x000055e8de928278 run>, #<Process::Waiter:0x000055e8de923e80 run>]]
first_stdin.puts("foo\nbar\nbaz")
first_stdin.close # Send EOF to sort.
wait_threads.each do |wait_thread|
  wait_thread.join
end

输出

1 bar
2 baz
3 foo

在给出块的情况下，使用第一个子进程的 stdin 流和等待进程的数组调用该块

Open3.pipeline_w('sort', 'cat -n') do |first_stdin, wait_threads|
  first_stdin.puts("foo\nbar\nbaz")
  first_stdin.close # Send EOF to sort.
  wait_threads.each do |wait_thread|
    wait_thread.join
  end
end

输出

1 bar
2 baz
3 foo

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

如果第一个参数是哈希，它将成为每次调用 Process.spawn 中的前导参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为每次调用 Process.spawn 中的尾随参数 options；请参阅执行选项。

cmds 中的每个剩余参数是以下之一

command_line：一个以 shell 保留字或特殊内置函数开头，或包含一个或多个元字符的字符串。
exe_path：要调用的可执行文件的字符串路径。
一个包含 command_line 或 exe_path 的数组，以及命令的零个或多个字符串参数。

请参阅参数 command_line 或 exe_path。

popen2([env, ] command_line, options = {}) → [stdin, stdout, wait_thread]

popen2([env, ] exe_path, *args, options = {}) → [stdin, stdout, wait_thread]

popen2([env, ] command_line, options = {}) {|stdin, stdout, wait_thread| ... } → object

popen2([env, ] exe_path, *args, options = {}) {|stdin, stdout, wait_thread| ... } → object

源

# File lib/open3.rb, line 365
def popen2(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
end

基本上是 Process.spawn 的包装器，它

通过使用给定的参数调用 Process.spawn 来创建一个子进程。
创建流 stdin 和 stdout，它们是子进程中的标准输入和标准输出流。
创建等待子进程退出的线程 wait_thread；该线程具有方法 pid，该方法返回子进程的进程 ID。

在未给出块的情况下，返回数组 [stdin, stdout, wait_thread]。调用者应关闭返回的两个流中的每一个。

stdin, stdout, wait_thread = Open3.popen2('echo')
# => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f58d52dbe98 run>]
stdin.close
stdout.close
wait_thread.pid   # => 2263572
wait_thread.value # => #<Process::Status: pid 2263572 exit 0>

如果提供了代码块，则使用三个变量（两个流和一个等待线程）调用该代码块，并返回该代码块的返回值。调用者无需关闭流。

Open3.popen2('echo') do |stdin, stdout, wait_thread|
  p stdin
  p stdout
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

输出

#<IO:fd 6>
#<IO:fd 7>
#<Process::Waiter:0x00007f58d59a34b0 sleep>
2263636
#<Process::Status: pid 2263636 exit 0>

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Process.spawn 时前置的参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Process.spawn 时末尾的参数 options；请参阅执行选项。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.popen2('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen2('echo') {|*args| p args }                         # Built-in.
Open3.popen2('date > date.tmp') {|*args| p args }              # Contains meta character.

输出（每次调用类似）

# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577dfe410 dead>]

命令行也可能包含命令的参数和选项

Open3.popen2('echo "Foo"') { |i, o, t| o.gets }
"Foo\n"

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.popen2('/usr/bin/date') { |i, o, t| o.gets }
# => "Thu Sep 28 09:41:06 AM CDT 2023\n"

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.popen2('doesnt_exist') { |i, o, t| o.gets } # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.popen2('echo', 'C #') { |i, o, t| o.gets }
# => "C #\n"
Open3.popen2('echo', 'hello', 'world') { |i, o, t| o.gets }
# => "hello world\n"

相关

Open3.popen2e：将子进程的标准输入和标准输出与标准错误流的合并流作为单独的流提供。
Open3.popen3：将子进程的标准输入、标准输出和标准错误流作为单独的流提供。

popen2e([env, ] command_line, options = {}) → [stdin, stdout_and_stderr, wait_thread]

popen2e([env, ] exe_path, *args, options = {}) → [stdin, stdout_and_stderr, wait_thread]

popen2e([env, ] command_line, options = {}) {|stdin, stdout_and_stderr, wait_thread| ... } → object

popen2e([env, ] exe_path, *args, options = {}) {|stdin, stdout_and_stderr, wait_thread| ... } → object

源

# File lib/open3.rb, line 508
def popen2e(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[[:out, :err]] = out_w

  popen_run(cmd, opts, [in_r, out_w], [in_w, out_r], &block)
ensure
  if block
    in_r.close
    in_w.close
    out_r.close
    out_w.close
  end
end

基本上是 Process.spawn 的包装器，它

通过使用给定的参数调用 Process.spawn 来创建一个子进程。
创建流 stdin 和 stdout_and_stderr，它们是子进程中的标准输入和标准输出与标准错误流的合并流。
创建等待子进程退出的线程 wait_thread；该线程具有方法 pid，该方法返回子进程的进程 ID。

如果没有提供代码块，则返回数组 [stdin, stdout_and_stderr, wait_thread]。调用者应关闭返回的两个流中的每一个。

stdin, stdout_and_stderr, wait_thread = Open3.popen2e('echo')
# => [#<IO:fd 6>, #<IO:fd 7>, #<Process::Waiter:0x00007f7577da4398 run>]
stdin.close
stdout_and_stderr.close
wait_thread.pid   # => 2274600
wait_thread.value # => #<Process::Status: pid 2274600 exit 0>

如果提供了代码块，则使用三个变量（两个流和一个等待线程）调用该代码块，并返回该代码块的返回值。调用者无需关闭流。

Open3.popen2e('echo') do |stdin, stdout_and_stderr, wait_thread|
  p stdin
  p stdout_and_stderr
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

输出

#<IO:fd 6>
#<IO:fd 7>
#<Process::Waiter:0x00007f75777578c8 sleep>
2274763
#<Process::Status: pid 2274763 exit 0>

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Process.spawn 时前置的参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Process.spawn 时末尾的参数 options；请参阅执行选项。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.popen2e('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen2e('echo') {|*args| p args }                         # Built-in.
Open3.popen2e('date > date.tmp') {|*args| p args }              # Contains meta character.

输出（每次调用类似）

# => [#<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f7577d8a1f0 dead>]

命令行也可能包含命令的参数和选项

Open3.popen2e('echo "Foo"') { |i, o_and_e, t| o_and_e.gets }
"Foo\n"

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.popen2e('/usr/bin/date') { |i, o_and_e, t| o_and_e.gets }
# => "Thu Sep 28 01:58:45 PM CDT 2023\n"

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.popen2e('doesnt_exist') { |i, o_and_e, t| o_and_e.gets } # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.popen2e('echo', 'C #') { |i, o_and_e, t| o_and_e.gets }
# => "C #\n"
Open3.popen2e('echo', 'hello', 'world') { |i, o_and_e, t| o_and_e.gets }
# => "hello world\n"

相关

Open3.popen2：将子进程的标准输入和标准输出流作为单独的流提供，无法访问标准错误流。
Open3.popen3：将子进程的标准输入、标准输出和标准错误流作为单独的流提供。

popen3([env, ] command_line, options = {}) → [stdin, stdout, stderr, wait_thread]

popen3([env, ] exe_path, *args, options = {}) → [stdin, stdout, stderr, wait_thread]

popen3([env, ] command_line, options = {}) {|stdin, stdout, stderr, wait_thread| ... } → object

popen3([env, ] exe_path, *args, options = {}) {|stdin, stdout, stderr, wait_thread| ... } → object

源

# File lib/open3.rb, line 218
def popen3(*cmd, &block)
  if Hash === cmd.last
    opts = cmd.pop.dup
  else
    opts = {}
  end

  in_r, in_w = IO.pipe
  opts[:in] = in_r
  in_w.sync = true

  out_r, out_w = IO.pipe
  opts[:out] = out_w

  err_r, err_w = IO.pipe
  opts[:err] = err_w

  popen_run(cmd, opts, [in_r, out_w, err_w], [in_w, out_r, err_r], &block)
end

基本上是 Process.spawn 的包装器，它

通过使用给定的参数调用 Process.spawn 来创建一个子进程。
创建流 stdin、stdout 和 stderr，它们是子进程中的标准输入、标准输出和标准错误流。
创建等待子进程退出的线程 wait_thread；该线程具有方法 pid，该方法返回子进程的进程 ID。

如果没有提供代码块，则返回数组 [stdin, stdout, stderr, wait_thread]。调用者应关闭返回的三个流中的每一个。

stdin, stdout, stderr, wait_thread = Open3.popen3('echo')
# => [#<IO:fd 8>, #<IO:fd 10>, #<IO:fd 12>, #<Process::Waiter:0x00007f58d5428f58 run>]
stdin.close
stdout.close
stderr.close
wait_thread.pid   # => 2210481
wait_thread.value # => #<Process::Status: pid 2210481 exit 0>

如果提供了代码块，则使用四个变量（三个流和一个等待线程）调用该代码块，并返回该代码块的返回值。调用者无需关闭流。

Open3.popen3('echo') do |stdin, stdout, stderr, wait_thread|
  p stdin
  p stdout
  p stderr
  p wait_thread
  p wait_thread.pid
  p wait_thread.value
end

输出

#<IO:fd 6>
#<IO:fd 7>
#<IO:fd 9>
#<Process::Waiter:0x00007f58d53606e8 sleep>
2211047
#<Process::Status: pid 2211047 exit 0>

与 Process.spawn 一样，如果使用不可信任的输入调用此方法，则存在潜在的安全漏洞；请参阅命令注入。

与 Process.spawn 不同，此方法在返回之前会等待子进程退出，因此调用者无需这样做。

如果第一个参数是哈希，它将成为调用 Process.spawn 时前置的参数 env；请参阅执行环境。

如果最后一个参数是哈希，它将成为调用 Process.spawn 时末尾的参数 options；请参阅执行选项。

单个必需参数是以下之一

command_line，如果它是字符串，并且如果它以 shell 保留字或特殊内置函数开头，或者如果它包含一个或多个元字符。
否则为 exe_path。

参数 command_line

字符串参数 command_line 是要传递给 shell 的命令行；它必须以 shell 保留字开头、以特殊内置函数开头或包含元字符

Open3.popen3('if true; then echo "Foo"; fi') {|*args| p args } # Shell reserved word.
Open3.popen3('echo') {|*args| p args }                         # Built-in.
Open3.popen3('date > date.tmp') {|*args| p args }              # Contains meta character.

输出（每次调用类似）

[#<IO:(closed)>, #<IO:(closed)>, #<IO:(closed)>, #<Process::Waiter:0x00007f58d52f28c8 dead>]

命令行也可能包含命令的参数和选项

Open3.popen3('echo "Foo"') { |i, o, e, t| o.gets }
"Foo\n"

参数 exe_path

参数 exe_path 是以下之一

要调用的可执行文件的字符串路径。
一个 2 元素数组，其中包含可执行文件的路径和用作执行进程名称的字符串。

示例

Open3.popen3('/usr/bin/date') { |i, o, e, t| o.gets }
# => "Wed Sep 27 02:56:44 PM CDT 2023\n"

Ruby 直接调用可执行文件，没有 shell，也没有 shell 扩展

Open3.popen3('doesnt_exist') { |i, o, e, t| o.gets } # Raises Errno::ENOENT

如果给出一个或多个 args，则每个都是要传递给可执行文件的参数或选项

Open3.popen3('echo', 'C #') { |i, o, e, t| o.gets }
# => "C #\n"
Open3.popen3('echo', 'hello', 'world') { |i, o, e, t| o.gets }
# => "hello world\n"

相关

Open3.popen2：将子进程的标准输入和标准输出流作为单独的流提供，无法访问标准错误流。
Open3.popen2e：将子进程的标准输入和标准输出与标准错误流的合并流作为单独的流提供。