Nivel inicial7 min de lectura · Publicado el

Obtener información del usuario en Ruby: gets y chomp

Obtener información del usuario en Ruby: gets espera a que escribas; devuelve "Ana\n" con el Intro, y gets.chomp, "Ana". gets.chomp quita el Introrubentejera.com Introduce tu nombre:espera…gets"Ana\n"el Introgets.chomp"Ana"
El programa se para en gets hasta que el usuario escribe y pulsa Intro. Lo que devuelve incluye ese Intro, el salto de línea \n; chomp lo quita. Si esperas un número, usa gets.to_i.

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, gets enseña en pantalla lo que se escribe. La librería io/console de Ruby tiene IO#getpass: con require "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

  1. Pide nombre y edad, y escribe «Ana tiene 41 años». Pruébalo con printf 'Ana\n41\n' | ruby tu_programa.rb.
  2. Haz que lineas.rb numere las líneas (1: Ana, 2: Luis) y pruébalo con < nombres.txt y con < /dev/null.
  3. Añade al test de pedir_edad un 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 ARGV o, si no hay, de la entrada estándar, y devuelve nil al final), Kernel#Integer (con base y con exception: false), String#chomp, #strip, #to_i y #to_f, StringIO e IO#getpass de io/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 oficiales ruby:4.0 (Ruby 4.0.9, Minitest 6.0.0) y ruby:3.4 (Ruby 3.4.12, Minitest 5.25.4): las salidas con teclado (y getpass), escribiendo en un pseudoterminal (librería pty de Ruby), y las demás redirigiendo la entrada estándar con echo, printf, < nombres.txt y < /dev/null. Las salidas coinciden en las dos versiones salvo la traza de Integer(), indicada en su sitio.