privados - programacion con objetos ruby

Variables de clase Ruby

Question

Las cosas de la clase de Ruby me están dando dolor de cabeza. Entiendo dado esto ...

class Foo
@var = ''bar''
end

... que @var es una variable en la instancia de la clase creada.

Pero, ¿cómo creo una variable de clase invalidable de subclase?

Aquí hay un ejemplo de lo que haría en Python:

class Fish:
var = ''fish''
def v(self):
return self.var
class Trout(Fish):
var = ''trout''
class Salmon(Fish):
var = ''salmon''
print Trout().v()
print Salmon().v()

Qué salidas:

trout
salmon

¿Cómo hago lo mismo en ruby?

Answer 1

Aquí está la versión que terminé averiguando usando el enlace de hobodave:

class Fish
class << self
attr_accessor :var
end
@var = ''fish''
def v
self.class.var
end
end
class Trout < Fish
@var = ''trout''
end
class Salmon < Fish
@var = ''salmon''
end
puts (Trout.new).v # => trout
puts (Salmon.new).v # => salmon

Tenga en cuenta que la @var subclases solo requiere la adición de un @var , no es necesario anular la inicialización.

Answer 2

Es un error común que hacen los programadores de Java al llegar a Ruby, y uno de los grandes saltos conceptuales que tuve que hacer para entenderlo. Al principio parece extraño, pero en realidad es uno de los aspectos más interesantes de Ruby: todo el código es ejecutable, incluidas las definiciones de clases.

Por lo tanto, las variables de instancia deben declararse dentro de los métodos. Tiene que ver con cómo se evalúa el "yo". ''uno mismo'' es el objeto actual. El intérprete buscará las llamadas al método y las referencias de variables primero en ''self'':

class Fish
@var = "foo" # here ''self'' == Fish, the constant which contains the class object
def foo
# do foo
end
end
fish = Fish.new
fish.foo # here ''self'' == fish, an instance of Fish

En una definición de clase, ''self'' se configura como el objeto de clase que se está definiendo, por lo que cualquier referencia dentro de una definición de clase se referirá a ese objeto de clase, en este caso Fish.

Sin embargo, cuando se invoca un método en una instancia de Fish, el self se establece para ser el receptor de la llamada, la instancia particular de Fish. Entonces, fuera de una definición de método, el yo es el objeto de clase. Dentro de un método, self es la instancia del receptor. Esta es la razón por la cual @var fuera de una definición de método es más parecido a una variable estática en Java, y @var dentro de una definición de método es una variable de instancia.

Answer 3

Hay un problema: puede anular @var:
Salmon.var = ''shark'' anulará @var, por lo
puts (Salmon.new) .v # => shark

Answer 4

Para contrastar la respuesta de @ khelll, esto usa variables de instancia en los objetos de clase:

class Fish
# an instance variable of this Class object
@var = ''fish''
# the "getter"
def self.v
@var
end
# the "setter"
def self.v=(a_fish)
@var = a_fish
end
end
class Trout < Fish
self.v = ''trout''
end
class Salmon < Fish
self.v = ''salmon''
end
p Trout.v # => "trout"
p Salmon.v # => "salmon"

Editar: para dar a las instancias acceso de lectura a la variable de instancia de la clase:

class Fish
def type_of_fish
self.class.v
end
end
p Trout.new.type_of_fish # => "trout"
p Salmon.new.type_of_fish # => "salmon"

Answer 5

@var mencionado anteriormente se llama variable de instancia de clase , que es diferente de las variables de instancia ... lea la respuesta here para ver la diferencia.

De todos modos, este es el código Ruby equivalente:

class Fish
def initialize
@var = ''fish''
end
def v
@var
end
end
class Trout < Fish
def initialize
@var = ''trout''
end
end
class Salmon < Fish
def initialize
@var = ''salmon''
end
end
puts Trout.new.v
puts Salmon.new.v