Ejecutar comandos del sistema desde Ruby: system, %x y Open3
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
exitstatuses 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;lsusa 2 para «no existe».success?estruesolo si el código es 0.- Antes de ejecutar ningún comando,
$?valenil. $?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/shsi 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 esosystem("exit 3")funciona aunque no exista ningún programaexit: devuelvefalsey$?.exitstatusvale 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,mvormfunciona, peroFileUtilslo 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,grepotrno 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.
capture3y las comillas invertidas esperan a que el comando termine y guardan toda la salida en memoria. Para ir leyendo mientras se ejecuta,Open3.popen3te 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.popen2elos junta en un solo canal; y si puedes esperar al final,capture3ya resuelve esto por ti.
Ejercicio
- Copia
Comandoy su test. Añade un test para un programa que no existe y decide qué debe devolverejecuta: ¿una excepción o unResultadocon código 127? - Escribe
Comando.cuenta_lineas(ruta), que usewc -ly devuelva un número. Pruébalo con una ruta que contenga un espacio y un punto y coma. - Reescribe el ejemplo «peligroso» de la inyección con
Shellwords.escapey 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,execyspawn), Process (cuándo una cadena pasa por la shell yProcess.last_status, que es del hilo actual), Process::Status, Open3 (capture3,capture2,capture2eystdin_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|enKernel#openy los métodos de clase deIO) 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) yruby: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 usabarm -rf /y no se ejecutó; se ha sustituido por uno inofensivo que sí se ha ejecutado. Que$?valenilantes de ejecutar nada, el código 127 de la shell,system("exit 3")y el cambio deopen("|…")entre 3.4 y 4.0 se han comprobado ejecutándolos. Las salidas de error están recortadas a las líneas que importan.