मैं रूबी के भविष्य के संस्करणों से क्या चाहूंगा, और मैं अभी कैसे काम कर रहा हूं

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

• C ++ में विभिन्न तर्क सूचियों के साथ ओवरलोडिंग की विधि
• एक हैश प्रदर्शित करें और उससे एक और हैश प्राप्त करें, एक सरणी नहीं
• किसी वर्ग के उदाहरण को अपने स्वयं के उपवर्ग में परिवर्तित करें
• अलग छोटी बातें

C ++ में विभिन्न तर्क सूचियों के साथ ओवरलोडिंग की विधि

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

module MethodOverload module ClassMethods def overload(meth, submethods_hash) if method_defined?(meth) alias_method "#{meth}_default_behavior", meth has_default_behavior = true end define_method meth do |*args,&block| submethods_hash.each do |sub_meth,arg_typelist| if args.size == arg_typelist.size && args.to_enum.with_index.all?{|arg,index| arg.is_a? arg_typelist[index]} return self.send(sub_meth,*args,&block) end end if has_default_behavior return self.send("#{meth}_default_behavior",*args,&block) else raise ArgumentError end end end end def self.included(base) base.extend(ClassMethods) end end 

हम एक फ़ंक्शन लिखते हैं जैसे कि यह निम्नलिखित परिणाम उत्पन्न करता है:

  x = X.new xf # => "original version []" xf 3, 'a' # => "original version [3,\"a\"]" xf 3, 4 # => "pair numeric version 3 & 4" xf 3 # => "numeric version 3" xf 'mystr' # => "string version mystr" 

यदि आप विधि ओवरलोडिंग का अनुकरण करते हैं तो यह कैसा दिखता है:

  class X include MethodOverload def f(*args) 'original version ' + args.to_s end def f_string(str) 'string version ' + str.to_s end def f_numeric(num) 'numeric version ' + num.to_s end def f_pair_numeric(num1,num2) "pair numeric version #{num1} & #{num2}" end overload :f, f_string:[String], f_numeric:[Numeric], f_pair_numeric:[Numeric, Numeric] end 

इसके बजाय, ज़ाहिर है, आप बस एक फ़ंक्शन लिख सकते हैं

  class X def f(*args) if args.size == 2 && args.first.is_a? Numeric && args.last.is_a? Numeric "pair numeric version #{args[0]} #{args[1]}" elsif args.size == 1 && args.first.is_a? String 'string version ' + str.to_s elsif args.size == 1 && args.first.is_a? Numeric 'numeric version ' + num.to_s else 'original version ' + args.to_s end end end 

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

एक हैश प्रदर्शित करें और उससे एक और हैश प्राप्त करें, एक सरणी नहीं

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

 {a: 1, b:2, c:3, z:26}.inject({}){|hsh,(k,v)| hsh.merge(k=>v.even?)} # => {a: false, b: true, c:false, z: true} 

एक और विकल्प है।

 Hash[{a: 1, b:2, c:3, z:26}.map{|k,v| [k,v.even?]}] 

यह विकल्प थोड़ा सरल और अधिक घातक है क्योंकि आपको न केवल मूल्यों को प्रदर्शित करने की अनुमति देता है, बल्कि चाबियाँ भी। हालांकि, यह स्पष्ट है कि सरणियों में हाश [गिरफ्तारी] नहीं लिखने के लिए to_hash विधि का अभाव है, लेकिन arr.to_hash।
हालाँकि, यह विधि सभी सरणियों पर लागू नहीं होगी, शायद इन कारणों से Array # to_hash विधि कर्नेल में नहीं है ( चर्चा देखें)।
यह संकेत देता है कि यह Array से प्राप्त HashLikeArray क्लास बनाने के लायक है, केवल फॉर्म के [[k1, v1], [k2, v2], ...] को स्वीकार करता है, लेकिन अगले भाग में उस पर और अधिक।

इस बीच, हम इंजेक्शन पद्धति के आधार पर एक साधारण हैश_मैप लागू करेंगे:

  class Hash def hash_map(&block) inject({}) do |hsh,(k,v)| hsh.merge( k=> block.call(v)) end end end 

और अब एरे से प्राप्त एक वर्ग के कार्यान्वयन के बारे में। इसके साथ, कुछ समस्याएं हैं जिन्हें हम अब हल करने का प्रयास करेंगे।

किसी वर्ग के उदाहरण को अपने स्वयं के उपवर्ग में परिवर्तित करें

यह स्पष्ट है कि एरे से व्युत्पन्न वर्ग बनाने में कोई समस्या नहीं है, लेकिन हमें किसी तरह हैश # to_a पद्धति को प्रतिस्थापित करने की आवश्यकता है ताकि यह एरे को वापस न करे, लेकिन यह व्युत्पन्न वर्ग हैशलाइक ऐरे है। बेशक, आप इस पद्धति के अपने स्वयं के कार्यान्वयन को लिखने का प्रयास कर सकते हैं, लेकिन वास्तव में आपको केवल एक रैपर की आवश्यकता होती है जो मूल Hash # to_a के परिणाम को Array वर्ग से HashLikeArray के उपवर्ग में बदल देता है।
आइए लिखने की कोशिश करते हैं (किसी भी अन्य के साथ परेशान किए बिना)

  class HashLikeArray < Array def initialize(*args,&block) #raise unless ... -    ,        super end end class Hash def to_a_another_version HashLikeArray[*self.to_a] #   ,    Array::[] end end {a:3,b:5,c:8}.to_a.class # ==> Array {a:3,b:5,c:8}.to_a_another_version.class # ==> HashLikeArray 

दाहिने। अब कार्य अधिक जटिल है, भले ही हमारे पास ऐरे से कम विकसित वर्ग हो:

  class Animal attr_accessor :weight def self.get_flying_animal res = self.new res.singleton_class.class_eval { attr_accessor :flight_velocity} res.flight_velocity = 1 res end end class Bird < Animal attr_accessor :flight_velocity end 

अब, आपके पास पुरानी get_flying_animal विधि है, जो तब लिखा गया था जब बर्ड वर्ग मौजूद नहीं था। पशु :: get_flying_animal हमेशा पक्षियों को चिपकाए गए गुणों के साथ लौटाते हैं, लेकिन शुद्ध रूप से वे पशु वर्ग के थे। अब बर्ड बनाने के लिए पशु वर्ग को बदलने की कोशिश न करें :: get_flying_animal विधि, जो समान एल्गोरिथ्म का उपयोग करके समान पक्षी लौटाता है, लेकिन अब केवल बर्ड वर्ग। हां, get_flying_animal विधि वास्तव में उदाहरण की तुलना में बहुत बड़ी है और आप इसे डुप्लिकेट नहीं करना चाहते हैं।
विशेष रूप से यह स्थिति आपके जीवन को तबाह कर सकती है जब आप पशु वर्ग को नहीं बदल सकते हैं, या आप इसके स्रोत को भी नहीं जानते हैं, क्योंकि वे, उदाहरण के लिए, सी में लिखे गए हैं। (एक अभ्यास के रूप में, Array :: [] या Array # प्रतिस्थापित विधियों का उपयोग किए बिना HashLikeArray # to_a पद्धति के अपने संस्करण को लिखने का प्रयास करें। आप बस कहीं से कोड की नकल करने के लिए नहीं हैं, जब तक कि निश्चित रूप से आप एक पुस्तकालय लिखने के लिए नहीं जा रहे हैं)
मुझे पता चला कि यह केवल एक अयोग्य तरीके से कैसे किया जाए, सभी उदाहरण चर को एक व्युत्पन्न वर्ग की वस्तु में कॉपी किया जाए

  class Object def type_cast(new_class) new_obj = new_class.allocate instance_variables.each do |varname| new_obj.instance_variable_set(varname, self.instance_variable_get(varname)) end new_obj end end 

अब आप यह कर सकते हैं:

  def Bird.get_flying_animal Animal.get_flying_animal.type_cast(Bird) end 

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

 x=X.new x.class = Y 

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

अलग छोटी बातें

अब छोटी चीजों के लिए:

स्व वापसी विधि

इसके अलावा, मैं एक विधि की तरह शुरू करने का सुझाव दूंगा

  def identity self end 

यह उपयोगी है ताकि आप .collect के बजाय .collect (&: पहचान) जैसे ब्लॉक में लिख सकें। {| x | x}
नंबरिंग और इकट्ठा करने के मामले में, सब कुछ बस हल किया जाता है - to_a पद्धति का उपयोग करके, आप ऑब्जेक्ट की पूरी सूची प्राप्त कर सकते हैं, लेकिन यदि आप अपनी खुद की विधि लिखते हैं जो ब्लॉक लेता है, तो फ़ंक्शन उपयोगी हो सकता है।
उदाहरण के लिए, एक विधि बनाते हैं जैसे रेल विधि Nil # कोशिश ।

  class Object def try(method_name,&block) send method_name rescue yield end end 

अब हम कर सकते हैं

 x.try(:transform,&:another_transform) 

और यहां हमें अपनी पहचान विधि की आवश्यकता हो सकती है:

 x.try(:transform, &:identity) 

- यदि परिवर्तन किया जा सकता है, तो यह किया जाएगा, नहीं - मूल वस्तु वापस कर दी जाएगी।

ऑब्जेक्ट # इन (संग्रह) विधि

रेल विधि

 color.in?([:red,:green,:blue]) 

से बहुत बेहतर लग रहा है

 [:red,:green,:blue].include?(color) 

हम लिखते हैं:

  def in?(collection) raise ArgumentError unless collection.respond_to? :include? collection.include? self end 

इस पद्धति के लिए, एक संपूर्ण लाइब्रेरी (ऐसा लगता है कि ActiveSupport) बहुत आलसी है। मुझे लगता है कि यह विधि कर्नेल में अच्छी तरह से रहती थी।

पूछताछ के तरीकों का नकारात्मक रूप

क्या आप arr.not_empty लिखना चाहेंगे? अनाड़ी के बजाय! arr.empty? माणिक में कई समान पूछताछ विधियां हैं, लेकिन लगभग कोई इनकार नहीं है। प्रकार not_empty के तरीके? और not_nil? मैं मानक पुस्तकालय में बिल्ट-इन करना चाहूंगा। मैं Method_missing (स्पष्ट कारणों के लिए, यह ऑब्जेक्ट क्लास के method_missing को बदलने के लिए अनुशंसित नहीं है) का उपयोग करके अपने स्वयं के प्रश्न-तरीकों को नकारात्मक के साथ परिभाषित करना पसंद करता हूं)

  class X def method_missing(meth,*args,&block) match = meth.to_s.match(/^not_(.+\?)$/) return !send(match[1], *args,&block) if match && respond_to?(match[1]) super end end X.new.not_nil? # => true 

फ़ाइल एक्सटेंशन काटें

मुझे फ़ाइल मॉड्यूल के लिए एक अलग घृणा है, जिसमें कोई फ़ाइल नाम_wo_extname और basename_wo_extname विधियाँ नहीं हैं। हम ठीक करते हैं:

  class File def self.filename_wo_ext(filename) filename[0..-(1+self.extname(filename).length)] end def self.basename_wo_ext(filename) self.basename(filename)[0..-(1+self.extname(filename).length)] end end File.basename_wo_ext('d:/my_folder/my_file.txt') # => "my_file" File.filename_wo_ext('d:/my_folder/my_file.txt') # => "d:/my_folder/my_file" 

कुछ खुशियाँ

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