Nivel inicial10 min de lectura · Publicado el

Operadores en Ruby: módulo %, <=>, &., ||= y más

Operadores en Ruby por grupos: cuentas (+ - * / % **), asignar (= += -= ||=), comparar (== != < <= <=> ===) y combinar (&& || !). = guarda; == compararubentejera.com cuentas+-*/%**asignar=+=-=||=comparar==!=<<=<=>===combinar&&||!
Cuatro familias de operadores: hacer cuentas, guardar un valor, comparar (true o false; <=> da -1, 0 o 1) y combinar condiciones. Ojo: = asigna y == compara; === es la igualdad de case.

Los operadores en Ruby son los símbolos con los que haces cuentas, guardas valores, comparas y combinas condiciones: +, %, =, ==, <=>, &&… Son pocos, pero aparecen en casi cada línea. Esta es la chuleta; debajo, cada uno con ejemplos ejecutados en Ruby 4.0.9.

Familia Operadores Para qué
Aritméticos + - * / % ** Hacer cuentas; % da el resto y ** eleva a una potencia
Asignación = += -= *= /= ||= &&= Guardar un valor en una variable
Comparación == != < <= > >= <=> === Comparar dos valores
Lógicos && || ! (y and, or, not) Combinar condiciones
Navegación segura &. Llamar a un método solo si el objeto no es nil

¿Buscabas module? Eso no es un operador: los módulos (include, extend, mixins) se explican en Módulos en Ruby.

Operadores aritméticos

7 + 2    # => 9
7 - 2    # => 5
7 * 2    # => 14
7 / 2    # => 3    (entre enteros, la división redondea hacia abajo)
-7 / 3   # => -3   (hacia abajo también con negativos)
7.0 / 2  # => 3.5
7 % 3    # => 1    (resto de la división)
2 ** 3   # => 8    (potencia)

Ojo con 7 / 2: si los dos números son enteros, el resultado también lo es. Si necesitas decimales, que uno de los dos lo sea (7.0) o usa 7.fdiv(2).

El operador módulo (%): el resto de una división

% divide y se queda con lo que sobra. Piensa en un reloj: si son las 22:00 y pasan 5 horas, no son las 27:00, sino las 3:00. Das la vuelta al llegar a 24 y te quedas con el resto. Eso es exactamente (22 + 5) % 24.

En Ruby, % también tiene nombre de método: modulo. Los dos hacen lo mismo.

p 10 % 3        # resto de 10 entre 3
p 10.modulo(3)  # lo mismo, con nombre
p 12 % 4        # división exacta: resto 0
p 7.5 % 2       # también con decimales

(1..10).each do |n|
  print n, (n % 3 == 0 ? " <- múltiplo de 3\n" : "\n")
end
1
1
0
1.5
1
2
3 <- múltiplo de 3
4
5
6 <- múltiplo de 3
7
8
9 <- múltiplo de 3
10

Tres usos habituales: saber si un número es múltiplo de otro (n % 3 == 0), hacer algo «cada N vueltas» en un bucle y dar la vuelta, como en el reloj:

hora = 22
p((hora + 5) % 24)   # 5 horas después de las 22
p 7.even?            # par
p 7 % 2 == 1         # lo mismo con %
3
false
true

Para saber si un número es par o impar, Ruby ya tiene even? y odd?, que se leen mejor que n % 2 == 0.

Con números negativos: % (modulo) frente a remainder

Aquí Ruby se diferencia de otros lenguajes. Con negativos, el resultado de % toma el signo del divisor (el número de la derecha). Si quieres el resto con el signo del dividendo (el de la izquierda), como el % de JavaScript o Java, usa remainder:

p(-7 % 3)             # % sigue el signo del divisor
p 7 % -3
p(-7.remainder(3))    # remainder sigue el signo del dividendo
p 7.remainder(-3)
p(-7 / 3)             # la división entera redondea hacia abajo
2
-2
-1
1
-3

La razón está en la última línea. En Ruby, -7 / 3 da -3, no -2: la división entera redondea hacia abajo. Y % es lo que falta para volver al número original: 3 * -3 + 2 = -7. La documentación lo resume así: n % r equivale a n - r * (n / r).floor.

Expresión % / modulo remainder
7 entre 3 1 1
-7 entre 3 2 -1
7 entre -3 -2 1

Si solo trabajas con números positivos, los dos dan lo mismo y no tienes que pensar en esto.

divmod: cociente y resto a la vez

divmod hace la división entera y el módulo en un solo paso, y devuelve los dos en un array. Con la asignación paralela los recoges en dos variables:

segundos = 125
minutos, resto = segundos.divmod(60)
puts "#{minutos} min #{resto} s"

p 17.divmod(5)
p(-7.divmod(3))
2 min 5 s
[3, 2]
[-3, 2]

divmod sigue las mismas reglas que / y %: con -7 da [-3, 2].

Dividir entre cero

p 7.0 / 0      # dividir un Float entre 0 da infinito
p 7 % 0
Infinity
cero.rb:2:in 'Integer#%': divided by 0 (ZeroDivisionError)

En Ruby 4.0.9, % lanza ZeroDivisionError entre cero, tanto con enteros como con decimales (7.0 % 0.0). La división / de un Float no lo lanza: da Infinity.

Potencias con **

p 2 ** 10
p 2 ** -2       # exponente negativo: un racional
p 9 ** 0.5      # exponente decimal: raíz cuadrada
p 2 ** 3 ** 2   # se agrupa por la derecha: 2 ** (3 ** 2)
p(-2 ** 2)      # ** va antes que el menos: -(2 ** 2)
p((-2) ** 2)
p 3.pow(4, 5)   # (3 ** 4) % 5, sin calcular el número entero grande
1024
(1/4)
3.0
512
-4
4
1

Dos detalles sorprenden al principio:

  • 2 ** -2 no da 0.25, sino (1/4), un número racional (fracción exacta). Si quieres el decimal, usa 2.0 ** -2 o .to_f.
  • -2 ** 2 da -4. La potencia tiene más prioridad que el signo menos, así que Ruby calcula -(2 ** 2). Si quieres elevar el negativo, ponlo entre paréntesis.

pow con dos argumentos calcula la potencia y el módulo a la vez. Es útil cuando solo te interesa el resto de una potencia enorme: Ruby no necesita calcular el número completo.

Asignación

= guarda un valor en una variable. Los operadores combinados hacen la cuenta y guardan el resultado en un paso:

a = 1
a += 1   # a = a + 1  => 2
a -= 1   # a = a - 1  => 1
a *= 3   # a = a * 3  => 3
a /= 2   # a = a / 2  => 1

Existen también %= y **=, con la misma idea.

||=: asignar solo si vale nil o false

||= asigna solo si la variable vale nil o false. Si tiene cualquier otro valor, aunque sea "", [] o 0, no la toca. &&= hace lo contrario: asigna solo si la variable no vale nil ni false.

nombre = nil
nombre ||= "invitado"
p nombre

nombre ||= "otro"   # ya tiene valor: no cambia
p nombre

avisos = false
avisos ||= true     # ¡cuidado! false también se sustituye
p avisos

grupos = {}
(grupos[:ruby] ||= []) << "Ana"
(grupos[:ruby] ||= []) << "Luis"
p grupos

precio = 100
precio &&= precio * 0.9   # solo si ya tiene valor
p precio
"invitado"
"invitado"
true
{ruby: ["Ana", "Luis"]}
90.0

El caso de avisos es la trampa: si false es un valor válido (el usuario desactivó los avisos), ||= lo pisa. Para eso, comprueba nil? de forma explícita.

Un uso muy conocido de ||= es guardar un resultado costoso para no calcularlo dos veces (memoización):

class Informe
  def datos
    @datos ||= begin
      puts "calculando..."
      [1, 2, 3].sum
    end
  end
end

informe = Informe.new
p informe.datos
p informe.datos   # la segunda vez no recalcula
calculando...
6
6

Sirve si el resultado nunca es nil ni false; si puede serlo, se recalcula cada vez.

Asignación encadenada

Puedes dar el mismo valor a varias variables en una línea. Se lee de derecha a izquierda:

a = b = 1 + 2 + 3
puts "a= #{a}"   # a= 6
puts "b= #{b}"   # b= 6

Con paréntesis cambias el orden:

a = (b = 1 + 2) + 3
puts "a= #{a}"   # a= 6
puts "b= #{b}"   # b= 3

Funciona, pero cuesta de leer. En código real, mejor dos líneas.

Asignación paralela

Ruby asigna varias variables a la vez, separándolas con comas. Primero calcula todos los valores de la derecha y después los reparte:

a = 1
b = 2

a, b = (a + b), a

puts "a= #{a}"   # a= 3
puts "b= #{b}"   # b= 1

Por eso b recibe el 1, el valor que tenía a antes de la línea. Un uso práctico es intercambiar dos variables sin una auxiliar:

a, b = b, a

Los valores de la derecha se calculan en orden, de izquierda a derecha:

x = 0

a, b, c = x, (x += 1), (x += 1)

puts "a= #{a}"   # a= 0
puts "b= #{b}"   # b= 1
puts "c= #{c}"   # c= 2

Comparación

Devuelven true o false:

a = 2
b = 2

a == 2   # => true
a == 3   # => false
a == b   # => true

a != 2   # => false
a != 3   # => true

a < b    # => false
a <= b   # => true
a > b    # => false
a >= b   # => true
Operador Significa
== Igual
!= Distinto
< y > Menor y mayor
<= y >= Menor o igual, y mayor o igual
<=> Compara y devuelve -1, 0, 1 o nil
=== Igualdad de caso: «¿encaja en?»

El operador nave espacial: <=>

<=> (lo llaman spaceship por su forma) dice si el primero es menor (-1), igual (0) o mayor (1). Si los dos valores no se pueden comparar, devuelve nil:

p 1 <=> 2
p "b" <=> "a"
p [1, 2] <=> [1, 3]
p 1 <=> "uno"   # no se pueden comparar

edades = [30, 12, 45]
p edades.sort { |a, b| b <=> a }   # de mayor a menor
p [3, "a"].sort
-1
1
-1
nil
[45, 30, 12]
nave.rb:8:in 'Array#sort': comparison of Integer with String failed (ArgumentError)

sort usa <=> por dentro: por eso, al darle la vuelta (b <=> a), ordena al revés. Y por eso falla con una lista que mezcla números y textos: <=> devuelve nil y sort no sabe qué hacer con él.

Los arrays se comparan elemento a elemento, y eso tiene un uso práctico. Si defines <=> en tu clase e incluyes el módulo Comparable, Ruby te regala <, <=, ==, >=, > y between?. Y como sort y max usan <=>, también funcionan con tus objetos:

class Version
  include Comparable
  attr_reader :mayor, :menor

  def initialize(mayor, menor)
    @mayor = mayor
    @menor = menor
  end

  def <=>(otra)
    [mayor, menor] <=> [otra.mayor, otra.menor]
  end

  def to_s = "#{mayor}.#{menor}"
end

a = Version.new(3, 4)
b = Version.new(4, 0)
p a < b
p [b, a].max.to_s
p Version.new(3, 5).between?(a, b)
true
"4.0"
true

Comparable es un mixin: cómo funcionan include y los módulos se explica en Módulos en Ruby.

== no es lo mismo que eql?

== compara el valor; eql? también exige que sean del mismo tipo:

1 == 1.0     # => true
1.eql?(1.0)  # => false  (Integer frente a Float)

El triple igual, ===

Si vienes de JavaScript, ojo: en Ruby === no es «igual y del mismo tipo». Es la igualdad de caso, la que usa case … when por debajo. Se lee como «¿encaja en?»:

Integer === 5        # => true  (5 es un Integer)
(1..10) === 7        # => true  (7 está en el rango)
/ru/ === "ruby"      # => true  (el texto encaja con la expresión regular)
5 === 5              # => true  (con números, igual que ==)

Gracias a eso puedes escribir:

edad = 7
case edad
when 0..12 then "niño"   # Ruby comprueba (0..12) === edad
else "adulto"
end
# => "niño"

En el día a día casi nunca lo escribirás a mano; lo usarás a través de case (más en condicionales en Ruby) o de las expresiones regulares.

Lógicos

Sirven para combinar condiciones, normalmente en un condicional:

true && false   # => false  (y: las dos deben cumplirse)
true || false   # => true   (o: basta con una)
!true           # => false  (no: invierte el valor)

Ruby también tiene and, or y not, pero con menos prioridad que && y ||, incluso menos que =. La sorpresa que eso provoca se ve en la precedencia. Para condiciones, usa &&, || y !.

El operador de navegación segura: &.

Llamar a un método sobre nil lanza un NoMethodError. &. (safe navigation operator) se salta la llamada si el objeto es nil y devuelve nil:

Usuario = Struct.new(:nombre, :email)

usuario = Usuario.new("Ana", nil)
p usuario.email&.downcase   # email es nil: no llama a downcase

usuario = nil
p usuario&.nombre           # usuario es nil: devuelve nil
p usuario&.nombre&.upcase   # cada eslabón necesita su &.

usuario = Usuario.new("Ana", "[email protected]")
p usuario&.email&.downcase
nil.nombre
nil
nil
nil
"[email protected]"
navegacion.rb:12:in '<main>': undefined method 'nombre' for nil (NoMethodError)

Según la documentación, &. solo protege la llamada que tiene justo detrás: en una cadena larga hay que ponerlo en cada eslabón. Si la llamada se salta, tampoco se evalúan sus argumentos.

Úsalo cuando nil es un valor esperado (un campo opcional, una búsqueda que puede no encontrar nada). Si un valor nunca debería ser nil, &. esconde el fallo: el error aparece más tarde y más lejos de su causa.

Precedencia de operadores en Ruby

La precedencia decide qué se calcula primero cuando hay varios operadores en la misma expresión, igual que en matemáticas la multiplicación va antes que la suma:

p 2 + 3 * 4       # * antes que +
p((2 + 3) * 4)
p 10 - 4 % 3      # % va con * y /
p 2 * 3 ** 2      # ** antes que *
p 1 + 2 == 3      # la suma antes que la comparación
p !true == false  # ! antes que ==

x = false || true
y = false or true
p x
p y
14
20
9
18
true
true
true
false

La última línea es la trampa de or: tiene menos prioridad que =, así que y = false or true guarda false en y.

Esta es la tabla de la documentación oficial, de más a menos prioridad (los que están en la misma fila tienen la misma):

Prioridad Operadores
1 ! ~ + unario
2 **
3 - unario
4 * / %
5 + -
6 << >>
7 &
8 | ^
9 > >= < <=
10 <=> == === != =~ !~
11 &&
12 ||
13 .. ...
14 ? : (ternario)
15 rescue como modificador
16 = += -= ||=, etc.
17 defined?
18 not
19 or and
20 if, unless, while y until como modificadores
21 Bloques con { }

La documentación añade que los bloques do … end tienen aún menos prioridad que los de { }.

No hace falta memorizarla. Si dudas, pon paréntesis: el código se lee mejor y no depende de que quien lo lea recuerde la tabla.

Siguiente paso

Los operadores casi siempre aparecen dentro de otra cosa:

Fuentes

Consultado el 9 de noviembre de 2026:

  • Documentación oficial de Ruby 4.0: operadores, precedencia, asignación (incluida la asignación múltiple), llamadas a métodos (operador de navegación segura), Integer (%, remainder, divmod, **, pow y <=>), Float y Comparable.
  • Todos los ejemplos se han ejecutado en Docker con la imagen oficial ruby:latest (Ruby 4.0.9). Los resultados de los comentarios y de los bloques de salida son los reales; en los errores se muestra solo la primera línea del mensaje. La comparación con el % de JavaScript y Java se ha comprobado con Node 24.21.0 y con la imagen oficial eclipse-temurin:25.