Variables en Ruby: tipos, referencias, dup y freeze
Si aún no conoces el lenguaje, antes puedes leer qué es Ruby y para qué se usa.
¿Qué es una variable?
Una variable es un nombre que le pones a un dato para poder usarlo después. Es como la etiqueta de un tarro en la cocina: no escribes «el tarro de cristal de la segunda balda», escribes «azúcar» y ya sabes qué hay dentro. En programación pasa lo mismo: en vez de repetir el 20 por todo el programa, lo guardas con un nombre que explica qué significa:
precio = 20
cantidad = 3
total = precio * cantidad
puts total # 60
precio = 25
puts total # 60: total se calculó antes del cambio
El signo = no significa «es igual a», como en matemáticas, sino «guarda esto con este nombre». Y fíjate en la última línea: total guardó el resultado del cálculo en su momento; cambiar precio después no lo recalcula. Una variable no es una fórmula de hoja de cálculo.
Muchos lenguajes orientados a objetos distinguen tipos de variables según desde dónde se pueden usar: locales (solo dentro de un trozo de código), de objeto, compartidas por una clase y globales (en todo el programa). Aparte están las constantes, que no son un alcance más, sino valores que no deberían cambiar. Ruby distingue todos estos tipos por el primer carácter del nombre, como verás más abajo.
Cómo crear una variable en Ruby y cambiarle el tipo
A diferencia de lenguajes como Java, en Ruby no le dices qué tipo de dato va a guardar una variable. La creas asignándole un valor:
edad = 30
p edad # 30
Y puedes asignarle después un valor de otro tipo:
edad = "treinta"
p edad # "treinta"
p edad.class # String
Puedes repetir estas pruebas en irb, la consola interactiva de Ruby: escribe irb en el terminal.
Para cambiar su valor con += o asignarla solo si vale nil o false con ||=, mira los operadores en Ruby.
Dinámico, pero fuertemente tipado
Ruby es un lenguaje dinámico: los tipos se comprueban mientras el programa se ejecuta, no antes. Por eso una variable puede guardar un número y luego un texto.
Y es de tipado fuerte: cada valor conserva su tipo y Ruby no lo convierte por su cuenta. Si mezclas un texto y un número, falla:
"Edad: " + 30
# TypeError: no implicit conversion of Integer into String
"Edad: #{30}" # "Edad: 30": la interpolación sí lo convierte
La forma cómoda de combinar texto y valores es la interpolación: la tienes en Interpolación de cadenas en Ruby.
Tipos de variables en Ruby
El primer carácter del nombre indica su alcance (desde dónde se puede usar):
| Se escribe | Tipo | Dónde se ve |
|---|---|---|
edad |
Local | Solo en el método o bloque donde se crea |
@edad |
De instancia | En todos los métodos de un mismo objeto |
@@edad |
De clase | En la clase y en todos sus objetos |
$edad |
Global | En todo el programa (evítalas: cualquiera puede cambiarlas) |
EDAD |
Constante | Empieza por mayúscula. Si la reasignas, Ruby avisa, pero lo permite |
Las variables de instancia las verás en Clases en Ruby y las de clase, en Variables de clase en Ruby.
Las variables guardan referencias a objetos
Una variable no contiene el objeto: contiene una referencia, como un acceso directo del escritorio que abre un documento. Si haces persona2 = persona1, no copias el documento; creas un segundo acceso directo al mismo. Lo que cambies a través de uno lo verás también a través del otro:
persona1 = "Tim"
persona2 = persona1
persona1[0] = "J"
puts persona1 # Jim
puts persona2 # Jim
p persona1.equal?(persona2) # true: es el mismo objeto
A esto se le llama aliasing: dos nombres para el mismo objeto.
Reasignar es distinto de modificar. Con = haces que el acceso directo abra otro documento, y la otra variable no se entera:
a = "Tim"
b = a
a = "Jim"
puts a # Jim
puts b # Tim
dup: una copia independiente
Para trabajar con una copia y no con el original, usa dup:
persona1 = "Tim"
persona2 = persona1.dup
persona1[0] = "J"
puts persona1 # Jim
puts persona2 # Tim
p persona1.equal?(persona2) # false: son dos objetos
freeze: impedir cambios
Para que nadie pueda modificar un objeto, congélalo con freeze. Afecta al objeto, así que tampoco se puede cambiar a través de otra variable que lo referencie:
persona1 = "Tim"
persona2 = persona1
persona1.freeze
persona2[0] = "J"
# FrozenError: can't modify frozen String: "Tim"
Dónde existe una variable local
Una variable local solo existe en el trozo de código donde se crea. Un método es una habitación con la puerta cerrada: no ve las variables locales de fuera.
descuento = 10
def precio_final(precio)
precio - descuento
end
puts precio_final(100)
undefined local variable or method 'descuento' for main (NameError)
Lo correcto es pasársela como parámetro: def precio_final(precio, descuento). Los bloques (each, map, times), en cambio, sí ven las variables de fuera, pero lo que crean dentro desaparece al terminar:
total = 0
[10, 20, 30].each { |precio| total += precio }
puts total # 60
[1, 2].each { |n| doble = n * 2 }
puts doble
undefined local variable or method 'doble' for main (NameError)
Más sobre bloques en Bloques en Ruby.
Errores frecuentes
1. Equivocarte al escribir una variable de instancia. Una variable local mal escrita da error enseguida, como acabas de ver. Una de instancia, no: si no existe, vale nil sin avisar, y el error aparece más tarde y en otro sitio:
class Pedido
def initialize(cliente)
@cliente = cliente
end
def resumen = "Pedido de #{@clente.upcase}"
end
puts Pedido.new("ana").resumen
undefined method 'upcase' for nil (NoMethodError)
Cuando veas for nil, sospecha de un nombre mal escrito. Usar attr_reader :cliente y llamar a cliente en vez de a @cliente lo evita: un método mal escrito sí da error en el momento.
2. Creer que dup lo copia todo. dup hace una copia superficial: copia el contenedor, pero los objetos de dentro siguen siendo los mismos. Es como fotocopiar el índice de un archivador: tienes otro índice, pero las carpetas son las de siempre.
original = ["Tim", "Ana"]
copia = original.dup
copia[0] << "my"
copia << "Luis"
p original # ["Timmy", "Ana"]
p copia # ["Timmy", "Ana", "Luis"]
Añadir a copia no toca original, pero modificar un elemento sí. Si necesitas copiar también los elementos, cópialos uno a uno:
original = ["Tim", "Ana"]
copia = original.map(&:dup)
copia[0] << "my"
p original # ["Tim", "Ana"]
p copia # ["Timmy", "Ana"]
3. Creer que freeze lo congela todo. Con freeze pasa lo mismo: congela la lista, no los textos que contiene.
COLORES = ["rojo", "verde"].freeze
COLORES.first << "izo"
p COLORES # ["rojoizo", "verde"]
COLORES << "azul"
can't modify frozen Array: ["rojoizo", "verde"] (FrozenError)
4. Reasignar una constante. Ruby no lo impide; solo avisa, y el programa sigue con el valor nuevo:
IVA = 0.21
IVA = 0.10
puts IVA
warning: already initialized constant IVA
warning: previous definition of IVA was here
0.1
Un aviso así en la salida de tus tests merece atención, no silencio.
5. Asignar la misma lista a dos variables en una línea. a = b = [] no crea dos listas vacías, sino una con dos nombres:
a = b = []
a << 1
p b # [1]
Si quieres dos, escribe a = [] y b = [].
Compruébalo con un test
El aliasing (dos nombres para el mismo objeto) causa fallos difíciles de ver: un método que recibe una lista y la modifica cambia también la del que lo llamó. Este método aplica un descuento con map!, que modifica la lista en el sitio:
require "minitest/autorun"
def con_descuento(precios)
precios.map! { |precio| precio * 0.9 }
end
class DescuentoTest < Minitest::Test
def test_no_modifica_la_lista_original
precios = [100, 200]
con_descuento(precios)
assert_equal [100, 200], precios
end
end
ruby descuento_test.rb
DescuentoTest#test_no_modifica_la_lista_original [descuento_test.rb:11]:
Expected: [100, 200]
Actual: [90.0, 180.0]
1 runs, 1 assertions, 1 failures, 0 errors, 0 skips
El test demuestra que la lista de quien llama ha cambiado. Con map, sin !, el método devuelve una lista nueva y deja la original como estaba. Con un segundo test que compruebe el resultado, los dos pasan:
require "minitest/autorun"
def con_descuento(precios)
precios.map { |precio| precio * 0.9 }
end
class DescuentoTest < Minitest::Test
def test_devuelve_los_precios_rebajados
assert_equal [90.0, 180.0], con_descuento([100, 200])
end
def test_no_modifica_la_lista_original
precios = [100, 200]
con_descuento(precios)
assert_equal [100, 200], precios
end
end
2 runs, 2 assertions, 0 failures, 0 errors, 0 skips
Para empezar con tests en Ruby, lee la introducción al testing en Ruby.
Cuándo no usar cada tipo de variable
Globales ($), casi nunca. Cualquier parte del programa puede cambiarlas, y el efecto aparece lejos:
$descuento = 10
def precio_final(precio) = precio - $descuento
def activar_rebajas = $descuento = 50
puts precio_final(100) # 90
activar_rebajas
puts precio_final(100) # 50
La misma llamada, precio_final(100), da dos resultados distintos según lo que haya pasado antes en otro método. Un parámetro o una constante dicen de dónde sale el dato; una global, no. Ruby tiene algunas globales propias, como $stdout o $PROGRAM_NAME, pero las tuyas casi siempre pueden ser otra cosa.
Los demás tipos tienen sus propios límites:
- De clase (
@@), con cuidado. Las comparten la clase y todas sus subclases, así que una subclase puede cambiar el valor de la madre. Lo tienes explicado en Variables de clase en Ruby. - Constantes mutables, congeladas. Una lista o un hash en una constante se puede modificar aunque la constante no se reasigne: ponle
.freeze, y recuerda que no congela lo de dentro. duppor si acaso, no. Copiar cada objeto «por seguridad» gasta memoria y esconde el problema real: un método que modifica lo que no es suyo. Mejor que el método no lo modifique, y que un test lo compruebe.
Ejercicio de cinco minutos
- Copia el test de
con_descuentoconmap!y comprueba que falla. Cámbialo pormapy comprueba que pasa. - Escribe
a = "Tim",b = aya << "my". Antes de ejecutarlo, apunta qué valdráb. ¿Y si cambias<<pora += "my"? - Crea una constante
DIAS = ["lunes", "martes"].freezee intenta añadir"miércoles"y modificar"lunes". ¿Cuál de los dos falla?
Para seguir, mira los operadores en Ruby, con += y ||=, y cómo guardar datos en arrays y hashes.
Fuentes
Comprobado en noviembre de 2026 en la documentación oficial de Ruby 4.0: asignación y tipos de variables (las variables locales creadas en un bloque no salen de él; una variable de instancia sin inicializar vale nil), Object#dup y #freeze (copia y congelación superficiales) y NEWS de Ruby 3.4 (aviso al modificar literales).
Las sesiones de irb del artículo original son de Rubén, de 2018. Los ejemplos del artículo original se ejecutaron el 7 de noviembre de 2026 con Ruby 4.0.9 (imagen oficial ruby:latest de Docker). Los nuevos (qué es una variable, alcance, errores frecuentes, globales y el test) 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), con la misma salida en las dos. Las salidas de error están recortadas a las líneas que importan.