Nivel inicial4 min de lectura · Publicado el

Variables de clase en Ruby (@@)

Variables de clase en Ruby: @@number_of_cars = 2 en la pizarra, que ven todos, y @colour en el cuaderno de cada alumno: red y grey. @@ para todos, @ para unorubentejera.com @@number_of_cars= 2@colour"red"@colour"grey"
La pizarra es @@number_of_cars: la clase la tiene una sola vez y todos los coches leen el mismo 2. Cada cuaderno es una variable de instancia, @colour: un coche apunta red y el otro, grey.

Una variable de instancia (@colour) es como el cuaderno de cada alumno: cada uno tiene el suyo. Una variable de clase (@@number_of_cars) es la pizarra del aula: todos ven la misma y, si alguien la cambia, la ven cambiada todos. Si buscas cómo funcionan las variables en general (locales, de instancia y globales), empieza por variables en Ruby; aquí solo se trata la de clase.

Cómo se define una variable de clase en Ruby (class variable)

  • Su nombre empieza por dos arrobas: @@contador.
  • La comparten todos los objetos de la clase.
  • Debe inicializarse antes de usarse.

En este ejemplo, cada coche nuevo suma uno al total de coches:

class Vehicle
  def initialize(number_wheels, colour)
    @number_wheels = number_wheels
    @colour = colour
  end

  def to_s
    "Vehicle: wheels=#{@number_wheels} colour=#{@colour}"
  end
end

class Car < Vehicle
  @@number_of_cars = 0

  def self.number_of_cars
    @@number_of_cars
  end

  def initialize(number_wheels, colour, number_doors)
    super(number_wheels, colour)
    @number_doors = number_doors
    @@number_of_cars += 1
  end

  def to_s
    super + " doors=#{@number_doors} total_cars=#{@@number_of_cars}"
  end
end

red = Car.new(4, "red", 5)
puts red   # Vehicle: wheels=4 colour=red doors=5 total_cars=1

grey = Car.new(4, "grey", 5)
puts grey  # Vehicle: wheels=4 colour=grey doors=5 total_cars=2

puts red   # Vehicle: wheels=4 colour=red doors=5 total_cars=2
puts Car.number_of_cars  # 2

Fíjate en la última llamada a red: muestra total_cars=2 aunque se creó cuando solo había uno. Es la pizarra compartida: el valor es de la clase, no del objeto. Car.number_of_cars es un método de clase para leerla desde fuera.

Si no la inicializas

class SinIniciar
  def self.leer = @@nada
end

SinIniciar.leer
# NameError: uninitialized class variable @@nada in SinIniciar

La trampa: las subclases comparten la misma variable

Una variable de clase es la misma para la clase y todas sus subclases. Si una subclase la cambia, cambia también para el padre:

class Padre
  @@tipo = "padre"
  def self.tipo = @@tipo
end

class Hija < Padre
  @@tipo = "hija"
end

puts Padre.tipo   # hija
Variable de clase frente a variable de instancia de clase. Con @@tipo, Padre y Hija < Padre apuntan a la misma variable: Hija la cambia a "hija" y Padre.tipo devuelve hija. Con @total, Contador y SubContador < Contador tienen cada una la suya: 2 y 1.
Arriba, las dos clases apuntan a la misma pizarra: lo que escribe Hija lo lee Padre. Abajo, cada clase tiene su propia cuenta.

La alternativa: variables de instancia de clase

Si quieres que cada clase lleve su propia cuenta, usa una variable con una sola arroba definida en el cuerpo de la clase:

class Contador
  @total = 0

  class << self
    attr_accessor :total
  end

  def initialize = self.class.total += 1
end

class SubContador < Contador
  @total = 0
end

Contador.new
Contador.new
SubContador.new
puts Contador.total     # 2
puts SubContador.total  # 1
@@variable @variable en el cuerpo de la clase
La comparten los objetos de la clase Sí Sí, a través de la clase
La comparten las subclases Sí, la misma No, cada una tiene la suya
Se lee desde un método de instancia Directamente Con self.class.total

Para entender mejor la diferencia entre lo que pertenece a la clase y a cada objeto, repasa clases en Ruby.

Los dos errores que lanza Ruby desde la versión 3.0

Hasta Ruby 2.7, algunos usos confusos de @@ solo daban un aviso (el de overtaken, además, solo con -w). Desde Ruby 3.0 son un RuntimeError, según las notas de la versión. Conviene reconocerlos, porque el mensaje no dice qué hacer.

1. Una variable «adelantada» por un antepasado. Ocurre cuando la subclase define @@color y, después, el padre define una variable con el mismo nombre. Ahora hay dos variables y Ruby no sabe cuál quieres:

class Padre; end

class Hija < Padre
  @@color = "azul"
  def self.color = @@color
end

class Padre
  @@color = "rojo"
end

Hija.color
RuntimeError: class variable @@color of Hija is overtaken by Padre

Suele aparecer cuando una clase se reabre en otro fichero o cuando una gema añade algo a una clase tuya. La salida es la misma de antes: si cada clase necesita su valor, una variable de instancia de clase.

2. Usarla fuera de una clase. Una variable de clase solo existe dentro de una clase o un módulo:

@@contador = 1
RuntimeError: class variable access from toplevel

El mismo error sale con algo menos evidente: un bloque (do … end o { … }) ve las variables del sitio donde se escribió, no de la clase donde se ejecuta. Por eso Hija.class_eval { @@color }, escrito fuera de la clase, también falla.

Los módulos también comparten

Si un módulo define una variable de clase, la comparten todas las clases que lo incluyen. Es la pizarra, pero en un pasillo por el que pasan varias aulas:

module Contable
  @@usos = 0
  def usar = @@usos += 1
end

class Factura; include Contable; end
class Pedido;  include Contable; end

Factura.new.usar
Pedido.new.usar
puts Factura.class_variable_get(:@@usos)  # 2

Las facturas y los pedidos suman en el mismo contador. Si eso no es lo que buscas, cada clase debe llevar su propia cuenta. Los módulos que se incluyen en varias clases se explican en ejemplos de mixin en Ruby.

Inspeccionarlas desde fuera

Para depurar, Module tiene métodos que leen y cambian variables de clase sin escribir un método para cada una:

Método Qué hace Ejemplo
class_variables Lista las que tiene la clase Car.class_variables # => [:@@number_of_cars]
class_variable_get Lee una Car.class_variable_get(:@@number_of_cars)
class_variable_set Cambia una Car.class_variable_set(:@@number_of_cars, 0)
class_variable_defined? Dice si existe Car.class_variable_defined?(:@@number_of_cars)

Son útiles en la consola o en un test, para dejar un contador a cero. En el código de la aplicación son una señal de alarma: si necesitas tocar la variable desde fuera, lo normal es darle a la clase un método con nombre propio.

¿Cuándo tiene sentido usar @@?

Pocas veces. Una regla práctica para elegir:

  • El valor no cambia (un tipo de IVA, un límite): una constante, LIMITE = 10.
  • El valor cambia y es de cada clase (un contador por tipo de vehículo): una variable de instancia de clase, @total.
  • El valor cambia y debe ser el mismo para toda la jerarquía, y lo sabes y lo quieres: entonces sí, @@.

Hay un motivo más para desconfiar de cualquier valor compartido que cambia: los tests. Si un test crea dos coches y otro test comprueba que el total es 1, el resultado depende del orden en que se ejecuten. Por eso los tests de abajo ponen el contador a cero en setup.

Compruébalo con un test

La forma más fiable de saber si una clase comparte su estado con las subclases no es leer el código: es escribir lo que esperas y ejecutarlo. Este test, con Minitest (incluido en Ruby), describe lo que queremos de Contador:

require "minitest/autorun"

class Contador
  @total = 0
  class << self
    attr_accessor :total
  end
  def initialize = self.class.total += 1
end

class SubContador < Contador
  @total = 0
end

class ContadorTest < Minitest::Test
  def setup
    Contador.total = 0
    SubContador.total = 0
  end

  def test_cada_clase_lleva_su_propia_cuenta
    2.times { Contador.new }
    SubContador.new

    assert_equal 2, Contador.total
    assert_equal 1, SubContador.total
  end
end
ruby contador_test.rb
1 runs, 2 assertions, 0 failures, 0 errors, 0 skips

Con @@tipo (el ejemplo de Padre y Hija), un test equivalente falla y lo dice con claridad:

Expected: "padre"
  Actual: "hija"

Este test sirve también cuando el cambio lo hace otra persona o un asistente de IA: si alguien «simplifica» @total a @@total, el test se pone en rojo antes de que el fallo llegue a producción, si los tests se ejecutan antes de desplegar. Para empezar a escribir tests así, lee la introducción al testing en Ruby y, después, TDD: desarrollo dirigido por tests.

Ejercicio de cinco minutos

  1. Copia el ejemplo de Car y añade una clase Moto < Vehicle con su propio @@number_of_motos. ¿Se mezclan los totales? (No: cada variable está en una clase distinta.)
  2. Ahora mueve @@number_of_cars a Vehicle y haz que Moto también lo incremente. ¿Qué cuenta ahora?
  3. Cámbialo por una variable de instancia de clase y escribe un test que compruebe las dos cuentas por separado.

Fuentes

  • Documentación oficial de Ruby 3.4: variables de clase y Module (class_variables, class_variable_get, class_variable_set, class_variable_defined?).
  • Notas de la versión de Ruby 3.0: los dos RuntimeError (Bug #14541).
  • Todos los ejemplos se han ejecutado con Ruby 3.4.12 y Minitest 5.25.4 (imagen oficial ruby:3.4 de Docker) el 8 de noviembre de 2026. El ejemplo original se ha simplificado en la salida (antes usaba tabuladores) y se ha añadido Car.number_of_cars.