Nivel inicial11 min de lectura · Publicado el

Ejecutar comandos del sistema desde Ruby: system, %x y Open3

Comandos del sistema desde Ruby: comillas invertidas devuelven la salida, system dice si salió bien y spawn devuelve el PID y sigue. Ruby: ¿esperas la salida?rubentejera.com `echo hola`"hola\n"system(...)truespawn(...)PID
El sistema es el compañero del recado. Con comillas invertidas esperas y te cuenta lo que vio; system solo te dice si salió bien (true, false o nil); con spawn lo mandas y sigues con lo tuyo.

A veces tu programa en Ruby necesita algo que ya hace un comando del sistema: listar ficheros, llamar a git o comprimir una carpeta. Ruby te deja ejecutarlo sin salir del script: con comillas invertidas, con system o con Open3.

Es como pedirle un recado a un compañero: puedes esperar a que vuelva y te cuente qué ha visto (comillas invertidas), solo preguntarle si salió bien (system) o mandarlo y seguir con lo tuyo (spawn).

Comillas invertidas y %x: guardar la salida

Si escribes una cadena entre comillas invertidas (el acento grave, `, no el apóstrofo) o con el formato %x{}, Ruby la ejecuta como un comando del sistema operativo y te devuelve lo que imprime como un String:

salida = `echo hola`
puts salida.inspect   # => "hola\n"
puts $?.success?      # => true

puts %x{echo "con %x"}.inspect  # => "con %x\n"

%x{} hace lo mismo que las comillas invertidas; es más cómodo cuando el comando lleva comillas. Las dos reciben el comando en una sola cadena y se lo pasan a la shell (/bin/sh en Linux y macOS) si lleva caracteres especiales o empieza por una palabra reservada o una orden interna de la shell. Por eso puedes usar tuberías (|) y redirecciones (2>&1). Lo verás en detalle más abajo.

Fíjate en que la salida termina en "\n": es el salto de línea que imprime el comando. Si vas a comparar o usar el texto, quítalo con chomp.

$?: cómo terminó el comando

Después de ejecutar un comando con comillas invertidas, %x, system o Process.wait, Ruby guarda en la variable $? un objeto Process::Status con el resultado. Es como el resguardo que te da el compañero al volver del recado: dice si salió bien y con qué código.

`ls /no-existe 2>/dev/null`
p $?.class         # => Process::Status
p $?.exitstatus    # => 2
p $?.success?      # => false

system("true")
p $?.exitstatus    # => 0
  • exitstatus es el código de salida: 0 si todo fue bien y otro número si algo falló. Cada programa decide qué significa cada número; ls usa 2 para «no existe».
  • success? es true solo si el código es 0.
  • Antes de ejecutar ningún comando, $? vale nil.
  • $? es del hilo actual: si lanzas comandos desde varios hilos, cada uno ve el suyo.

system: ejecutar y saber si fue bien

system muestra la salida del comando en la consola y te devuelve cómo terminó:

p system("echo desde system")       # imprime "desde system" => true
p system("false")                   # el comando falla       => false
p system("comando-que-no-existe")   # no se pudo ejecutar    => nil

Si prefieres que un fallo pare el programa, añade exception: true:

system("false", exception: true)
exc.rb:1:in 'Kernel#system': Command failed with exit 1: false (RuntimeError)

Una cadena o varios argumentos: cuándo entra la shell

system, spawn, exec y Open3 aceptan el comando de dos formas, y la diferencia importa:

  • Una sola cadena: system("ls -l /tmp"). Ruby se la da a /bin/sh si contiene caracteres especiales (;, |, &, >, $, comillas…) o si empieza por una palabra reservada o una orden interna especial de la shell (exit, export, if…); si no, lanza el programa directamente. Por eso system("exit 3") funciona aunque no exista ningún programa exit: devuelve false y $?.exitstatus vale 3.
  • El programa y cada argumento por separado: system("ls", "-l", "/tmp"). Nunca hay shell: cada argumento llega tal cual al programa.

Por eso un comando que no existe se comporta distinto según cómo lo escribas. Sin shell, Ruby no encuentra el programa y lanza un error:

`comando-que-no-existe`
bt_noexiste.rb:1:in 'Kernel#`': No such file or directory - comando-que-no-existe (Errno::ENOENT)

Con un carácter especial, como 2>&1, entra la shell: ella es la que no lo encuentra, lo dice en la salida y termina con el código 127:

salida = `comando-que-no-existe 2>&1`
p salida          # => "sh: 1: comando-que-no-existe: not found\n"
p $?.exitstatus   # => 127

Open3: salida, errores y código por separado

Cuando necesitas distinguir lo que el comando escribe en la salida normal de lo que escribe como error, usa Open3.capture3, de la biblioteca estándar:

require "open3"

out, err, status = Open3.capture3("ls", "/no-existe")
p out                # => ""
p err                # => "ls: cannot access '/no-existe': No such file or directory\n"
p status.exitstatus  # => 2

Tiene dos variantes que también vienen bien:

require "open3"

# capture2: solo la salida; stdin_data le pasa texto por la entrada estándar
salida, status = Open3.capture2("tr", "a-z", "A-Z", stdin_data: "hola\n")
p salida           # => "HOLA\n"
p status.success?  # => true

# capture2e: salida y errores juntos, en el orden en que salen
todo, status = Open3.capture2e("sh", "-c", "echo bien; echo mal >&2")
p todo             # => "bien\nmal\n"

exec y spawn: sustituir o lanzar en segundo plano

# spawn lanza el proceso y no espera; Process.wait espera a que termine
pid = spawn("sleep 0.1 && echo terminado")
Process.wait(pid)

# exec sustituye tu programa por el comando: lo que va detrás no se ejecuta
exec("echo", "adios")
puts "nunca se imprime"
terminado
adios

Si un proceso se queda colgado, en matar un proceso en Linux tienes cómo pararlo.

Resumen: cuál usar

Forma Devuelve Cuándo usarla
`cmd` o %x{cmd} La salida como String Quieres guardar lo que imprime
system(...) true, false o nil Solo te importa si fue bien
Open3.capture3(...) Salida, errores y estado Necesitas separar errores o el código de salida
spawn(...) El PID Quieres seguir trabajando mientras se ejecuta
exec(...) Nada: no vuelve Quieres que el comando sustituya a tu programa

Cuidado con los datos del usuario

Si metes en una sola cadena algo que viene del usuario, la shell interpreta sus ; o && como órdenes. Así, alguien podría colar otro comando: es la inyección de comandos. Es como dictarle a alguien una nota que ha escrito un desconocido y que acaba en «… y después abre la caja fuerte».

En este ejemplo, el «usuario» ha escrito un nombre de fichero con un comando inofensivo detrás, echo INYECTADO:

nombre = "informe.txt; echo INYECTADO"   # lo que ha escrito el usuario

system("echo #{nombre}")       # una cadena: la interpreta la shell
system("echo", nombre)         # varios argumentos: sin shell
informe.txt
INYECTADO
informe.txt; echo INYECTADO

La primera llamada ha ejecutado dos comandos: el echo que querías y el que ha colado el usuario. Si en lugar de echo INYECTADO hubiera escrito un comando que borra ficheros, también se habría ejecutado. La segunda llamada trata todo el texto como un único argumento: un dato, no una orden.

Con las comillas invertidas y %x pasa lo mismo, porque el comando va en una sola cadena:

nombre = "informe.txt; echo INYECTADO"
puts `echo #{nombre}`
informe.txt
INYECTADO

La regla: si el comando lleva datos que no controlas, pásalo como varios argumentos a system, spawn u Open3. Si de verdad necesitas la shell (por ejemplo, para una tubería), escapa cada dato con Shellwords.escape o su atajo shellescape:

require "shellwords"

nombre = "informe.txt; echo INYECTADO"
puts `echo #{Shellwords.escape(nombre)}`
puts `echo #{nombre.shellescape} | tr a-z A-Z`
informe.txt; echo INYECTADO
INFORME.TXT; ECHO INYECTADO

Shellwords escapa para la shell de tipo Bourne (sh, bash); no sirve para cmd.exe ni PowerShell. Usa el resultado sin comillas alrededor: el escape ya hace su papel. Y un dato que empieza por - todavía puede confundirse con una opción del comando: muchos programas aceptan -- para marcar dónde acaban las opciones, como en system("cat", "--", fichero).

Una vía más que conviene conocer si mantienes código antiguo: hasta Ruby 3.4, open("|comando") e IO.read("|comando") también ejecutaban comandos (con -W:deprecated, Ruby 3.4 avisa de que se eliminaría). Ruby 4.0 lo eliminó, y ahora esa cadena se trata como un nombre de fichero:

p open("|echo desde open").read
pipe.rb:1:in 'File#initialize': No such file or directory @ rb_sysopen - |echo desde open (Errno::ENOENT)

En Ruby 3.4.12, el mismo código imprime "desde open\n". Si necesitas ese comportamiento, usa IO.popen.

Errores frecuentes

Los mensajes son de Ruby 4.0.9; Ruby 3.4.12 da los mismos, salvo la ruta de open3.rb, que incluye la versión.

1. Juntar varios argumentos en uno. Con varios argumentos, cada cadena es exactamente un argumento. Aquí ls recibe una sola opción, "-l /tmp", con el espacio dentro:

system("ls", "-l /tmp")
p $?.exitstatus
ls: invalid option -- ' '
Try 'ls --help' for more information.
2

Escribe system("ls", "-l", "/tmp").

2. Comparar la salida sin quitar el salto de línea.

rama = `echo main`
p rama                 # => "main\n"
p rama == "main"       # => false
p rama.chomp == "main" # => true

3. Esperar que Open3 devuelva un error cuando el programa no existe. Igual que las comillas invertidas sin shell, lanza una excepción en vez de rellenar err:

require "open3"
Open3.capture3("comando-que-no-existe")
/usr/local/lib/ruby/4.0.0/open3.rb:534:in 'Kernel#spawn': No such file or directory - comando-que-no-existe (Errno::ENOENT)

Captúrala con rescue Errno::ENOENT si el programa puede no estar instalado. Más en excepciones en Ruby.

4. Mirar $? sin haber ejecutado nada. Vale nil, así que preguntarle cualquier cosa falla:

$?.success?
nil2.rb:1:in '<main>': undefined method 'success?' for nil (NoMethodError)

5. No comprobar el resultado. Las comillas invertidas devuelven la salida aunque el comando falle: un "" puede significar «no había nada» o «ha fallado». Mira siempre $?.success?, o usa Open3.capture3 y su status.

Compruébalo con un test

Si tu programa lanza comandos en varios sitios, conviene envolverlos en un único método. Así el resultado tiene siempre la misma forma y puedes probarlo. Fichero comando.rb, con Data.define (una clase de solo lectura en una línea):

require "open3"

module Comando
  Resultado = Data.define(:salida, :error, :codigo) do
    def ok? = codigo.zero?
  end

  def self.ejecuta(*argumentos)
    salida, error, status = Open3.capture3(*argumentos)
    Resultado.new(salida: salida, error: error, codigo: status.exitstatus)
  end
end

Fichero comando_test.rb, con Minitest, que viene con Ruby:

require "minitest/autorun"
require_relative "comando"

class ComandoTest < Minitest::Test
  def test_devuelve_la_salida_de_un_comando_que_va_bien
    resultado = Comando.ejecuta("echo", "hola")

    assert resultado.ok?
    assert_equal "hola\n", resultado.salida
  end

  def test_separa_el_error_y_el_codigo_cuando_falla
    resultado = Comando.ejecuta("ls", "/no-existe")

    refute resultado.ok?
    assert_equal 2, resultado.codigo
    assert_match(/No such file or directory/, resultado.error)
  end

  def test_no_ejecuta_lo_que_venga_en_un_argumento
    resultado = Comando.ejecuta("echo", "x; echo INYECTADO")

    assert_equal "x; echo INYECTADO\n", resultado.salida
  end
end
ruby comando_test.rb
3 runs, 7 assertions, 0 failures, 0 errors, 0 skips

El último test protege contra la inyección: si alguien cambia ejecuta para que junte los argumentos en una cadena, falla. Para empezar con tests en Ruby, lee la introducción al testing en Ruby.

Cuándo no usar comandos del sistema

  • Para lo que Ruby ya hace. Copiar, mover o borrar ficheros con cp, mv o rm funciona, pero FileUtils lo hace sin shell, sin depender del sistema y con errores de Ruby. Para leer y escribir ficheros tampoco los necesitas, como se ve en trabajar con ficheros en Ruby.
  • Si el programa tiene que funcionar en Windows. ls, grep o tr no existen allí, y la shell es otra. Cada comando externo es una dependencia más de tu programa.
  • Con salidas enormes o comandos que no acaban. capture3 y las comillas invertidas esperan a que el comando termine y guardan toda la salida en memoria. Para ir leyendo mientras se ejecuta, Open3.popen3 te da los canales del proceso, pero hay que leer la salida y los errores a la vez (por ejemplo, con un hilo para cada uno): si uno de los dos se llena y nadie lo lee, el proceso se queda bloqueado. Si no necesitas separarlos, Open3.popen2e los junta en un solo canal; y si puedes esperar al final, capture3 ya resuelve esto por ti.

Ejercicio

  1. Copia Comando y su test. Añade un test para un programa que no existe y decide qué debe devolver ejecuta: ¿una excepción o un Resultado con código 127?
  2. Escribe Comando.cuenta_lineas(ruta), que use wc -l y devuelva un número. Pruébalo con una ruta que contenga un espacio y un punto y coma.
  3. Reescribe el ejemplo «peligroso» de la inyección con Shellwords.escape y comprueba que solo imprime una línea.

Y si vas a filtrar la salida de un comando, te vendrán bien las expresiones regulares en Ruby.

Fuentes

  • Documentación oficial de Ruby 4.0: Kernel (`, system, exec y spawn), Process (cuándo una cadena pasa por la shell y Process.last_status, que es del hilo actual), Process::Status, Open3 (capture3, capture2, capture2e y stdin_data), Shellwords (escapa para la shell Bourne y el resultado se usa sin comillas), NEWS de Ruby 4.0 (se elimina la creación de procesos con | en Kernel#open y los métodos de clase de IO) y Command injection.
  • Los ejemplos del artículo original se ejecutaron el 7 de noviembre de 2026 con Ruby 4.0.9. El 12 de noviembre de 2026 se han ejecutado todos, incluidos los nuevos, en Docker con las imágenes oficiales ruby:3.4 (Ruby 3.4.12, Minitest 5.25.4) y ruby:4.0 (Ruby 4.0.9, Minitest 6.0.0), con la misma salida en las dos. El ejemplo de inyección del artículo original usaba rm -rf / y no se ejecutó; se ha sustituido por uno inofensivo que sí se ha ejecutado. Que $? vale nil antes de ejecutar nada, el código 127 de la shell, system("exit 3") y el cambio de open("|…") entre 3.4 y 4.0 se han comprobado ejecutándolos. Las salidas de error están recortadas a las líneas que importan.