Nivel inicial8 min de lectura · Publicado el

Variables en Ruby: tipos, referencias, dup y freeze

Variables en Ruby: persona1 y persona2, dos accesos directos al mismo documento; al cambiar persona1[0], persona2 también muestra Jim. Dos nombres, un objetorubentejera.com persona1persona2"Jim"persona2 = persona1persona1[0] = "J"persona2 → Jim
Una variable es como un acceso directo: persona2 = persona1 crea otro acceso al mismo documento, sin copiarlo. Si lo cambias desde uno, lo ves desde el otro. Para una copia, usa dup.

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.
  • dup por 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

  1. Copia el test de con_descuento con map! y comprueba que falla. Cámbialo por map y comprueba que pasa.
  2. Escribe a = "Tim", b = a y a << "my". Antes de ejecutarlo, apunta qué valdrá b. ¿Y si cambias << por a += "my"?
  3. Crea una constante DIAS = ["lunes", "martes"].freeze e 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.