programacion - ruby on rails poo

Variable de instancia de clase Ruby vs. variable de clase

Question

Leí "¿ Cuándo se configuran las variables de instancia de Ruby? ", Pero me da mucho miedo cuándo utilizar las variables de instancia de la clase.

Las variables de clase son compartidas por todos los objetos de una clase, las variables de instancia pertenecen a un objeto. No queda mucho espacio para usar variables de instancia de clase si tenemos variables de clase.

¿Podría alguien explicar la diferencia entre estos dos y cuándo usarlos?

Aquí hay un ejemplo de código:

class S
@@k = 23
@s = 15
def self.s
@s
end
def self.k
@@k
end
end
p S.s #15
p S.k #23

Ahora entiendo, las variables de instancia de clase no se pasan a lo largo de la cadena de herencia.

Answer 1

Como dijeron otros, las variables de clase se comparten entre una clase determinada y sus subclases. Las variables de instancia de clase pertenecen exactamente a una clase; sus subclases están separadas.

¿Por qué existe este comportamiento? Bueno, todo en Ruby es un objeto, incluso clases. Eso significa que cada clase tiene un objeto de la clase Class (o más bien, una subclase de Class ) que le corresponde. (Cuando dices class Foo , estás declarando realmente un Foo constante y asignándole un objeto de clase.) Y cada objeto Ruby puede tener variables de instancia, de modo que los objetos de clase también pueden tener variables de instancia.

El problema es que las variables de instancia en los objetos de la clase no se comportan realmente de la manera en que normalmente queremos que se comporten las variables de la clase. Por lo general, desea que una variable de clase definida en una superclase se comparta con sus subclases, pero no es así como funcionan las variables de instancia: la subclase tiene su propio objeto de clase y ese objeto de clase tiene sus propias variables de instancia. Entonces introdujeron variables de clase separadas con el comportamiento que es más probable que desee.

En otras palabras, las variables de instancia de clase son una especie de accidente del diseño de Ruby. Probablemente no deberías usarlos a menos que sepas específicamente que son lo que estás buscando.

Answer 2

Creo que el principal (¿solo?) Diferente es la herencia:

class T < S
end
p T.k
=> 23
S.k = 24
p T.k
=> 24
p T.s
=> nil

Las variables de clase son compartidas por todas las "instancias de clase" (es decir, subclases), mientras que las variables de instancia de clase son específicas solo de esa clase. Pero si nunca intenta extender su clase, la diferencia es puramente académica.

Answer 3

La variable de instancia de clase # está disponible solo para el método de clase y no para los métodos de instancia mientras que las variables de clase están disponibles tanto para los métodos de instancia como para los métodos de clase. Además, las variables de instancia de clase se pierden en la cadena de herencia, mientras que las variables de clase no lo son.

class Vars
@class_ins_var = "class instance variable value" #class instance variable
@@class_var = "class variable value" #class variable
def self.class_method
puts @class_ins_var
puts @@class_var
end
def instance_method
puts @class_ins_var
puts @@class_var
end
end
Vars.class_method
puts "see the difference"
obj = Vars.new
obj.instance_method
class VarsChild < Vars
end
VarsChild.class_method

Answer 4

Variable de instancia en una clase:

class Parent
@things = []
def self.things
@things
end
def things
self.class.things
end
end
class Child < Parent
@things = []
end
Parent.things << :car
Child.things << :doll
mom = Parent.new
dad = Parent.new
p Parent.things #=> [:car]
p Child.things #=> [:doll]
p mom.things #=> [:car]
p dad.things #=> [:car]

Variable de clase:

class Parent
@@things = []
def self.things
@@things
end
def things
@@things
end
end
class Child < Parent
end
Parent.things << :car
Child.things << :doll
p Parent.things #=> [:car,:doll]
p Child.things #=> [:car,:doll]
mom = Parent.new
dad = Parent.new
son1 = Child.new
son2 = Child.new
daughter = Child.new
[ mom, dad, son1, son2, daughter ].each{ |person| p person.things }
#=> [:car, :doll]
#=> [:car, :doll]
#=> [:car, :doll]
#=> [:car, :doll]
#=> [:car, :doll]

Con una variable de instancia en una clase (no en una instancia de esa clase) puede almacenar algo común para esa clase sin tener subclases que también las obtenga automáticamente (y viceversa). Con las variables de clase, tiene la comodidad de no tener que escribir self.class desde un objeto de instancia, y (cuando sea conveniente) también obtiene compartir automáticamente en toda la jerarquía de clases.

Fusionando estos juntos en un solo ejemplo que también cubre variables de instancia en instancias:

class Parent
@@family_things = [] # Shared between class and subclasses
@shared_things = [] # Specific to this class
def self.family_things
@@family_things
end
def self.shared_things
@shared_things
end
attr_accessor :my_things
def initialize
@my_things = [] # Just for me
end
def family_things
self.class.family_things
end
def shared_things
self.class.shared_things
end
end
class Child < Parent
@shared_things = []
end

Y luego en acción:

mama = Parent.new
papa = Parent.new
joey = Child.new
suzy = Child.new
Parent.family_things << :house
papa.family_things << :vacuum
mama.shared_things << :car
papa.shared_things << :blender
papa.my_things << :quadcopter
joey.my_things << :bike
suzy.my_things << :doll
joey.shared_things << :puzzle
suzy.shared_things << :blocks
p Parent.family_things #=> [:house, :vacuum]
p Child.family_things #=> [:house, :vacuum]
p papa.family_things #=> [:house, :vacuum]
p mama.family_things #=> [:house, :vacuum]
p joey.family_things #=> [:house, :vacuum]
p suzy.family_things #=> [:house, :vacuum]
p Parent.shared_things #=> [:car, :blender]
p papa.shared_things #=> [:car, :blender]
p mama.shared_things #=> [:car, :blender]
p Child.shared_things #=> [:puzzle, :blocks]
p joey.shared_things #=> [:puzzle, :blocks]
p suzy.shared_things #=> [:puzzle, :blocks]
p papa.my_things #=> [:quadcopter]
p mama.my_things #=> []
p joey.my_things #=> [:bike]
p suzy.my_things #=> [:doll]