Obtener información del usuario en Ruby: gets y chomp
Hasta ahora tus programas hablan, pero no escuchan. Para que el usuario te diga algo (su nombre, una edad, una opción de un menú) Ruby tiene gets.
gets se queda esperando tu respuesta: el programa no sigue hasta que contestas. Es como el camarero que pregunta «¿qué te pongo?» y no se mueve de la mesa hasta que contestas.
Pedir datos con gets
Guarda esto en saludo.rb:
print "Introduce tu nombre: "
nombre = gets
puts "Hola #{nombre}. ¡Buenos días!"
ruby saludo.rb
Al ejecutarlo parece que el programa no hace nada: solo ves la pregunta y el cursor parpadeando. Está esperando. Escribes el nombre, pulsas Intro y Ruby lo mete en la frase con la interpolación de cadenas (#{nombre}).
La pregunta se escribe con print porque, a diferencia de puts, no añade salto de línea y así el usuario escribe en la misma línea.
El salto de línea que se cuela
El resultado sale partido en dos líneas:
Introduce tu nombre: Ana
Hola Ana
. ¡Buenos días!
El motivo: gets devuelve todo lo que escribiste, incluido el Intro, que es un carácter de salto de línea (\n). Si lo inspeccionas con p nombre lo ves:
nombre = gets # escribes Ana e Intro
p nombre # => "Ana\n"
Quitarlo con gets.chomp
chomp quita ese salto de línea del final del texto:
print "Introduce tu nombre: "
nombre = gets.chomp
puts "Hola #{nombre}. ¡Buenos días!"
Introduce tu nombre: Ana
Hola Ana. ¡Buenos días!
chomp solo quita el salto de línea del final, si lo hay: no toca los espacios ni nada de en medio. Si además quieres quitar los espacios que el usuario haya escrito de más, usa strip, que quita espacios y saltos de línea por los dos lados.
Como norma, cuando pidas texto al usuario, usa gets.chomp. También puedes escribir gets(chomp: true), que devuelve el texto ya sin el salto de línea.
Pedir números
gets siempre devuelve texto. Si necesitas operar con lo que escribe el usuario, conviértelo:
print "Edad: "
edad = gets.to_i # "41\n" se convierte en 41
puts "El año que viene tendrás #{edad + 1}"
Edad: 41
El año que viene tendrás 42
| Quieres… | Usa | Si escribe 41 e Intro |
|---|---|---|
| El texto tal cual | gets |
"41\n" |
| El texto sin salto de línea | gets.chomp |
"41" |
| Un número entero | gets.to_i |
41 |
| Un número con decimales | gets.to_f |
41.0 |
to_i no se fija en el salto de línea: lee las cifras del principio y se para en lo primero que no lo sea. Por eso "41\n".to_i es 41, pero también "12abc".to_i es 12, y si el texto no empieza por un número, devuelve 0. Si escribes hola, la edad será 0 y el programa dirá «tendrás 1» sin quejarse. Más abajo se ve cómo validarlo.
Probarlo sin teclear: redirigir la entrada
Escribir la respuesta a mano cada vez que pruebas el programa cansa. En la terminal puedes darle la respuesta por adelantado: la entrada estándar (lo que el programa lee con gets) no tiene por qué ser el teclado; puede venir de otro comando o de un fichero.
Con una tubería (|), lo que escribe echo le llega al programa como si lo hubieras tecleado:
echo "Ana" | ruby saludo.rb
Introduce tu nombre: Hola Ana. ¡Buenos días!
Ahora el nombre no aparece detrás de la pregunta. No falta nada: cuando tecleas, lo que ves en pantalla es el eco de la terminal, y aquí nadie ha tecleado. El programa ha recibido "Ana\n" igual que antes.
Con < la entrada sale de un fichero. Si nombres.txt tiene una línea Ana y otra Luis, este programa las lee todas:
while (linea = gets)
puts "Leído: #{linea.chomp}"
end
puts "Fin de la entrada"
ruby lineas.rb < nombres.txt
Leído: Ana
Leído: Luis
Fin de la entrada
El bucle funciona porque, al terminar el fichero, gets devuelve nil, y while se para con nil. Al teclear, ese «se acabó» se consigue con Ctrl + D al principio de una línea en Linux y macOS. Con ruby lineas.rb nombres.txt, sin el <, el resultado es el mismo; en los errores frecuentes se explica por qué.
Errores frecuentes
Las salidas son de Ruby 4.0.9, recortadas a las líneas que importan; en Ruby 3.4.12 salen igual salvo donde se indica.
1. Llamar a chomp cuando ya no queda entrada. Si no hay nada que leer, gets devuelve nil, y nil no tiene chomp:
nombre = gets.chomp
puts "Hola #{nombre}"
ruby nil_chomp.rb < /dev/null
nil_chomp.rb:1:in '<main>': undefined method 'chomp' for nil (NoMethodError)
nombre = gets.chomp
^^^^^^
/dev/null es un fichero especial que siempre está vacío al leerlo: sirve para simular que la entrada se acaba, como si el usuario pulsara Ctrl + D sin escribir nada. En un programa que solo se usa con teclado puede no importarte; en uno que lee de ficheros o de otros programas, sí. El operador &. llama a chomp solo si hay algo, y || pone un valor por defecto:
nombre = gets&.chomp || "desconocido"
puts "Hola #{nombre}"
ruby seguro.rb < /dev/null
Hola desconocido
2. Pasarle argumentos al programa y que gets intente abrirlos. gets (el de Kernel) no lee siempre del teclado: si el programa recibe argumentos, los toma como nombres de fichero y lee de ellos. Por eso ruby lineas.rb nombres.txt funcionaba. Pero si el argumento no es un fichero:
echo "Ana" | ruby saludo.rb Luis
saludo.rb:2:in 'ARGF.class#gets': No such file or directory @ rb_sysopen - Luis (Errno::ENOENT)
Si tu programa usa argumentos y además pregunta al usuario, lee explícitamente de la entrada estándar con $stdin.gets:
print "Introduce tu nombre: "
nombre = $stdin.gets.chomp
puts "Hola #{nombre}. ¡Buenos días!"
puts "Argumentos: #{ARGV.inspect}"
echo "Ana" | ruby saludo_stdin.rb Luis
Introduce tu nombre: Hola Ana. ¡Buenos días!
Argumentos: ["Luis"]
3. Fiarse de to_i para validar números. to_i nunca falla, así que un error del usuario pasa desapercibido. Integer(texto, 10) sí falla si el texto no es un número entero en base 10 (los espacios y el salto de línea de los extremos los acepta):
print "Edad: "
edad = Integer(gets, 10)
puts "El año que viene tendrás #{edad + 1}"
echo "hola" | ruby integer.rb
integer.rb:2:in 'Kernel#Integer': invalid value for Integer(): "hola\n" (ArgumentError)
En Ruby 3.4.12 la primera línea empieza por <internal:kernel>:290 en vez de integer.rb:2; el mensaje es el mismo.
¿Por qué el 10? Sin él, Integer interpreta los prefijos como hace Ruby con los números del código: sin el 10, Ruby lee 010 como octal.
p Integer("010") # 8: el 0 delante lo lee como octal
p Integer("010", 10) # 10
Sin la base, "0b11" también se aceptaría (vale 3, en binario) y "08" daría error. Alguien que escribe 010 como edad quiere decir 10, no 8.
Con Integer(texto, 10, exception: false) no salta el error: devuelve nil, y puedes volver a preguntar. Es lo que hace el ejemplo siguiente.
Compruébalo con un test
Un método que lee del teclado parece imposible de probar sin teclear. El truco es pasarle de dónde leer y dónde escribir, con el teclado y la pantalla como valores por defecto. Guarda pedir_edad.rb:
def pedir_edad(entrada = $stdin, salida = $stdout)
loop do
salida.print "Edad: "
respuesta = entrada.gets
return nil if respuesta.nil?
edad = Integer(respuesta, 10, exception: false)
return edad if edad && edad >= 0
salida.puts "«#{respuesta.chomp}» no es una edad válida"
end
end
if __FILE__ == $PROGRAM_NAME
edad = pedir_edad
puts edad ? "El año que viene tendrás #{edad + 1}" : "No se ha recibido ninguna edad"
end
Pregunta hasta recibir un número entero no negativo, y devuelve nil si la entrada se acaba. Desde la terminal:
printf 'hola\n-3\n41\n' | ruby pedir_edad.rb
Edad: «hola» no es una edad válida
Edad: «-3» no es una edad válida
Edad: El año que viene tendrás 42
En el test, StringIO hace de teclado y de pantalla: es un objeto que se comporta como un fichero, pero guarda el texto en memoria. Guarda pedir_edad_test.rb en la misma carpeta:
require "minitest/autorun"
require "stringio"
require_relative "pedir_edad"
class PedirEdadTest < Minitest::Test
def test_convierte_la_respuesta_en_numero
assert_equal 41, pedir_edad(StringIO.new("41\n"), StringIO.new)
end
def test_vuelve_a_preguntar_si_no_es_un_numero
salida = StringIO.new
assert_equal 41, pedir_edad(StringIO.new("hola\n41\n"), salida)
assert_includes salida.string, "«hola» no es una edad válida"
end
def test_devuelve_nil_si_se_acaba_la_entrada
assert_nil pedir_edad(StringIO.new(""), StringIO.new)
end
end
ruby pedir_edad_test.rb
3 runs, 5 assertions, 0 failures, 0 errors, 0 skips
El tercer test es el nil del final de la entrada: sin la línea return nil if respuesta.nil?, el programa fallaría con el NoMethodError de antes. Si es tu primer test en Ruby, empieza por la introducción al testing en Ruby.
Cuándo no usar gets
- Para datos que el programa necesita al arrancar (un fichero, una opción), suelen encajar mejor los argumentos de la línea de comandos, que llegan en
ARGV:ruby informe.rb ventas.csv. Así el programa se puede usar en un script sin nadie delante. - Para leer un fichero entero, abre el fichero directamente; lo tienes en trabajar con ficheros en Ruby.
- Para contraseñas,
getsenseña en pantalla lo que se escribe. La libreríaio/consolede Ruby tieneIO#getpass: conrequire "io/console",$stdin.getpass("Contraseña: ")lee la línea sin mostrarla en pantalla y sin el salto de línea final.
Ejercicio de cinco minutos
- Pide nombre y edad, y escribe «Ana tiene 41 años». Pruébalo con
printf 'Ana\n41\n' | ruby tu_programa.rb. - Haz que
lineas.rbnumere las líneas (1: Ana,2: Luis) y pruébalo con< nombres.txty con< /dev/null. - Añade al test de
pedir_edadun caso con" 41 \n"(con espacios) y averigua si lo acepta.
Fuentes
- Documentación oficial de Ruby 4.0: Kernel#gets (lee de los ficheros de
ARGVo, si no hay, de la entrada estándar, y devuelvenilal final), Kernel#Integer (con base y conexception: false), String#chomp, #strip, #to_i y #to_f, StringIO e IO#getpass deio/console. - Los ejemplos del artículo original se ejecutaron en Docker con
ruby:latest(Ruby 4.0.9) en noviembre de 2026. El 12 de noviembre de 2026 se ha repetido todo con las imágenes oficialesruby:4.0(Ruby 4.0.9, Minitest 6.0.0) yruby:3.4(Ruby 3.4.12, Minitest 5.25.4): las salidas con teclado (ygetpass), escribiendo en un pseudoterminal (libreríaptyde Ruby), y las demás redirigiendo la entrada estándar conecho,printf,< nombres.txty< /dev/null. Las salidas coinciden en las dos versiones salvo la traza deInteger(), indicada en su sitio.