दिलचस्प पोस्ट
एंड्रॉइड स्क्रॉल करते समय सूची दृश्य आइटम की स्थिति में परिवर्तन होता है? मैं अनुरोध पुस्तकालय से लॉग संदेशों को कैसे अक्षम करूं? वैज्ञानिक संकेतन के बिना स्ट्रिंग रूपांतरण के लिए डबल 2 डी सरणी के साथ Linq का उपयोग करना, नहीं मिला का चयन करें जावा: BigInteger का उपयोग कैसे करें? अंकों की संख्या गिनती – कौन सा पद्धति सबसे अधिक कुशल है? इससे पहले कि वह वापस लौटाए, मैं AJAX कॉल को समाप्त करने के लिए jQuery का इंतजार कैसे करूं? स्क्रिप्ट / उपकरण को सी / सी ++ स्रोत कोड सरणी में बदलने के लिए कैरेक्टर क्लास घटाव, जावा वाक्यविन्यास से रेगेक्सबुड्डी में परिवर्तित क्या मुझे SQL सर्वर में थोड़ी फ़ील्ड को अनुक्रमणिका चाहिए? Scanf और scanf_s में अंतर VB.NET में DirectCast () और CType () के बीच का अंतर PHP दिनांक प्रारूप / तिथि (1365004652303-0500) / जावा एप्लेट का उपयोग करते हुए वेब पेज पर मैक पता प्राप्त करना जावा में हाइबरनेट का उपयोग करके डेटाबेस से कंबलबॉक्स को भरना

रूबी में attr_accessor क्या है?

रूबी में attr_accessor को समझने में मुझे कठिन समय आ attr_accessor है क्या कोई मुझे ये समझा सकता है?

Solutions Collecting From Web of "रूबी में attr_accessor क्या है?"

मान लें कि आपके पास एक क्लास Person

 class Person end person = Person.new person.name # => no method error 

जाहिर है हम विधि name कभी नहीं परिभाषित चलो करते हैं।

 class Person def name @name # simply returning an instance variable @name end end person = Person.new person.name # => nil person.name = "Dennis" # => no method error 

अहे, हम नाम पढ़ सकते हैं, लेकिन इसका अर्थ यह नहीं है कि हम नाम असाइन कर सकते हैं। ये दो अलग-अलग तरीके हैं पूर्व को पाठक कहा जाता है और बाद के लेखक को लेखक कहते हैं । हमने अभी तक लेखक नहीं बनाया है तो हम ऐसा करते हैं

 class Person def name @name end def name=(str) @name = str end end person = Person.new person.name = 'Dennis' person.name # => "Dennis" 

बहुत बढ़िया। अब हम पाठक और लेखक विधियों का उपयोग करते हुए उदाहरण चर लिख सकते हैं और पढ़ सकते हैं। सिवाय, यह बहुत बार किया जाता है, हर बार इन विधियों को लिखने में समय बर्बाद क्यों किया जाता है? हम इसे आसान कर सकते हैं

 class Person attr_reader :name attr_writer :name end 

यहां तक ​​कि यह दोहराव प्राप्त कर सकते हैं जब आप चाहते हैं कि पाठक और लेखक दोनों ही एक्सेसर का उपयोग करें!

 class Person attr_accessor :name end person = Person.new person.name = "Dennis" person.name # => "Dennis" 

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

 class Person attr_accessor :name def greeting "Hello #{@name}" end end person = Person.new person.name = "Dennis" person.greeting # => "Hello Dennis" 

बस। समझने के लिए कि कैसे attr_reader , attr_writer , और attr_accessor विधियां वास्तव में आपके लिए तरीकों की उत्पत्ति करते हैं, अन्य उत्तर, पुस्तकों, रूबी दस्तावेज़ पढ़ें।

attr_accessor सिर्फ एक तरीका है (लिंक को यह कैसे काम करता है इसके साथ अधिक अंतर्दृष्टि प्रदान करनी चाहिए – उत्पन्न तरीकों के जोड़े को देखें, और ट्यूटोरियल आपको यह दिखाएगा कि इसका उपयोग कैसे करना है।)

चाल यही है कि class रूबी में परिभाषा नहीं है (यह सी ++ और जावा जैसे भाषाओं में "सिर्फ एक परिभाषा" है), लेकिन यह एक अभिव्यक्ति है जो मूल्यांकन करता है । इस मूल्यांकन के दौरान जब attr_accessor विधि लागू की जाती है जो बदले में वर्तमान वर्ग को संशोधित करता है – अंतर्निहित रिसीवर को याद रखें: self.attr_accessor , जहां self इस बिंदु पर "ओपन" वर्ग ऑब्जेक्ट है

attr_accessor और दोस्तों के लिए की जरूरत है, अच्छी तरह से है:

  1. स्मालटाक की तरह रूबी, उस ऑब्जेक्ट के लिए विधि 1 के बाहर उदाहरण चर को एक्सेस करने की अनुमति नहीं देता। यही है, उदाहरण चर xy रूप में नहीं पहुंचा जा सकता है क्योंकि जावा, या अजगर में भी सामान्य है। रूबी में हमेशा एक संदेश भेजने के लिए लिया जाता है (या "कॉल करने की विधि")। इस प्रकार attr_* विधियां रैपर बनाती हैं जो गतिशील रूप से बनाई गई विधियों के माध्यम से attr_* का attr_*

  2. बॉयलरप्लेट बेकार है

आशा है कि यह कुछ छोटे विवरणों को स्पष्ट करता है। हैप्पी कोडिंग


1 यह कड़ाई से सच नहीं है और इसके आसपास कुछ "तकनीकों" हैं , लेकिन "सार्वजनिक आवृत्ति चर" पहुंच के लिए कोई वाक्यविन्यास समर्थन नहीं है।

attr_accessor है (जैसा कि ppt ने कहा है) सिर्फ एक विधि है यह आपके लिए अधिक तरीके तैयार करता है।

तो यह कोड यहाँ है:

 class Foo attr_accessor :bar end 

इस कोड के बराबर है:

 class Foo def bar @bar end def bar=( new_value ) @bar = new_value end end 

आप खुद रूबी में इस प्रकार की विधि लिख सकते हैं:

 class Module def var( method_name ) inst_variable_name = "@#{method_name}".to_sym define_method method_name do instance_variable_get inst_variable_name end define_method "#{method_name}=" do |new_value| instance_variable_set inst_variable_name, new_value end end end class Foo var :bar end f = Foo.new p f.bar #=> nil f.bar = 42 p f.bar #=> 42 

attr_accessor बहुत सरल है:

 attr_accessor :foo 

के लिए एक शॉर्टकट है:

 def foo=(val) @foo = val end def foo @foo end 

यह ऑब्जेक्ट के लिए एक सेटर / सेटर से ज्यादा कुछ नहीं है

यह सिर्फ एक तरीका है जो उदाहरण के चर के लिए प्राप्तकर्ता और सेटर विधियों को परिभाषित करता है। एक उदाहरण कार्यान्वयन होगा:

 def self.attr_accessor(*names) names.each do |name| define_method(name) {instance_variable_get("@#{name}")} # This is the getter define_method("#{name}=") {|arg| instance_variable_set("@#{name}", arg)} # This is the setter end end 

असल में वे नकली सार्वजनिक तौर पर सुलभ डेटा विशेषताएँ, जो रूबी के पास नहीं हैं।

मुझे लगता है कि जो कुछ नया रूबीवादियों / प्रोग्रामर (मेरी तरह) को भ्रमित करता है:

"मैं सिर्फ इस उदाहरण को क्यों नहीं बता सकता क्योंकि इसमें कोई विशेष विशेषता है (जैसे, नाम) और उस गुण को एक झुकाव में मान देते हैं?"

थोड़ा अधिक सामान्यीकृत, लेकिन यह मेरे लिए क्लिक किया गया है:

दिया हुआ:

 class Person end 

हमने उस व्यक्ति के रूप में परिभाषित नहीं किया है जिसका उस नाम के लिए कोई नाम या कोई अन्य विशेषता हो सकती है

तो अगर हम:

 baby = Person.new 

… और उन्हें एक नाम देने का प्रयास करें …

 baby.name = "Ruth" 

हमें एक त्रुटि मिलती है, क्योंकि रूबीलैंड में, वस्तु का एक व्यक्ति वर्ग ऐसा कुछ नहीं है जो "नाम" के साथ जुड़ा हुआ है या सक्षम है … अभी तक!

लेकिन हम किसी भी तरह की विधियों (पिछली उत्तर देखें) कहने का एक तरीका के रूप में उपयोग कर सकते हैं, "एक व्यक्ति वर्ग ( baby ) का एक उदाहरण अब 'नाम' नाम का एक विशेषता हो सकता है , इसलिए हमारे पास केवल एक सिंटैक्टीकल तरीका नहीं है और उस नाम की स्थापना, लेकिन यह हमारे लिए ऐसा करने के लिए समझ में आता है। "

फिर से, इस सवाल को थोड़ा अलग और अधिक सामान्य कोण से मारकर, लेकिन मुझे उम्मीद है कि यह इस थ्रेड के लिए अपना रास्ता ढूंढने वाले क्लास व्यक्ति की अगली घटना में मदद करता है।

यदि आप ओओपी अवधारणा से परिचित हैं, तो आपको गेटर और सेटर विधि से परिचित होना चाहिए। attr_accessor रूबी में वही करता है

सामान्य रास्ते में गेटर और सेटर

 class Person def name @name end def name=(str) @name = str end end person = Person.new person.name = 'Eshaan' person.name # => "Eshaan" 

सेटर विधि

 def name=(val) @name = val end 

गेटर विधि

 def name @name end 

रूबी में गेटर और सेटर विधि

 class Person attr_accessor :name end person = Person.new person.name = "Eshaan" person.name # => "Eshaan" 

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

विधि प्रारंभ करें

इनिशियलाइज़ आपको किसी ऑब्जेक्ट के उदाहरण में डेटा को उदाहरण के निर्माण पर सेट करने की अनुमति देता है, जब भी आप अपने कोड में एक अलग लाइन पर सेट करते हैं, जब भी आप क्लास का नया इंस्टेंस बनाते हैं।

 class Person attr_accessor :name def initialize(name) @name = name end def greeting "Hello #{@name}" end end person = Person.new("Denis") puts person.greeting 

उपरोक्त कोड में हम डेनिस को शुरूआत में पैरामीटर के माध्यम से पास करके प्रारंभिक विधि का उपयोग करके नाम "डेनिस" सेट कर रहे हैं। यदि हम प्रारंभिक पद्धति के बिना नाम सेट करना चाहते हैं तो हम ऐसा कर सकते हैं:

 class Person attr_accessor :name # def initialize(name) # @name = name # end def greeting "Hello #{name}" end end person = Person.new person.name = "Dennis" puts person.greeting 

उपरोक्त कोड में, हम वस्तु के आरंभीकरण पर मूल्य निर्धारित करने के बजाय person.name के उपयोग से attr_accessor सेटर विधि पर कॉल करके नाम सेट करते हैं।

यह काम करने के दोनों "तरीके" हैं, लेकिन आरंभ करने से हमें समय और कोड की रेखाएं बचाई जाती हैं।

प्रारंभ करने का यह एकमात्र काम है आप एक विधि के रूप में प्रारंभ करने पर कॉल नहीं कर सकते। वास्तव में एक उदाहरण ऑब्जेक्ट के मूल्य प्राप्त करने के लिए आपको गेटर्स और सेटर्स (एट्रे_रिडर (प्राप्त करें), एट्रि_लेखक (सेट), और एट्रे_एकेसर (दोनों)) का उपयोग करने की आवश्यकता है। उन पर अधिक जानकारी के लिए नीचे देखें

गेटर्स, सेटर्स (एट्रि_रिडर, एट्रि_ लेखक, एट्रे_एसरसोर)

गेटर्स, एट्रि_रिडर: एक विशेष प्रकार के चर का मूल्य वापस करना गेटर्स का पूरा उद्देश्य है। इस पर ब्रेकडाउन के लिए नीचे नमूना कोड पर जाएं।

 class Item def initialize(item_name, quantity) @item_name = item_name @quantity = quantity end def item_name @item_name end def quantity @quantity end end example = Item.new("TV",2) puts example.item_name puts example.quantity 

ऊपर दिए गए कोड में आप आइटम "उदाहरण" के उदाहरण पर "आइटम_नाम" और "मात्रा" के तरीकों को बुला रहे हैं। "उदाहरण देता है .item_name" और "example.quantity" पैरामीटर के मान को "उदाहरण" में वापस लाया जाएगा (या "प्राप्त") और उन्हें स्क्रीन पर प्रदर्शित करेगा।

सौभाग्य से रूबी में एक अंतर्निहित पद्धति है जो हमें इस कोड को अधिक संक्षिप्त लिखने की अनुमति देता है; attr_reader विधि नीचे दिए गए कोड देखें;

 class Item attr_reader :item_name, :quantity def initialize(item_name, quantity) @item_name = item_name @quantity = quantity end end item = Item.new("TV",2) puts item.item_name puts item.quantity 

यह सिंटैक्स बिल्कुल उसी प्रकार से काम करता है, केवल यह हमें छह लाइनों कोड को बचाता है। कल्पना कीजिए अगर आपके पास आइटम वर्ग में 5 और राज्य होंगे? कोड को शीघ्रता से जल्दी मिलेगा

Setters, attr_writer: सेटर पद्धतियों के साथ सबसे पहले मुझे क्या पार किया गया है कि मेरी आँखों में यह प्रारंभिक विधि के लिए एक समान कार्य करने लगती है। नीचे मैं अपनी समझ के आधार पर अंतर की व्याख्या करता हूं;

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

लेकिन क्या होगा यदि आप मूल्यों को बाद में सेट करना चाहते हैं, उदाहरण के बाद बनाया गया था, या उन्हें शुरू करने के बाद उन्हें बदलना है? यह एक ऐसा परिदृश्य होगा जहां आप एक सेटर विधि का उपयोग करेंगे। यह भिन्नता है जब आप attr_writer विधि का उपयोग शुरू में कर रहे हैं तो आपको एक विशेष स्थिति "सेट" करने की आवश्यकता नहीं है

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

 class Item attr_reader :item_name def item_name=(str) @item_name = (str) end end 

नीचे दिए गए कोड attr_writer का उपयोग करने के लिए एक बार फिर हमारे कोड को छोटा करते हैं और हमें समय बचाते हैं।

 class Item attr_reader :item_name attr_writer :item_name end item = Item.new puts item.item_name = "TV" 

नीचे दिए गए कोड के ऊपर दिए गए प्रारंभिक उदाहरण का एक पुनरावृत्ति है जहां हम निर्माण पर item_name के ऑब्जेक्ट्स वेल्यू सेट करने के लिए प्रारंभिक उपयोग कर रहे हैं।

 class Item attr_reader :item_name def initialize(item_name) @item_name = item_name end end item = Item.new("TV") puts item.item_name 

attr_accessor: दोनों attr_reader और attr_writer के कार्यों को पूरा करता है, आपको कोड की एक और पंक्ति को सहेजता है।

ऊपर दिए गए अधिकांश उत्तर कोड का उपयोग करते हैं मुझे कोई बात नहीं है जो वे कहते हैं दोहराता है, इसलिए मैं कोड के बिना अवधारणा को समझाने की कोशिश करूंगा:

व्याख्या

बाहरी पार्टियां आंतरिक सीआईए रहस्यों तक पहुंच नहीं सकते हैं

  • चलो एक सचमुच गुप्त जगह की कल्पना करते हैं। एक एजेंसी। चलो इस एजेंसी को सीआईए कहते हैं। सीआईए के अंदर के लोगों के अलावा सीआईए में क्या हो रहा है, कोई भी नहीं जानता है। दूसरे शब्दों में, बाहरी लोग सीआईए में किसी भी जानकारी का उपयोग नहीं कर सकते। लेकिन क्योंकि यह कोई संगठन नहीं है जो पूरी तरह से गुप्त है, कुछ जानकारी बाहरी दुनिया के लिए उपलब्ध कराई जाती है – केवल सीआईए चाहता है कि हर किसी को बेशक जानना चाहिए: उदाहरण के लिए सीआईए के निदेशक, यह विभाग पर्यावरण के अनुकूल कैसे पेश करता है अन्य सभी सरकारी विभागों आदि के लिए। अन्य जानकारी: उदाहरण के लिए, जो इराक या अफगानिस्तान में गुप्त सहयोगी हैं – इन प्रकार की चीजें अगले 150 वर्षों के लिए शायद ही गुप्त रहेंगी।

  • आप केवल ऐसी जानकारी तक पहुंच सकते हैं जो सीआईए जनता को उपलब्ध कराती है (यदि आप सड़क पर जो ब्लॉग्स बंद कर रहे हैं)। या सीआईए भाषा का उपयोग करने के लिए आप केवल "मंजूरी" वाली जानकारी तक पहुंच सकते हैं

    सीआईए सीआईए के बाहर सामान्य जनता के लिए उपलब्ध कराई जाने वाली जानकारी कहलाती है: विशेषताओं

विशेषताओं को पढ़ने और लिखने का अर्थ:

  • सीआईए के मामले में, अधिकांश विशेषताओं "केवल पढ़ने" हैं इसका अर्थ है कि आप पूछ सकते हैं: "सीआईए के निदेशक कौन हैं?" और आपको सीधे उत्तर मिलेगा। लेकिन आप "केवल पढ़ने के लिए" विशेषताओं के साथ क्या नहीं कर सकते हैं सीआईए में परिवर्तन में परिवर्तन है। जैसे आप एक फोन कॉल नहीं बना सकते और अचानक फैसला कर सकते हैं कि आप किम कार्दशियन को निदेशक बनना चाहते हैं, या आप पेरिस हिल्टन को चीफ में कमांडर चाहते हैं कल्पना कीजिए कि सभी सीआईए सूचना कागज के एक टुकड़े पर नीचे नोट की गई है। यदि आपके पास "लिखना" पहुंच नहीं है तो मूल रूप से आप उस कागज पर कुछ भी नहीं जोड़ सकते हैं / घटाना / संपादित या लिख ​​सकते हैं यदि पढ़ने की एक्सेस ही आपके पास थी, तो अच्छी तरह से कठिन चीजें थीं।

  • यदि विशेषताओं ने आपको "लिखना" पहुंच प्रदान की है, तो आप ऐसा कर सकते हैं

    दूसरे शब्दों में, एक्सेसर्स आपको उन संगठनों को पूछताछ करने या परिवर्तन करने की अनुमति देते हैं, जो अन्यथा बाहरी लोगों को नहीं छोड़ते हैं।

एक कक्षा के अंदर के ऑब्जेक्ट आसानी से एक-दूसरे तक पहुंच सकते हैं

  • दूसरी ओर, यदि आप पहले से ही सीआईए के अंदर थे, तो आप आसानी से काबुल में अपने सीआईए संचालक को फोन कर सकते हैं और उससे पूछें कि क्या वह काम के बाद स्थानीय काबुल के मुखबिर के साथ बियर लेना चाहता है। लेकिन अगर आप सीआईए के बाहर हैं, तो आपको आसानी से पहुंच नहीं दी जाएगी: आप यह नहीं जान पाएंगे कि वे कौन हैं (पढ़ें ऐक्सेस), और आप अपने मिशन (लिखने का ऐक्सेस) बदल नहीं पाएंगे।

वर्गों और उनके भीतर चर, गुण और तरीकों तक पहुंचने की आपकी क्षमता के साथ सटीक एक ही चीज़।

मुझे आशा है कि वह मदद करेंगे!

केवल attr-accessor विशिष्ट गुणों के लिए getter और setter विधियों को बनाता है

बस इसे डालकर कक्षा के लिए एक सेटर और गेस्टेर को परिभाषित करेगा।

ध्यान दें कि

 attr_reader :v is equivalant to def v @v end attr_writer :v is equivalant to def v=(value) @v=value end 

इसलिए

 attr_accessor :v which means attr_reader :v; attr_writer :v 

वर्ग के लिए एक सेटर और गेस्टेटर को परिभाषित करने के लिए समकक्ष हैं।

इसे समझने का एक और तरीका यह पता लगाना है कि attr_accessor होने के attr_accessor यह त्रुटि कोड समाप्त कर रहा है।

उदाहरण:

 class BankAccount def initialize( account_owner ) @owner = account_owner @balance = 0 end def deposit( amount ) @balance = @balance + amount end def withdraw( amount ) @balance = @balance - amount end end 

निम्नलिखित विधियां उपलब्ध हैं:

 $ bankie = BankAccout.new("Iggy") $ bankie $ bankie.deposit(100) $ bankie.withdraw(5) 

निम्न विधियों में त्रुटि फेंकता है:

 $ bankie.owner #undefined method `owner'... $ bankie.balance #undefined method `balance'... 

owner और balance तकनीकी रूप से नहीं, एक विधि है , लेकिन एक विशेषता है। बैंक खाता श्रेणी में def owner और डीआरआर def balance । यदि ऐसा होता है, तो आप नीचे दो आदेशों का उपयोग कर सकते हैं। लेकिन उन दोनों विधियों में नहीं हैं हालांकि, आप एट्रिब्यूट्स एक्सेस कर सकते हैं जैसे कि आप attr_accessor माध्यम से एक विधि का उपयोग कर सकते हैं !! इसलिए शब्द attr_accessor का श्रेय दें। एक्सेसर। यह विशेषताओं को एक्सेस करता है जैसे कि आप एक विधि का उपयोग करेंगे।

attr_accessor :balance, :owner जोड़ना attr_accessor :balance, :owner आपको balance और owner "विधि" को पढ़ने और लिखने की अनुमति देता है। अब आप पिछले 2 तरीकों का उपयोग कर सकते हैं

 $ bankie.balance $ bankie.owner 

इस मॉड्यूल के लिए एक नामित विशेषता को परिभाषित करता है, जहां नाम प्रतीक है। आईडी 2 नाम, एक उदाहरण चर (@name) बनाने और इसे पढ़ने के लिए एक संबंधित एक्सेस विधि। इसके अलावा गुण सेट करने के लिए नाम = नाम की एक विधि बनाता है।

 module Mod attr_accessor(:one, :two) end Mod.instance_methods.sort #=> [:one, :one=, :two, :two=] 

एक विशेषता एक्सेसर उर्फ ​​attr_accessor को संक्षेप करने के लिए आपको दो निशुल्क तरीके प्रदान करता है।

जावा में की तरह वे getters और setters कहा जाता है।

बहुत से उत्तर ने अच्छे उदाहरण दिखाए हैं इसलिए मैं संक्षेप में हूं।

#the_attribute

तथा

# The_attribute =

पुराने रूबी डॉक्स में एक हैश टैग # एक विधि का मतलब है इसमें क्लास का नाम उपसर्ग भी शामिल हो सकता है … MyClass # my_method

गुण और एक्सेसर तरीके

विशेषताओं वर्ग घटकों है कि वस्तु के बाहर से पहुँचा जा सकता है वे कई अन्य प्रोग्रामिंग भाषाओं में गुणों के रूप में जाना जाता है। उनके मूल्यों को "डॉट नोटेशन" का उपयोग करके पहुँचा जा सकता है, जैसा कि object_name.attribute_name है अजगर और कुछ अन्य भाषाओं के विपरीत, रूबी ऑब्जेक्ट वैरिएबल को ऑब्जेक्ट के बाहर से सीधे एक्सेस करने की अनुमति नहीं देता।

 class Car def initialize @wheels = 4 # This is an instance variable end end c = Car.new c.wheels # Output: NoMethodError: undefined method `wheels' for #<Car:0x00000000d43500> 

उपर्युक्त उदाहरण में, सी कार क्लास का एक उदाहरण (वस्तु) है। हमने ऑब्जेक्ट के बाहर के व्हेल्स इंस्टेंस वैरिएबल का मान पढ़ने में असफल रहने की कोशिश की क्या हुआ कि रूबी ने सी ऑब्जेक्ट के भीतर पहियों नामक एक विधि को कॉल करने का प्रयास किया, लेकिन ऐसी कोई भी विधि परिभाषित नहीं की गई थी। संक्षेप में, object_name.attribute_name वस्तु के भीतर attribute_name नामक एक विधि को कॉल करने का प्रयास करता है। बाहर से पहियों चर के मूल्य तक पहुंचने के लिए, हमें उस नाम से एक उदाहरण पद्धति को कार्यान्वित करने की जरूरत है, जो कि उस चर के मूल्य को वापस कर देगा जब कहा जाता है। यह एक एक्सेसर विधि कहा जाता है। सामान्य प्रोग्रामिंग संदर्भ में, ऑब्जेक्ट के बाहर एक इंस्टेंस वैरिएबल तक पहुंचने का सामान्य तरीका एक्सेसर तरीके को लागू करना है, जिसे गेटर और सेटर विधि भी कहा जाता है। एक गेटर एक क्लास के बाहर परिभाषित चर के मूल्य को बाहर से पढ़ने की अनुमति देता है और एक सेटर इसे बाहर से लिखे जाने की अनुमति देता है।

निम्नलिखित उदाहरण में, हमने ऑब्जेक्ट के बाहर पहिये वाले चर तक पहुंचने के लिए कार वर्ग में गेटर और सेटर पद्धतियां जोड़ दी हैं। यह गेटर्स और सेटर्स को निर्धारित करने के "रुबी रास्ता" नहीं है; यह केवल समझने के लिए कार्य करता है कि क्या प्राप्तकर्ता और सेटर तरीके क्या करते हैं।

 class Car def wheels # getter method @wheels end def wheels=(val) # setter method @wheels = val end end f = Car.new f.wheels = 4 # The setter method was invoked f.wheels # The getter method was invoked # Output: => 4 

उपर्युक्त उदाहरण काम करता है और इसी प्रकार का कोड आमतौर पर अन्य भाषाओं में गेटर और सेटर पद्धतियां बनाने के लिए उपयोग किया जाता है। हालांकि, रूबी यह करने के लिए एक सरल तरीका प्रदान करता है: तीन अंतर्निहित विधियों को attr_reader, attr_writer और attr_acessor कहा जाता है। Attr_reader विधि एक उदाहरण चर को बाहर से पठनीय बनाता है, attr_writer इसे लिखने योग्य बनाता है, और attr_acessor यह पठनीय और लिखने योग्य बनाता है

उपरोक्त उदाहरण को फिर से लिखा जा सकता है।

 class Car attr_accessor :wheels end f = Car.new f.wheels = 4 f.wheels # Output: => 4 

उपरोक्त उदाहरण में, पहियों के गुण वस्तु के बाहर से पठनीय और लिखने योग्य होंगे। अगर attr_accessor के बजाय, हम attr_reader का इस्तेमाल करते हैं, यह केवल पढ़ने के लिए होगा। अगर हम attr_writer का इस्तेमाल करते हैं, तो यह केवल लिखने वाला होगा उन तीन तरीकों में खुद को प्राप्त करने वाले और सेटर्स नहीं होते हैं, लेकिन जब उन्हें बुलाया जाता है तो वे हमारे लिए गेटर और सैटर पद्धतियां बनाते हैं। वे तरीके हैं जो गतिशील रूप से (प्रोग्रामेटिक रूप से) अन्य विधियों को उत्पन्न करते हैं; जिसे मेटाप्रोग्रामिंग कहा जाता है

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

उदाहरण के उपयोग से उदाहरण (आवृत्ति और चर) का उपयोग (उदाहरण के लिए, पढ़ने और लिखने) संभव है उदाहरण_व्याही_गेट और उदाहरण_व्याय_सेट निर्मित-इन तरीकों हालांकि, यह शायद ही संभवतः उचित है और आमतौर पर एक बुरा विचार है, क्योंकि इनकैप्सूल को छोड़कर सभी प्रकार के कहरों को बर्बाद करना पड़ता है।

बैंक अकाउंट के उदाहरण नीचे देखें Attr_accessor में, नाम और पता परिभाषित कर रहे हैं, इसलिए ऑब्जेक्ट बनाने के दौरान ऑब्जेक्ट को पास किया जाता है। इसके अलावा वहाँ प्रयोजन दोनों को पढ़ने और लिखने के संचालन के प्रदर्शन के लिए किया जाएगा। Attr_reader के लिए, ऑब्जेक्ट को ऑब्जेक्ट को कक्षा के ऑब्जेक्ट के प्रारंभ के दौरान पास किया जाता है।


     कक्षा खाता

       attr_accessor: नाम,: पता
       attr_reader: id,: शेष राशि 

       डीईपी प्रारंभ (नाम, पता)
         self.name = नाम
         self.address = पता
         नाबालिंस = 0
         @id = Random.rand (100)
       समाप्त

       डेफ डिपाजिट (पैसा)
         नाबालिग + = पैसा 
         डालता है "# पैसे के लिए जमाराशि" 
       समाप्त

       डीईएफ़ चेक_बेलान्स
         डालता है "उपलब्ध शेष राशि # {शेष} है" 
       समाप्त
     समाप्त

     account1 = खाता.न्यू ('जॉन', 'सिंगापुर')
     account1.deposit (100)
     account1.check_balance

हममम। बहुत सारे अच्छे उत्तर यहां मेरे कुछ सेंट हैं I

  • attr_accessor एक सरल तरीका है जो हमें दोहराए जाने getter and setter विधियों को साफ करने में मदद करता है।

  • ताकि हम व्यावसायिक तर्क लिखने और सेटर्स और गेटर्स के बारे में चिंता न करें।

अन्य लोगों पर attr_accessor की मुख्य कार्यक्षमता अन्य फ़ाइलों से डेटा तक पहुंचने की क्षमता है।
तो आप आमतौर पर attr_reader या attr_writer होगा लेकिन अच्छी खबर यह है कि रुबी आपको इन दोनों को attr_accessor के साथ मिलकर गठजोड़ करने देता है मैं इसके बारे में सोचता हूं क्योंकि मैं विधि जाने हूं क्योंकि यह अधिक अच्छी तरह गोल या बहुमुखी है इसके अलावा, ध्यान में रखें कि रेल में, यह समाप्त हो गया है क्योंकि यह आपके लिए पीछे के अंत में करता है तो दूसरे शब्दों में: आप अन्य दो पर attr_acessor का उपयोग करने से बेहतर हैं क्योंकि आपको विशिष्ट होने के बारे में चिंता करने की ज़रूरत नहीं है, एक्सेसर यह सभी को कवर करता है मुझे पता है यह एक सामान्य स्पष्टीकरण के अधिक है, लेकिन यह मुझे शुरुआत के रूप में मदद करता है

आशा है कि यह मदद की!