Operadores en Ruby: módulo %, <=>, &., ||= y más
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 ** -2no da0.25, sino(1/4), un número racional (fracción exacta). Si quieres el decimal, usa2.0 ** -2o.to_f.-2 ** 2da-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:
- en las condiciones de los condicionales en Ruby;
- en los bucles e iteradores, donde
%sirve para hacer algo cada N vueltas; - con las variables en Ruby, si estás empezando y quieres repasar cómo se guardan los valores.
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,**,powy<=>), 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 oficialeclipse-temurin:25.