रूबी ऑब्जेक्ट मॉडल को गहराई से समझना

विकिपीडिया के अनुसार, ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग (OOP) "ऑब्जेक्ट्स" की अवधारणा पर आधारित एक प्रोग्रामिंग प्रतिमान है, जिसमें डेटा और कोड शामिल हो सकते हैं:डेटा फ़ील्ड के रूप में (अक्सर विशेषताओं या गुणों के रूप में जाना जाता है) और फॉर्म में कोड प्रक्रियाओं की (अक्सर विधियों के रूप में जाना जाता है)।

रूबी एक शुद्ध वस्तु-उन्मुख भाषा है, जिसका अर्थ है कि रूबी भाषा में, सब कुछ एक वस्तु है। ये ऑब्जेक्ट, चाहे वे स्ट्रिंग्स, संख्याएं, कक्षाएं, मॉड्यूल इत्यादि हों, ऑब्जेक्ट मॉडल नामक सिस्टम में काम करते हैं। ।

रूबी object_id . नामक एक विधि प्रदान करती है , जो सभी वस्तुओं के लिए उपलब्ध है। यह पहचानकर्ता एक पूर्णांक देता है और किसी भी दो वस्तुओं के लिए समान नहीं होता है। आइए अपने हाथों को गंदा करने के लिए आईआरबी में शामिल हों; आप irb . लिखकर ऐसा कर सकते हैं आपके टर्मिनल में।

जैसा कि ऊपर देखा गया है, तार, पूर्णांक, सरणियाँ, वर्ग और यहां तक ​​कि विधियाँ सभी ऑब्जेक्ट हैं, क्योंकि उनके पास एक ऑब्जेक्ट आईडी है।

इस लेख में, हम निम्नलिखित अवधारणाओं को विस्तार से कवर करेंगे:

• कक्षाएं और उदाहरण
• विरासत
• सार्वजनिक, निजी और संरक्षित तरीके
• मिश्रण
• मॉड्यूल
• वस्तु पदानुक्रम

कक्षाएं और उदाहरण

रूबी में, वर्ग वे होते हैं जहाँ किसी वस्तु के गुण और व्यवहार (क्रियाएँ) परिभाषित होते हैं। यदि कोई वस्तु गोल (एक विशेषता) है और बोलने में सक्षम होना चाहिए (एक क्रिया), तो हम उस वर्ग से बता सकते हैं, क्योंकि इन विशेषताओं और क्रियाओं को विधियों नामक किसी चीज़ के रूप में परिभाषित किया गया है उस वर्ग में। किसी वर्ग से संबंधित वस्तु को उदाहरण . कहा जाता है उस वर्ग का और .new . का उपयोग करके बनाया (तत्काल) बनाया गया है . आइए Human . नामक एक वर्ग बनाकर प्रारंभ करें . मुझे लगता है कि हम सभी इंसान हैं, इसलिए यह मजेदार होना चाहिए।

class Human
  def initialize(name)
    @name = name
  end
end

आरंभ करें विधि एक वर्ग के एक नए उदाहरण के निर्माण के लिए आवश्यकताओं की पहचान करती है। उपरोक्त मामले में, हम देख सकते हैं कि एक नया मानव बनाने के लिए, एक नाम की आवश्यकता होती है। इसलिए, Human.new(name) . कमांड का उपयोग करके मानव का एक नया उदाहरण बनाया जा सकता है , जहां नाम आप जो भी चुनते हैं। हमारे मामले में, आइए 'हेनरी' का प्रयोग करें। हमारे irb वातावरण में इसका परीक्षण करने के लिए, हमें केवल load './path_to_filename' कमांड का उपयोग करके फ़ाइल को लोड करना है। और जब भी परिवर्तन किए जाते हैं तो फ़ाइल पुन:निष्पादन के लिए कमांड का पुन:उपयोग करें। मेरे मामले में, यह load './Human.rb' . है क्योंकि आईआरबी उक्त फाइल वाले फोल्डर में ओपन होता है। आईआरबी के बिना कोड चलाने के लिए, हमें एक puts जोड़ना होगा प्रत्येक आदेश से पहले बयान ताकि परिणाम दिखाई दे।

जब हम एक नाम के बिना एक नया मानव बनाने की कोशिश करते हैं, तो हमें एक तर्क त्रुटि मिलती है क्योंकि एक नाम की आवश्यकता होती है। हालांकि, जब हम इसे सही तरीके से करते हैं, तो हम देखते हैं कि हेनरी नाम का मानव बनाया गया है और वह Human वर्ग से संबंधित है। . इसलिए हेनरी वर्ग Human . का एक उदाहरण है ।

@name वेरिएबल को इंस्टेंस वैरिएबल कहा जाता है क्योंकि @ प्रतीक के साथ शुरू होता है, जिसका अर्थ है कि इस चर को कक्षा के भीतर किसी अन्य विधि द्वारा संदर्भित किया जा सकता है, जब तक कि प्रश्न में वर्ग उदाहरण मौजूद है। यहां, हमने इसे बनाया है और इसे उस नाम के बराबर सेट किया है जिसके साथ ऑब्जेक्ट को इनिशियलाइज़ किया गया था।

आइए इस वर्ग से संबंधित किसी भी वस्तु के लक्षणों और कार्यों को परिभाषित करने के लिए आगे बढ़ें। चूंकि बनाई गई वस्तुओं को वर्ग के उदाहरण कहा जाता है, इसलिए उनके व्यवहार को परिभाषित करने वाली विधियों को इंस्टेंस विधियां कहा जाता है। . मनुष्यों का एक नाम और शरीर के कुछ अंग होते हैं और वे कुछ क्रियाएं कर सकते हैं, तो चलिए उन्हें परिभाषित करते हैं।

def name
  @name
end

def no_of_legs
  2
end

def no_of_hands
  2
end

def speak
  'blablabla'
end

हमने ऐसे तरीके जोड़े हैं जो बनाए गए मानव के नाम को पुनः प्राप्त करते हैं, मानव के पैरों और हाथों की संख्या को परिभाषित करते हैं, और मानव को बोलने की क्षमता देते हैं। हम इन विधियों को instance.method_name . का उपयोग करके क्लास इंस्टेंस पर कॉल कर सकते हैं , जैसा कि नीचे दिखाया गया है।

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

def name=(new_name)
  @name = new_name
end

रूबी के अंतर्निर्मित attr_accessor का उपयोग करना विधि, हम अपनी नाम विधि को त्याग सकते हैं और इसे attr_accessor :name लाइन से बदल सकते हैं :

class Human
  attr_accessor :name

  def initialize(name)
    @name = name
  end
# rest of the code
end

चुने हुए तरीके के बावजूद, दिन के अंत में, यही उपलब्ध है।

अब तक बनाए गए सभी तरीकों को instance methods . कहा जाता है क्योंकि उन्हें कक्षा के किसी भी उदाहरण पर बुलाया जा सकता है लेकिन कक्षा में ही नहीं। class method . नाम की कोई चीज़ भी होती है , जिसे कक्षा पर ही बुलाया जा सकता है, न कि इसके उदाहरणों पर। क्लास मेथड्स को मेथड नाम को self. . के साथ प्रीफ़िक्स करके नाम दिया गया है . यहां एक उदाहरण दिया गया है:

# within the Human class
def self.introduction
  "I am a human, not an alien!"
end

जैसा कि हम ऊपर देख सकते हैं, क्लास मेथड केवल क्लास के लिए ही उपलब्ध है, न कि इसके इंस्टेंस के लिए। इसके अलावा, जैसे उदाहरण चर मौजूद हैं, हमारे पास वर्ग चर हैं, जो दो @ . के साथ उपसर्ग करते हैं प्रतीक एक उदाहरण नीचे दिखाया गया है।

class Human
  attr_accessor :name
  @@no_cars_bought = 0 #class variable

  def initialize(name)
    @name = name
  end

  def self.no_cars_bought
    @@no_cars_bought
  end

  def buy_car
    @@no_of_cars_bought += 1
    "#{@name} just purchased a car"
  end
end

इस उदाहरण में, हमने एक buy_car जोड़ा है हर इंसान को कार खरीदने में सक्षम बनाने की विधि। हमने @@no_of_cars_bought . नामक एक वर्ग चर भी बनाया है जो हर बार कार खरीदने पर 1 बढ़ जाती है। अंत में, हमने no_cars_bought . नामक एक वर्ग विधि बनाई जो खरीदी गई कारों की संख्या प्राप्त करता है। आइए देखें कि यह कैसे काम करता है:

अब तक परिभाषित सभी विधियों को सार्वजनिक . के रूप में जाना जाता है विधियाँ क्योंकि वे कक्षा के बाहर पहुँच योग्य हैं। हम निजी . नामक विधियों को भी परिभाषित कर सकते हैं विधियाँ, जिन्हें केवल एक वर्ग के भीतर पहुँचा जा सकता है। आइए एक उदाहरण देखें।

# at the bottom of the Human class
  def say_account_number
    "My account number is #{account_number}"
  end

  private

  def account_number
    "1234567890"
  end

यह निम्नलिखित देता है:

जब हम henry.account_number . पर कॉल करते हैं , हमें "NoMethodError" मिलता है क्योंकि account_number एक निजी विधि है जिसे केवल कक्षा के भीतर से ही पहुँचा जा सकता है। say_account_number . के द्वारा एक्सेस किए जाने पर जैसा कि हमने किया था, कोई त्रुटि नहीं है, क्योंकि यह विधि उसी वर्ग के भीतर मौजूद है जिसमें निजी विधि है। यह ध्यान रखना महत्वपूर्ण है कि private . के बाद प्रत्येक इंस्टेंस विधि कीवर्ड एक निजी विधि बन जाता है; इसलिए, सभी सार्वजनिक विधियों के बाद निजी विधियों को कक्षा में सबसे नीचे परिभाषित किया जाना चाहिए।

क्या आपने कभी संरक्षित . के बारे में सुना है तरीके? हाँ सही! ये भी मौजूद हैं, लेकिन विरासत . की अवधारणा को समझने के बाद हम इनके बारे में बात करेंगे ।

विरासत

अब जब हम कक्षाओं और उदाहरणों के बारे में जानते हैं, तो आइए विरासत . के बारे में बात करते हैं . वंशानुक्रम की अवधारणा को ठीक से समझने के लिए, आइए एक नया वर्ग बनाएं जिसे Mammal . कहा जाता है चूंकि मनुष्य स्तनधारी हैं। मुझे विज्ञान वर्ग में एक निश्चित वाक्यांश याद आता है:"सभी मनुष्य स्तनधारी हैं, लेकिन सभी स्तनधारी मनुष्य नहीं हैं"। मुझे यह भी याद है कि स्तनधारियों की कुछ विशेषताओं में बाल या फर और एक जटिल मस्तिष्क की उपस्थिति शामिल है। आइए इस जानकारी को Mammal में डालते हैं कक्षा।

class Mammal
  def has_hair?
    "Most certainly, Yes"
  end

  def has_complex_brain?
    "Well, as a mammal, what do you expect?"
  end
end

क्या आपको मेरा विज्ञान वर्ग का वाक्यांश याद है? यदि हां, तो यह महत्वपूर्ण है कि हम एक ऐसा संबंध बनाएं जो इस कथन की पुष्टि करता हो। तो हम क्या करें? हम मानव वर्ग को Mammal . के गुणों को विरासत में लेने की अनुमति देते हैं < Mammal . जोड़कर कक्षा इसकी कक्षा परिभाषा के लिए।

class Human < Mammal
  # all other code
end

एक वर्ग जो दूसरे के गुणों को विरासत में प्राप्त कर रहा है, उसे उपवर्ग . कहा जाता है , और जिस वर्ग से इसे विरासत में मिला है उसे सुपरक्लास . कहा जाता है . हमारे मामले में, Human उपवर्ग है और Mammal सुपरक्लास है। इस बिंदु पर यह ध्यान रखना महत्वपूर्ण है कि यदि आप सभी वर्गों को एक फ़ाइल में परिभाषित कर रहे हैं जैसे हम अभी कर रहे हैं, Mammal वर्ग की परिभाषा Human . से पहले आनी चाहिए आपकी फ़ाइल में वर्ग, क्योंकि हम परिभाषित होने से पहले एक चर का उल्लेख नहीं करना चाहते हैं। आइए देखें कि मानव के पास अब कौन-सी अतिरिक्त विशेषताएं हैं।

जैसा कि ऊपर दिखाया गया है, मानव के पास अब Mammal . में परिभाषित सभी विशेषताओं तक पहुंच है कक्षा। अगर हम इनहेरिटेंस हटाते हैं (यानी, हम < Mammal . हटाते हैं कोड की उस पंक्ति से) और कमांड चलाएँ henry.class.superclass , हमें हमारी प्रतिक्रिया के रूप में "ऑब्जेक्ट" मिलता है। यह हमें बताता है कि प्रत्येक वर्ग जब सीधे किसी अन्य वर्ग से विरासत में नहीं मिलता है, तो उसका सुपरक्लास "ऑब्जेक्ट" होता है, जो इस तथ्य को और मजबूत करता है कि रूबी में, यहां तक ​​​​कि कक्षाएं भी वस्तुएं हैं।

अब जब हम जानते हैं कि सुपरक्लास क्या हैं, तो यह कीवर्ड सुपर के बारे में बात करने का सही समय है। . रूबी इस कीवर्ड को सुपरक्लास पर पहले से मौजूद विधियों के पुन:उपयोग और संशोधन को सक्षम करने के लिए प्रदान करता है। हमारे Mammal . में सुपरक्लास, याद रखें कि हमारे पास has_hair? . नामक एक विधि है; क्या होगा यदि हम उस विधि को बुलाए जाने पर मनुष्यों के लिए विशिष्ट अतिरिक्त जानकारी जोड़ना चाहते हैं? यहीं पर सुपर कीवर्ड का उपयोग आता है। हमारे Human . में वर्ग, हम एक ही नाम के साथ एक विधि परिभाषित करते हैं, has_hair? ।

def has_hair?
  super + ", but humans can be bald at times"
end

जब सुपर कीवर्ड कहा जाता है, रूबी सुपरक्लास में उस विधि के नाम की तलाश करती है और उसका परिणाम देती है। उपरोक्त विधि में, हमने सुपरक्लास' has_hair? द्वारा उत्पादित परिणाम में कुछ अतिरिक्त जानकारी जोड़ी है। विधि।

रूबी केवल एकल वर्ग वंशानुक्रम का समर्थन करता है, जिसका अर्थ है कि आप केवल एक वर्ग से वर्ग गुण प्राप्त कर सकते हैं। मुझे यकीन है कि आप सोच रहे हैं कि क्या होगा यदि आप अपनी कक्षा में किसी विशेष वर्ग के लिए विशिष्ट नहीं कई गुण जोड़ना चाहते हैं। रूबी इसके लिए मिश्रण . के रूप में भी प्रावधान करती है , लेकिन इससे पहले कि हम उनके बारे में बात करें, आइए संरक्षित विधियों . के बारे में बात करते हैं ।

संरक्षित तरीके

संरक्षित विधियाँ निजी विधियों की तरह कार्य करती हैं, जिसमें वे एक वर्ग और उसके उपवर्गों में बुलाए जाने के लिए उपलब्ध हैं। आइए Mammal . के भीतर एक संरक्षित विधि बनाएं कक्षा।

  #at the bottom of the Mammal class
  def body_status
    body
  end

  protected
  def body
    "This body is protected"
  end

जैसा कि ऊपर दिखाया गया है, हम body . तक नहीं पहुंच सकते हैं विधि क्योंकि यह संरक्षित है। हालांकि, हम इसे body_status . से एक्सेस कर सकते हैं विधि, जो Mammal . के अंदर एक अन्य विधि है कक्षा। हम उस वर्ग के उपवर्गों से संरक्षित विधियों तक भी पहुँच सकते हैं जहाँ इसे परिभाषित किया गया है। आइए इसे Human . में आजमाएं कक्षा।

# within the Human class
def check_body_status
  "Just a human checking that " + body.downcase
end

जैसा कि ऊपर दिखाया गया है, इस बात की परवाह किए बिना कि Human . के भीतर बॉडी मेथड को परिभाषित किया गया है या नहीं वर्ग और संरक्षित, Human वर्ग इसे एक्सेस कर सकता है क्योंकि यह Mammal . का एक उपवर्ग है कक्षा। निजी तरीकों से भी यह उपवर्ग पहुंच संभव है; हालांकि, इससे यह सवाल पैदा होता है कि इन तरीकों में क्या अंतर है।

स्पष्ट रिसीवर का उपयोग करके संरक्षित विधियों को कॉल किया जा सकता है, जैसा कि receiver.protected_method में है , जब तक विचाराधीन प्राप्तकर्ता कीवर्ड self . है या उसी कक्षा में self . हालाँकि, निजी विधियों को केवल स्पष्ट रिसीवर का उपयोग करके ही कहा जा सकता है जब स्पष्ट रिसीवर self . हो .आइए body.downcase . को बदलकर अपना कोड संपादित करें self.body.downcase . के साथ check_body_status . में विधि और हमारी निजी विधि कॉल को बदलने के लिए self . भी शामिल है ।

def check_body_status
  "Just a human checking that " + self.body.downcase
  # body method is protected
end

def say_account_number
  "My account number is #{self.account_number}"
  # account_number method is private
end

पुनश्च:रूबी 2.7 . से पहले , self . का उपयोग करके, कुछ जानकारी प्राप्त करने के लिए किसी निजी विधि को कॉल करते समय असंभव था।

आइए आगे बढ़ते हैं और self . शब्द को प्रतिस्थापित करते हैं self . के समान वर्ग में किसी ऑब्जेक्ट के साथ . हमारे मामले में, self Henry है , विधियों को कौन बुला रहा है, और Henry Human . का एक उदाहरण है वर्ग, जो Mammal . से विरासत में मिला है कक्षा।

def check_body_status
  non_self = Human.new('NotSelf') #same class as self
  puts "Just #{non_self.name} checking that " + non_self.body.downcase
  # Mammal.new is also in the same class as self
  "Just a human checking that " + Mammal.new.body.downcase
end

def say_account_number
  non_self = Human.new('NotSelf')
  "My account number is #{non_self.account_number}"
end

जैसा कि ऊपर दिखाया गया है, self . को बदलना संभव है self . के समान वर्ग के ऑब्जेक्ट के साथ संरक्षित विधियों में , लेकिन निजी तरीकों से यह असंभव है।

मिश्रण

मिक्सिन मॉड्यूल . में परिभाषित कोड का एक सेट है , जो, जब किसी वर्ग में शामिल या विस्तारित किया जाता है, तो उस वर्ग को अतिरिक्त क्षमताएं प्रदान करता है। एक वर्ग में कई मॉड्यूल जोड़े जा सकते हैं, क्योंकि इसकी कोई सीमा नहीं है, इसके विपरीत जो वर्ग वंशानुक्रम में प्राप्य है। इस जानकारी के आलोक में, आइए एक मॉड्यूल बनाएं जिसे Movement . कहा जाता है मानव वर्ग में चलने की क्षमता जोड़ने के लिए।

module Movement
  def hop
    "I can hop"
  end

  def swim
    "Ermmmm, I most likely can if I choose"
  end
end

अगला कदम इस मॉड्यूल को हमारे Human . में शामिल करना होगा कक्षा। यह वाक्यांश जोड़कर किया जाता है include <module_name> प्रश्न में वर्ग के लिए। हमारे मामले में, इसमें include Movement . जोड़ना होगा मानव वर्ग के लिए, जैसा कि नीचे दिखाया गया है।

class Human < Mammal
  include Movement
  # rest of the code
end

आइए इस कोड का परीक्षण करें:

जैसा कि ऊपर दिखाया गया है, मॉड्यूल के माध्यम से कक्षा में मिश्रित विधियाँ केवल वर्ग के उदाहरणों के लिए उपलब्ध हैं, न कि स्वयं वर्ग के लिए। क्या होगा यदि हम मॉड्यूल में विधियों को कक्षा में उपलब्ध कराना चाहते हैं, उदाहरण के लिए नहीं? ऐसा करने के लिए, हम "शामिल करें" शब्द को "विस्तार" से बदल देते हैं, जैसा कि extend Movement में है। ।

.extend शब्द का उपयोग वर्ग के उदाहरणों पर भी किया जा सकता है लेकिन बहुत अलग तरीके से। आइए एक और मॉड्यूल बनाएं जिसे Parent . कहा जाता है ।

module Parent
  def has_kids?
    "most definitely"
  end
end

जैसा कि ऊपर दिखाया गया है, .extend(Parent) . का उपयोग करके डैड वैरिएबल पर has_kids? . बनाता है इसके लिए उपलब्ध विधि। यह विशेष रूप से तब उपयोगी होता है जब हम मॉड्यूल के तरीकों को हर वर्ग के उदाहरण में मिश्रित नहीं करना चाहते हैं। इस प्रकार, extend केवल उस विशेष उदाहरण पर उपयोग किया जा सकता है जिसमें हम रुचि रखते हैं।

मॉड्यूल

मॉड्यूल कक्षाओं, विधियों, स्थिरांक और यहां तक ​​कि अन्य मॉड्यूल के लिए आवास हैं। मिश्रण के रूप में उपयोग किए जाने के अलावा, जैसा कि पहले देखा गया, मॉड्यूल के अन्य उपयोग हैं। नामों को टकराने से रोकने के लिए वे आपके कोड को व्यवस्थित करने का एक शानदार तरीका हैं, क्योंकि वे नेमस्पेसिंग नामक एक लाभ प्रदान करते हैं। रूबी में, प्रत्येक वर्ग एक मॉड्यूल है, लेकिन कोई मॉड्यूल एक वर्ग नहीं है, क्योंकि मॉड्यूल को न तो इंस्टेंट किया जा सकता है और न ही इनहेरिट किया जा सकता है। नेमस्पेसिंग को समझने के लिए, आइए एक मॉड्यूल बनाते हैं जिसमें एक स्थिरांक, एक वर्ग, एक विधि और एक अन्य मॉड्यूल होता है।

module Male
  AGE = "Above 0"

  class Adult
    def initialize
      puts "I am an adult male"
    end
  end

  def self.hungry
    puts "There's no such thing as male food, I just eat."
  end

  module Grown
    def self.age
      puts "18 and above"
    end
  end
end

आपने देखा होगा कि ऊपर दिए गए मॉड्यूल में परिभाषित और बुलाए गए तरीके self. . से पहले लगे होते हैं . ऐसा इसलिए है क्योंकि मॉड्यूल को तत्काल नहीं किया जा सकता है, और उनके भीतर परिभाषित कोई भी विधि self. . के बिना उपसर्ग केवल एक मिश्रण के रूप में उपलब्ध होगा, जैसा कि हमने पहले देखा था जब हमने mixins . पर चर्चा की थी . मॉड्यूल पर ही किसी विधि को कॉल करने के लिए, हमें इसे self.method_name के उपयोग के माध्यम से विधि नाम पर पहचानना होगा . याद रखें कि हमने self . का भी उपयोग किया था कक्षा विधियों में कीवर्ड; वही सिद्धांत यहां लागू होता है।

जैसा कि ऊपर दिखाया गया है, मॉड्यूल के भीतर परिभाषित कक्षाओं, मॉड्यूल या स्थिरांक तक पहुंचने के लिए, हम module_name::target_name का उपयोग करते हैं . नेमस्पेसिंग अवधारणा को ठीक से समझने के लिए, हम Adult . नामक एक वर्ग के साथ एक और मॉड्यूल बनाएंगे , और फिर हम देखेंगे कि कैसे दोनों वर्गों में अंतर है।

module Female
  class Adult
    def initialize
      puts "I am an adult female"
    end
  end
    def self.hungry
      puts "Maybe there's such a thing as female food, I'm not sure. I just need to eat"
    end
end

जैसा कि ऊपर दिखाया गया है, हमारे पास "वयस्क" नाम के दो वर्ग हैं। उन्हें अपने स्वयं के मॉड्यूल में लपेटकर, हम इन नामों का उपयोग बिना किसी भ्रम के कर सकते हैं कि सटीक वयस्क वर्ग को हर बार बुलाया जा रहा है। इसके अलावा, हमारा कोड अधिक पठनीय और अधिक व्यवस्थित है, और हम अलग-अलग कोड ब्लॉक को उनके कार्यों के आधार पर कई श्रेणियों में अलग करते हुए, चिंता डिजाइन सिद्धांत को अलग करते हैं।

ऑब्जेक्ट पदानुक्रम

कक्षाओं, उदाहरणों, मॉड्यूल और विरासत की अवधारणा को समझना आश्चर्यजनक है, लेकिन रूबी में वस्तु पदानुक्रम को समझे बिना इस क्षेत्र में ज्ञान अधूरा है। यह उस क्रम को संदर्भित करता है जिसमें रूबी में एक विधि की खोज की जाती है। इस पदानुक्रम को समझने में हमारी सहायता के लिए कुछ विधियां मौजूद हैं; उनमें से एक है ancestors तरीका। यह विधि वर्ग के उदाहरणों के लिए उपलब्ध नहीं है, लेकिन इसे स्वयं और उनके पूर्वजों की कक्षाओं में बुलाया जा सकता है। एक उदाहरण नीचे दिखाया गया है।

Human.ancestors . के परिणाम से , हम देखते हैं कि यह विधि प्रश्न में वर्ग को लौटाती है, इसके सीधे शामिल मॉड्यूल, इसके मूल वर्ग, और माता-पिता की कक्षा 'सीधे शामिल मॉड्यूल; यह लूप तब तक जारी रहता है जब तक कि यह Basic Object तक नहीं पहुंच जाता , जो सभी वस्तुओं का मूल है।

किसी वर्ग के बारे में अधिक जानकारी प्राप्त करने के लिए एक अन्य उपलब्ध विधि है included_modules ।

जैसा कि ऊपर दिखाया गया है, मानव वर्ग में दो मॉड्यूल शामिल हैं:एक जिसे हमने सीधे include Movement का उपयोग करके शामिल किया है और वह जो ऑब्जेक्ट क्लास में शामिल है। इसका मतलब यह है कि प्रत्येक वर्ग को अपने पूर्वज वर्गों से वर्ग गुण विरासत में मिलते हैं, और उनमें शामिल प्रत्येक मॉड्यूल इसमें शामिल हो जाता है। इस जानकारी के आधार पर, हम रूबी में विधि लुकअप पथ की पुष्टि करने के लिए एक सरल अभ्यास करेंगे और किन वर्गों की प्राथमिकताएँ हैं इस रास्ते में दूसरों पर। हम एक ही नाम लेकिन अलग आउटपुट स्ट्रिंग के साथ विधियों को परिभाषित करेंगे और उन्हें Human . में रखेंगे वर्ग, Movement मॉड्यूल, और Mammal कक्षा।

# in the mammal class
def find_path
  "Found me in the Mammal class path"
end

# in the Movement module
def find_path
  "Found me in the Movement module path"
end
# in the Human class
def find_path
  "Found me in the Human class path"
end

अब इस अभ्यास को करते हैं।

जैसा कि ऊपर दिखाया गया है, जब हम .ancestors . को कॉल करते हैं तो पूर्वजों का क्रम निर्धारित किया जाता है उस वर्ग के उदाहरण पर बुलाए गए विधि की तलाश करते समय कक्षा पर पथ का पालन किया जाता है। Human . के लिए हमारे द्वारा बनाया गया वर्ग उदाहरण, रूबी पहले कक्षा में ही विधि की खोज करता है; यदि नहीं मिला, तो यह किसी भी सीधे शामिल मॉड्यूल के लिए आगे बढ़ता है; यदि नहीं मिला, तो यह सुपरक्लास में चला जाता है और यह चक्र तब तक जारी रहता है जब तक कि यह BasicObject तक नहीं पहुंच जाता . यदि विधि अभी भी वहां नहीं मिली है, तो "NoMethodError" वापस कर दिया जाता है। .ancestors . का उपयोग करके विधि, हम किसी ऑब्जेक्ट के लिए लुकअप पथ की पहचान कर सकते हैं और जहां इसकी विधियां किसी भी समय से निकलती हैं।

रूबी methods . नामक एक विधि भी प्रदान करती है जिससे हम किसी भी वस्तु के लिए उपलब्ध सभी विधियों की पहचान कर सकते हैं। हम यह दिखाने के लिए घटाव भी कर सकते हैं कि कौन सा इसके मूल से आता है और जो इसके लिए विशिष्ट है। एक उदाहरण नीचे दिखाया गया है।

जैसा कि ऊपर दिखाया गया है, चर हेनरी इसके लिए बहुत सारे तरीके उपलब्ध हैं। हालांकि, जब हम उन्हें ऑब्जेक्ट . में उपलब्ध लोगों से घटाते हैं वर्ग, हम पाते हैं कि हमारे पास केवल वही बचे हैं जिन्हें हमने अपनी फ़ाइल में विशेष रूप से परिभाषित किया है, और हर दूसरी विधि विरासत में मिली है। यह प्रत्येक वस्तु, उसके वर्ग और उसके पूर्वजों में से किसी के लिए समान है। Human.methods . से जुड़े कई संयोजनों को आज़माकर अपने हाथों को गंदा करने के लिए स्वतंत्र महसूस करें , स्तनपायी तरीके , Module.methods , और हर दूसरे वर्ग या मॉड्यूल को पहले परिभाषित किया गया है; आप पाएंगे कि यह आपको रूबी ऑब्जेक्ट मॉडल की एक मजबूत समझ देता है।