ruby - रूबी क्लास इंस्टेंस वैरिएबल बनाम क्लास वेरिएबल




instance-variables class-variables (3)

# क्लास इंस्टेंस वैरिएबल केवल क्लास विधि के लिए उपलब्ध है, उदाहरण के तरीकों के लिए नहीं, जबकि कक्षा चर दोनों उदाहरण विधियों और वर्ग विधियों के लिए उपलब्ध हैं। इसके अलावा वर्ग आवृत्ति चर विरासत श्रृंखला में खो जाते हैं जबकि कक्षा चर नहीं होते हैं।

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

मैंने पढ़ा " रूबी इंस्टेंस चर कब सेट हो जाते हैं? " लेकिन क्लास इंस्टेंस चर का उपयोग करने के लिए मैं दो दिमाग में हूं।

कक्षा चर सभी वर्गों द्वारा साझा की जाती हैं, इंस्टेंस वैरिएबल एक ऑब्जेक्ट से संबंधित होते हैं। यदि हमारे पास कक्षा चर है तो क्लास इंस्टेंस चर का उपयोग करने के लिए बहुत अधिक जगह नहीं है।

क्या कोई इन दोनों के बीच अंतर और उन्हें कब उपयोग कर सकता है?

यहां एक कोड उदाहरण है:

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

अब मैं समझता हूं, कक्षा इंस्टेंस वैरिएबल विरासत श्रृंखला के साथ पास नहीं हुए हैं!


कक्षा पर इंस्टेंस वैरिएबल:

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] 

मेरा मानना ​​है कि मुख्य (केवल?) अलग विरासत है:

class T < S
end

p T.k
=> 23

S.k = 24
p T.k
=> 24

p T.s
=> nil

कक्षा चर सभी "वर्ग उदाहरणों" (यानी उप-वर्ग) द्वारा साझा किए जाते हैं, जबकि कक्षा आवृत्ति चर केवल उस वर्ग के लिए विशिष्ट होते हैं। लेकिन यदि आप कभी भी अपनी कक्षा का विस्तार नहीं करना चाहते हैं, तो अंतर पूरी तरह अकादमिक है।





class-instance-variables