Ruby类实例变量与类变量

Question

Ruby类实例变量与类变量我读过“ Ruby实例变量什么时候设置？ ”但我在使用类实例变量时有两种想法。类变量由类的所有对象共享，实例变量属于一个对象。如果我们有类变量，那么使用类实例变量的余地就不大了。有人可以解释这两者之间的区别以及何时使用它们？这是一个代码示例：class S  @@k = 23   @s = 15   def self.s    @s   end   def self.k     @@k   endendp S.s #15p S.k #23我现在明白了，Class Instance Variables不会传递给继承链！

Answer 1

类上的实例变量：

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]

类变量：

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]

使用类上的实例变量（不在该类的实例上），您可以存储该类的公共内容，而不会自动获取子类（反之亦然）。使用类变量，您可以方便地不必self.class从实例对象写入，并且（在需要时）您还可以在整个类层次结构中自动共享。

将这些合并到一个示例中，该示例还包含实例上的实例变量：

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

然后在行动：

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] 

Answer 2

我相信主要（只有？）不同的是继承：

class T < S

end

p T.k

=> 23

S.k = 24

p T.k

=> 24

p T.s

=> nil

类变量由所有“类实例”（即子类）共享，而类实例变量仅特定于该类。但如果你从不打算扩展你的课程，那么差异纯粹是学术性的。