यह काफी समय हो गया है क्योंकि मैं रूबी कोड में भाग गया था, मुझे समझ में नहीं आया, लेकिन रेल के कुछ हिस्सों में वास्तव में रूबी की समझ को धक्का दिया गया है।
कहा जा रहा है, भले ही आप भाषा के साथ एक मध्यवर्ती स्तर पर हों, यह पता लगाने के लिए कि रेल कैसे काम करते हैं, शायद आपके गेम को बढ़ाने का एक शानदार तरीका होगा।
कहां से शुरू करना है, मैं प्लगइन लिखकर शुरू करूंगा। एक अच्छी प्लगइन के बारे में सोचें जो आप लिख सकते हैं जो अभी तक नहीं किया गया है, या ऐसा कुछ जो आपको लगता है कि आप बेहतर कर सकते हैं। जो कुछ भी आप करना चाहते हैं, संभावना है कि आपको ऐसा करने के लिए कुछ प्रकार के रेल इंटर्नल में हुक करने की आवश्यकता होगी, जो आपको शुरू करने के लिए एक अच्छी जगह देगा। एक बार जब आप ढांचे के किसी दिए गए क्षेत्र का थोड़ा सा ज्ञान प्राप्त कर लें, तो देखें कि उस क्षेत्र में कोई खुली बग है जिसे आप ठीक कर सकते हैं।
अवरोध काफी अधिक है, क्योंकि रेल लोग उन लोगों द्वारा लिखे गए एक बड़े और जटिल कार्यक्रम हैं जिनके पास अविश्वसनीय रूप से लचीली भाषा के साथ उच्च स्तर की निपुणता है। यह भी एक बड़ी चुनौती है जो आपको अंत में एक बेहतर प्रोग्रामर बना देगी। :)
संपादित करें: मदद करने के लिए रेलिंग
यह वास्तव में बहुत दिलचस्प है, तो यह एक टुकड़ा वर्णन करने के लिए कैसे वर्ग चर और सिंगलटन कक्षाएं काम के लिए बनाया गया है, लेकिन वहाँ बहुत स्पष्ट तरीके अगर यह इसी कार्य को पूरा करने के लिए कर रहे हैं "वास्तविक" कोड है।
सिंगलटन कक्षा
माणिक में, हर वस्तु एक माता पिता के वर्ग है कि यह से अपने तरीकों हो जाता है। ओओ भाषाओं के लिए यह बहुत सामान्य है। गहरे लाल रंग का क्या सामान्य नहीं है यह भी एक अवधारणा "वस्तु individuation कहा जाता है, इसका मतलब है कि वस्तुओं के तरीकों कि केवल एक विशिष्ट उदाहरण पर हैं हो सकता है, लेकिन माता-पिता वर्ग पर नहीं है। यहाँ एक त्वरित आईआरबी उदाहरण
irb(main):001:0> foo = "bar"
=> "bar"
irb(main):002:0> def foo.foo_method
irb(main):003:1> "this is _only_ on the foo instance, not on all strings"
irb(main):004:1> end
=> nil
irb(main):005:0> foo.foo_method
=> "this is _only_ on the foo instance, not on all strings"
irb(main):006:0> "bar".foo_method
NoMethodError: undefined method `foo_method' for "bar":String
from (irb):6
irb(main):007:0> foo = "New string"
=> "New string"
irb(main):008:0> foo.foo_method
NoMethodError: undefined method `foo_method' for "New string":String
from (irb):8
है
सबसे पहले, हम एक चर के लिए एक स्ट्रिंग निर्दिष्ट करते हैं। इसके बाद, हम कि उदाहरण पर एक विधि को परिभाषित। कॉलिंग विधि काम करता है, लेकिन एक नए स्ट्रिंग पर बुला काम नहीं करता। हमारे foo चर के लिए एक नया स्ट्रिंग उदाहरण नियत भी नहीं है वह foo विधि।
ऑब्जेक्ट विभाजन को संभव बनाने के लिए, उदाहरण और अभिभावक वर्ग के बीच कुछ होना आवश्यक है। यह बात सिंगलटन कक्षा है, और प्रत्येक उदाहरण में अन्य सभी obje से अद्वितीय है सीटी उदाहरण जब रूबी एक विधि की तलाश में है, तो यह अभिभावक वर्ग से पहले सिंगलटन कक्षा को देखेगा।
मानो या न मानो, भले ही आप इस बात का पहले कभी नहीं सुना है, तो आप शायद पहले से ही इस्तेमाल किया है। आप कुछ करने के लिए एक "वर्ग विधि" जोड़ना चाहते हैं, तो आप आम तौर पर इस
class Foo
def self.bar
"i am on the class"
end
end
Foo.bar #=> "I am on the class"
ऊपर से शुरू करने के लिए बयान class Foo इस Foo = Class.new do की सटीक बराबर है। क्या हो रहा है कि आप निरंतर फू को टाइप क्लास का एक नया उदाहरण असाइन कर रहे हैं। (एक तरफ, मुझे रूबी के बारे में बहुत पसंद है। अधिकांश वाक्यविन्यास वास्तव में कुछ मूल अवधारणा के आसपास सिर्फ चीनी है)
कक्षा परिभाषा के अंदर, स्वयं कक्षा को संदर्भित करता है, इसलिए कह रहा है कि def self.bar अनिवार्य रूप से कह रहा है "परिभाषित करें कक्षा उदाहरण है कि लगातार फू "में संग्रहीत होता है सिंगलटन वर्ग पर विधि बार।
यदि आपको यह सामान जटिल लगता है, तो ऐसा इसलिए है क्योंकि यह है। मुझे नहीं लगता कि कुछ भी तो अन्य माणिक में अधिक complected क्या विधि लुकअप दौरान होता है, और सिंगलटन कक्षाएं क्या यह इतना जटिल बना देता है का एक बड़ा हिस्सा हैं।
कक्षा चर
एक वर्ग चर @@ लगाया जाता है, और मूल रूप से एक चर जिसका गुंजाइश सभी उदाहरणों, वर्ग वस्तु, और सभी वर्गों के उस वर्ग से विरासत है।मैं कार्रवाई में इस वर्णन करने के लिए
irb(main):003:0* class Foo
irb(main):004:1> @@instance_count = 0
irb(main):005:1>
irb(main):006:1* def initialize
irb(main):007:2> @@instance_count += 1
irb(main):008:2> end
irb(main):009:1>
irb(main):010:1* def count
irb(main):011:2> @@instance_count
irb(main):012:2> end
irb(main):013:1> end
=> nil
irb(main):014:0>
irb(main):015:0* class Bar < Foo
irb(main):016:1> end
=> nil
irb(main):017:0>
irb(main):018:0* f = Foo.new
=> #<Foo:0x7fa9089c7da0>
irb(main):019:0> f.count
=> 1
irb(main):020:0>
irb(main):021:0* b = Bar.new
=> #<Bar:0x7fa9089be0e8>
irb(main):022:0> b.count
=> 2
irb(main):023:0>
irb(main):024:0* f.count
=> 2
पहले एक त्वरित आईआरबी करूँगा, हम फू परिभाषित करते हैं। फू में एक क्लास वेरिएबल है जो ट्रैक करता है कि कितने उदाहरण बनाए गए थे। ऐसा करने के लिए, हम उस चर को कन्स्ट्रक्टर में बढ़ाते हैं, और आखिरकार केवल एक त्वरित गेटर को परिभाषित करते हैं। बार बस फू फैलाता है।
अब, इसे क्रिया में देखने के लिए, हम एक नया फू बनाते हैं, और गिनती की जांच करें, जो 1 है। अगला, हम एक नई बार बनाते हैं, और गिनती की जांच करते हैं, हम अब 2 पर हैं। बस सुनिश्चित करने के लिए कि फू और बार दोनों एक ही गिनती साझा करते हैं, हम फिर से हमारे foo इंस्टेंस की जांच करते हैं, और यह अब 2 है।
कक्षा चर एक बहुत ही परिस्थिति विशेषता है जिसे आप आम तौर पर फ्रेमवर्क कोड के बाहर नहीं देखते हैं। आमतौर पर इसका उपयोग तब किया जाता है जब आप किसी दिए गए वर्ग के सभी उदाहरणों का ट्रैक रखना चाहते हैं।
रेलिंग कोड
class << Object.new
@@var = 6
end
String.class_variable_get(:@@var) #=> 6
आपका कोड कार्रवाई में उन दो अवधारणाओं दिखा रहा है। सबसे पहले, हम एक नई वस्तु के सिंगलटन वर्ग को खोलते हैं, और उस पर एक क्लास वैरिएबल डालते हैं। यदि यह किसी अन्य वर्ग के बाद एक वर्ग परिवर्तनीय था, तो वे पहली तीन पंक्तियां दुनिया में सबसे बेकार रूबी कोड होगी। लेकिन चूंकि यह एक वर्ग परिवर्तनीय है, जो कक्षा के लिए दिखाई देता है, कक्षा के सभी उदाहरण, कक्षा से प्राप्त होने वाले सभी वर्ग, और कक्षा से प्राप्त होने वाले सभी वर्गों के सभी उदाहरण। चूंकि जिस वर्ग के बारे में हम बात कर रहे हैं वह वस्तु है, इसका मतलब है सबकुछ। तो स्ट्रिंग पर class_variable_get कर आपको यह देता है, लेकिन आप उस चर या किसी भी वर्ग या आवृत्ति से उस चर को एक्सेस कर सकते हैं।
मैं माफी चाहता
यह बुरी तरह सामान है कि बहुत स्पष्ट रूप से व्याख्या करने के लिए कठिन है complected रहा है। इन अवधारणाओं ने मुझे अपने सिर को लपेटने के लिए काफी हद तक प्रयास किए एक सप्ताह या उससे अधिक समय तक लिया। यदि आपके द्वारा लिखे गए प्रश्नों के बारे में आपके कोई प्रश्न हैं, तो बेझिझक पूछें, लेकिन अगर आप इसे "प्राप्त नहीं करते" तो निराश न हों।
इन अन्य लोगों को मत सुनो, रूबी को जानने के बिना अभी आप बहुत कुछ कर सकते हैं। प्रलेखन और परीक्षणों के साथ शुरू करें, –
समझने के तरीके के रूप में अपना रास्ता बनाएं, मैं डब्ल्यू/@ चक वोस से सहमत हूं "दस्तावेज और परीक्षण के साथ शुरू करें, समझने के तरीके के रूप में अपना रास्ता बनाएं"। इसके अलावा - उस ढांचे का एक हिस्सा चुनें जो आपकी रूचि रखता है और एक प्लगइन या दो लिखता है जो इसकी क्षमता को बढ़ाता है। यह वास्तव में उस क्षेत्र के आंतरिक को समझने में मदद करनी चाहिए। एक बार जब आप समझ लेंगे, उस क्षेत्र के लिए @ टिकट देखें और देखें कि आप क्या कर सकते हैं। शुभकामनाएँ! – Brian