Debido a que las constantes en Ruby no están destinadas a ser cambiadas, Ruby lo desalienta de asignarles partes de código que podrían ejecutarse más de una vez, como los métodos internos.
En circunstancias normales, debe definir la constante dentro de la propia clase:
class MyClass
MY_CONSTANT = "foo"
end
MyClass::MY_CONSTANT #=> "foo"
Si por alguna razón realmente necesita definir una constante dentro de un método (quizás para algún tipo de metaprogramación), puede usar const_set:
class MyClass
def my_method
self.class.const_set(:MY_CONSTANT, "foo")
end
end
MyClass::MY_CONSTANT
#=> NameError: uninitialized constant MyClass::MY_CONSTANT
MyClass.new.my_method
MyClass::MY_CONSTANT #=> "foo"
Sin embargo, una vez más, const_setno es algo a lo que realmente deba recurrir en circunstancias normales. Si no está seguro de si realmente desea asignar a las constantes de esta manera, puede considerar una de las siguientes alternativas:
Variables de clase
Las variables de clase se comportan como constantes de muchas maneras. Son propiedades en una clase, y son accesibles en subclases de la clase en la que se definen.
La diferencia es que las variables de clase deben modificarse y, por lo tanto, pueden asignarse a métodos internos sin problemas.
class MyClass
def self.my_class_variable
@@my_class_variable
end
def my_method
@@my_class_variable = "foo"
end
end
class SubClass < MyClass
end
MyClass.my_class_variable
#=> NameError: uninitialized class variable @@my_class_variable in MyClass
SubClass.my_class_variable
#=> NameError: uninitialized class variable @@my_class_variable in MyClass
MyClass.new.my_method
MyClass.my_class_variable #=> "foo"
SubClass.my_class_variable #=> "foo"
Atributos de clase
Los atributos de clase son una especie de "variable de instancia en una clase". Se comportan un poco como las variables de clase, excepto que sus valores no se comparten con las subclases.
class MyClass
class << self
attr_accessor :my_class_attribute
end
def my_method
self.class.my_class_attribute = "blah"
end
end
class SubClass < MyClass
end
MyClass.my_class_attribute #=> nil
SubClass.my_class_attribute #=> nil
MyClass.new.my_method
MyClass.my_class_attribute #=> "blah"
SubClass.my_class_attribute #=> nil
SubClass.new.my_method
SubClass.my_class_attribute #=> "blah"
Variables de instancia
Y solo para completar, probablemente debería mencionar: si necesita asignar un valor que solo se puede determinar después de que se haya instanciado su clase, hay una buena probabilidad de que realmente esté buscando una variable de instancia antigua simple.
class MyClass
attr_accessor :instance_variable
def my_method
@instance_variable = "blah"
end
end
my_object = MyClass.new
my_object.instance_variable #=> nil
my_object.my_method
my_object.instance_variable #=> "blah"
MyClass.new.instance_variable #=> nil