Nivel inicial9 min de lectura · Publicado el

Métodos en Ruby: definición, parámetros y return

Métodos en Ruby: def sumar(a, b) como una caja con dos entradas, a y b, que devuelve su última línea, a + b: sumar(5, 2) da 7. Métodos en Ruby: la última línearubentejera.com def sumar(a, b)5a2ba + b7sin escribir returnsumar(5, 2) # 7
Los parámetros a y b son las entradas de la caja; al llamar a sumar(5, 2), a vale 5 y b vale 2. El método devuelve el valor de su última línea, a + b, sin escribir return.

Un método en Ruby es un trozo de código con nombre, que empieza por def y termina en end, y que puedes usar tantas veces como quieras. Es como una receta: la escribes una vez y luego solo dices «haz la tortilla», con los ingredientes que toquen ese día (los parámetros).

Cómo definir un método en Ruby

def saludar
  puts "Hola. ¡Buenos días!"
end

saludar  # Hola. ¡Buenos días!

Cómo nombrarlo

El nombre empieza por minúscula y se escribe en snake_case (palabras en minúscula separadas por guion bajo). El último carácter da una pista de lo que hace:

Final Significado Ejemplo
? Hace una pregunta y devuelve true o false valido?, empty?
! Versión «peligrosa»: suele modificar el propio objeto chomp!, merge!
= Asigna un valor (un setter) apellido=
class Persona
  def apellido=(valor)
    @apellido = valor
  end
end

persona = Persona.new
persona.apellido = "López"   # llama al método apellido=

chomp o chop: casi iguales, pero no

Los dos quitan algo del final de un texto, y es fácil confundirlos. chomp quita el salto de línea final, si lo hay; chop quita el último carácter, sea cual sea:

linea = "hola\n"
p linea.chomp   # "hola"
p linea.chop    # "hola"
p "hola".chomp  # "hola"
p "hola".chop   # "hol"

Con lo que llega de gets al escribir en el teclado suelen dar lo mismo, porque la línea acaba en salto. Pero la última línea de un fichero, o de una entrada redirigida, puede no llevarlo, y ahí chop se come una letra:

# dos_lineas.txt contiene "hola\nadios", sin salto al final
File.foreach("dos_lineas.txt") { |linea| p [linea.chomp, linea.chop] }
["hola", "hola"]
["adios", "adio"]

Usa chomp: más sobre leer del teclado en obtener información del usuario en Ruby.

Parámetros

def saludar(nombre)
  puts "Hola #{nombre}. ¡Buenos días!"
end

saludar("Ana")   # con paréntesis, la convención más habitual
saludar "Ana"    # sin paréntesis también funciona

Con varios parámetros, se separan por comas. Este ejemplo pide el nombre por teclado con gets.chomp:

def saludar(nombre, saludo)
  puts "Hola #{nombre}. ¡#{saludo}!"
end

print "Introduce tu nombre: "
nombre = gets.chomp
saludar(nombre, "Buenos días")

Parámetros por defecto

Si el parámetro no llega, se usa el valor por defecto:

def saludar(saludo = "Hola", nombre = "usuari@")
  puts "#{saludo} #{nombre}!"
end

saludar                          # Hola usuari@!
saludar("Qué pasa", "Antonio")   # Qué pasa Antonio!

El valor por defecto se calcula de nuevo en cada llamada. Si vienes de Python, donde una lista por defecto se comparte entre llamadas, aquí no pasa:

def añadir(producto, lista = [])
  lista << producto
end

p añadir("pan")    # ["pan"]
p añadir("leche")  # ["leche"]

Parámetros con nombre

Con los keyword arguments (parámetros con nombre) el orden da igual y la llamada se lee sola. Si no tienen valor por defecto, son obligatorios:

def crear_usuario(nombre:, edad: 18)
  "#{nombre} (#{edad})"
end

crear_usuario(nombre: "Ana")             # => "Ana (18)"
crear_usuario(edad: 30, nombre: "Luis")  # => "Luis (30)"
crear_usuario                            # ArgumentError: missing keyword: :nombre

Devolver un valor

Un método devuelve el valor de su última expresión. return solo hace falta para salir antes:

def sumar(a, b)
  a + b   # igual que: return a + b
end

puts "El resultado de la suma es #{sumar(5, 2)}"   # 7

Si el método cabe en una línea, desde Ruby 3.0 puedes escribirlo así:

def cuadrado(x) = x * x

Devolver varios valores

Con return y varios valores separados por comas, Ruby los devuelve en un array. Lo más cómodo es recogerlos en varias variables a la vez:

def datos_personales
  return "Ana", "López", "35010"
end

datos_personales                       # => ["Ana", "López", "35010"]
nombre, apellido, cp = datos_personales
puts cp                                # 35010

Número variable de parámetros: el operador splat

Con un asterisco (*) delante, el parámetro recoge todos los argumentos que lleguen en un array. A este * se le llama splat:

def dar_bienvenida(saludo, *personas)
  personas.each do |persona|
    puts "#{saludo} #{persona}, ¡bienvenido!"
  end
end

dar_bienvenida("Hey!!", "Luis", "Carlos")
# Hey!! Luis, ¡bienvenido!
# Hey!! Carlos, ¡bienvenido!

Otra forma de usar la lista:

def saludar_a_todos(saludo, *nombres)
  puts "#{saludo} #{nombres.join(", ")}!"
end

saludar_a_todos("Qué pasa", "Antonio", "Pepe", "Juan")   # Qué pasa Antonio, Pepe, Juan!

Pasar un array: con o sin *

Si pasas un array tal cual, cuenta como un argumento. Con * delante, se «desempaqueta» y cada elemento cuenta por separado:

dar_bienvenida("Hey!!", ["Luis", "Carlos"], "Pepe")
# Hey!! ["Luis", "Carlos"], ¡bienvenido!
# Hey!! Pepe, ¡bienvenido!

dar_bienvenida("Hey!!", *["Luis", "Carlos"], "Pepe")
# Hey!! Luis, ¡bienvenido!
# Hey!! Carlos, ¡bienvenido!
# Hey!! Pepe, ¡bienvenido!

El equivalente para parámetros con nombre es **: def opciones(**extra) recoge todos los que lleguen en un hash.

Métodos que reciben un bloque

Además de parámetros, un método puede recibir un bloque de código y ejecutarlo con yield:

def repetir(veces)
  veces.times { |i| yield i }
end

repetir(2) { |i| puts "vuelta #{i}" }
# vuelta 0
# vuelta 1

Lo tienes en detalle en Bloques en Ruby.

Un buen nombre de método te ahorra leer su código.

Errores frecuentes

1. Pasar menos argumentos de los que pide. Ruby cuenta los argumentos al llamar y, si no cuadran, para:

def saludar(nombre, saludo)
  "#{saludo}, #{nombre}"
end

puts saludar("Ana")

Con Ruby 3.4:

saludar.rb:1:in 'saludar': wrong number of arguments (given 1, expected 2) (ArgumentError)
	from saludar.rb:5:in '<main>'

Con Ruby 4.0, el mensaje enseña también la llamada (caller) y la definición (callee), así que ves de un vistazo qué falta:

saludar.rb:1:in 'Object#saludar': wrong number of arguments (given 1, expected 2) (ArgumentError)

    caller: saludar.rb:5
    | puts saludar("Ana")
           ^^^^^^^
    callee: saludar.rb:1
    | def saludar(nombre, saludo)
          ^^^^^^^
	from saludar.rb:5:in '<main>'

given 1, expected 2 se lee «has dado 1, esperaba 2».

2. Llamar al método antes de definirlo. En un fichero, Ruby lee de arriba abajo. Si la llamada va antes que el def, el método todavía no existe:

puts doble(4)

def doble(n) = n * 2
undefined method 'doble' for main (NoMethodError)

Si la llamada está dentro de otro método, no pasa: solo importa que doble exista cuando ese método se ejecute.

def cuadruple(n) = doble(doble(n))   # doble aún no existe, pero no importa

def doble(n) = n * 2

puts cuadruple(3)   # 12

3. Terminar el método con puts. puts escribe en pantalla y devuelve nil. Si es la última línea, el método devuelve nil, no el valor:

def total(precios)
  suma = precios.sum
  puts "Total: #{suma}"
end

resultado = total([10, 20])
p resultado
Total: 30
nil

Deja que el método calcule y devuelva (precios.sum) y que quien lo llama decida si lo imprime.

4. Escribir mal un parámetro con nombre. Es una ventaja frente a los parámetros por posición: Ruby te avisa en vez de ignorarlo.

def crear_usuario(nombre:, edad: 18)
  "#{nombre} (#{edad})"
end

puts crear_usuario(nombre: "Ana", eda: 30)
unknown keyword: :eda (ArgumentError)

Y si lo pasas sin nombre, también:

puts crear_usuario("Ana")   # el mismo crear_usuario de arriba, sin el nombre del parámetro
wrong number of arguments (given 1, expected 0; required keyword: nombre) (ArgumentError)

5. Usar el resultado de un método con !. Muchos métodos con ! devuelven nil cuando no cambian nada. Si guardas su resultado, puedes acabar con nil en lugar del texto:

nombre = "Ana".strip!
p nombre   # nil

Como "Ana" no tiene espacios que quitar, strip! no cambia nada y devuelve nil. Para guardar el resultado, usa la versión sin !: nombre = "Ana".strip.

Compruébalo con un test

Un método que recibe datos y devuelve un resultado, sin escribir en pantalla, es el más fácil de probar: le das una entrada y compruebas la salida. Este calcula un precio con descuento e IVA y rechaza un descuento imposible lanzando un error (excepciones en Ruby):

require "minitest/autorun"

def precio_final(precio, descuento: 0, iva: 0.21)
  raise ArgumentError, "descuento fuera de rango: #{descuento}" unless (0..100).cover?(descuento)

  (precio * (1 - descuento / 100.0) * (1 + iva)).round(2)
end

class PrecioFinalTest < Minitest::Test
  def test_sin_descuento_solo_suma_el_iva
    assert_equal 121.0, precio_final(100)
  end

  def test_aplica_el_descuento_antes_del_iva
    assert_equal 108.9, precio_final(100, descuento: 10)
  end

  def test_rechaza_un_descuento_imposible
    error = assert_raises(ArgumentError) { precio_final(100, descuento: 120) }
    assert_equal "descuento fuera de rango: 120", error.message
  end
end
ruby precio_final_test.rb
3 runs, 4 assertions, 0 failures, 0 errors, 0 skips

Fíjate en descuento / 100.0: con 100 a secas, 10 / 100 es una división entre enteros y da 0, así que el descuento desaparecería. El segundo test lo detectaría. Para empezar con tests en Ruby, lee la introducción al testing en Ruby.

Cuándo no escribir un método así

Un método está bien cuando hace una cosa y su nombre la cuenta. Estas son las señales de que conviene cambiarlo:

  • Recibe valores true y false sueltos. En la llamada no se sabe qué significa cada uno:
def enviar_pedido(cliente, urgente, regalo)
  etiquetas = [cliente]
  etiquetas << "urgente" if urgente
  etiquetas << "para regalo" if regalo
  etiquetas.join(" · ")
end

puts enviar_pedido("Ana", false, true)   # Ana · para regalo. ¿Qué era false? ¿Y true?

Con parámetros con nombre, la llamada se explica sola, y los que no hacen falta se omiten:

def enviar_pedido(cliente, urgente: false, regalo: false)
  etiquetas = [cliente]
  etiquetas << "urgente" if urgente
  etiquetas << "para regalo" if regalo
  etiquetas.join(" · ")
end

puts enviar_pedido("Ana", regalo: true)   # Ana · para regalo
  • Tiene más de tres o cuatro parámetros. Suele indicar que varios de ellos van siempre juntos y merecen su propio objeto (un Pedido, una Direccion). Cómo crear uno, en Clases en Ruby.
  • Calcula y además imprime. Como en el error 3: sepáralo en un método que calcula y otro que muestra. El que calcula se prueba sin capturar la pantalla.
  • No te cabe en la pantalla. Si para entenderlo hay que hacer scroll, probablemente hace varias cosas. Extrae cada una a un método con un buen nombre. Lo tienes desarrollado, con un ejemplo paso a paso, en funciones en código limpio.

Ejercicio de cinco minutos

  1. Copia el test de precio_final y cambia 100.0 por 100. ¿Qué test falla y con qué mensaje?
  2. Añade un test para precio_final(100, descuento: -5). ¿Pasa ya, o tienes que tocar el método?
  3. Escribe un método iniciales(nombre_completo) que devuelva "A. L." para "Ana López". Escribe primero el test y después el método, sin usar puts dentro.

Fuentes

  • Methods y Calling Methods, documentación oficial de Ruby 4.0 (valores por defecto, parámetros con nombre, splat y bloques), y String (chomp, chop y strip!).
  • NEWS de Ruby 4.0: el apartado de ErrorHighlight recoge que un ArgumentError muestra ahora el fragmento de la llamada (caller) y el de la definición (callee).
  • Los ejemplos del artículo original se ejecutaron con Ruby 4.0.9 (imagen oficial ruby:latest de Docker) en noviembre de 2026. Se corrigieron dos errores del ejemplo original del splat: llamaba al método antes de definirlo y usaba una variable (mensaje) que no existía.
  • Los ejemplos nuevos (chomp y chop, valores por defecto, errores frecuentes, el test y los parámetros con nombre) se han ejecutado el 11 de noviembre de 2026 en Docker con las imágenes ruby:3.4 (Ruby 3.4.12, Minitest 5.25.4) y ruby:4.0 (Ruby 4.0.9, Minitest 6.0.0). La salida es la misma en las dos salvo el mensaje del ArgumentError, que se muestra con las dos versiones. Las salidas de error están recortadas a las líneas que importan.