रूबी में समानता

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

string = "some string" same_string = string copy_string = "some string" int = 7 same_int = int copy_float = 7.0 new_int = 7 class TestClass def initialize(content) @content = content end end class SubTestClass < TestClass def initialize(content) super(content) end end test_obj = TestClass.new("something") same_obj = test_obj new_obj = TestClass.new("something") sub_obj = SubTestClass.new("something") 

1. समान? () विधि

शायद सबसे आसान तरीका। इसे ऑब्जेक्ट क्लास में परिभाषित किया गया है और चाइल्ड क्लास में दोबारा नहीं लिखा जा सकता है (जैसा कि यह निकला, यह हो सकता है, लेकिन इसकी बिल्कुल भी सिफारिश नहीं की गई है !)। वह जो कुछ भी करता है वह यह देखने के लिए जाँचता है कि क्या चर एक ही वस्तु की ओर इशारा करते हैं।
हम जाँच करते हैं:

 puts string.equal?(same_string) #true,  ,     puts string.equal?(copy_string) #false,    puts int.equal?(same_int) #true,   puts int.equal?(copy_float) #false 7  7.0 -   puts int.equal?(new_int) #true,    Fixnum    ,   # object_id   . ,   ,    new_int,  int puts test_obj.equal?(same_obj) #true,   puts test_obj.equal?(new_obj) #false, ,   puts test_obj.equal?(sub_obj) #false,   ,    

खैर, यहां सब कुछ बहुत स्पष्ट है, हम अगली विधि पर जा रहे हैं।

2. eql? () विधि

ऑब्जेक्ट क्लास में भी परिभाषित किया गया है। यह उसी तरह से काम करता है जैसे कि बराबर? हैश क्लास द्वारा उपयोग किया जाता है।

 puts string.eql?(same_string) #true, ,       puts string.eql?(copy_string) #true, -  puts int.eql?(same_int) #true,   equal? ,  eql?   puts int.eql?(copy_float) #false, ,   puts int.eql?(new_int) #true,  ,  ,   puts test_obj.eql?(same_obj) #true, ,   puts test_obj.eql?(new_obj) #false, !,  eql?     Object,  #  equal? puts test_obj.eql?(sub_obj) #false, ,  ,   

3. ==
वर्ग स्तर पर, ऑब्जेक्ट समान कार्य करता है? वर्ग (संख्यात्मक के लिए), eql के साथ अंतर क्या है?

 puts string == (same_string) #true,   puts string == (copy_string) #true,   puts int == (same_int) #true,     puts int == (copy_float) #true, - ,    puts int == (new_int) #true,   #!     ==  ,     #Object,      equal? puts test_obj == (same_obj) #true puts test_obj == (new_obj) #false puts test_obj == (sub_obj) #false 

4. ===
=== के लिए परिणाम == (एक "लेकिन" तार और नियमित अभिव्यक्ति के लिए) के समान हैं। ट्रिपल बराबर का सबसे आम उपयोग मामले के घटक में होता है जब आप तुलना करते हैं, जैसा कि आप अनुमान लगा सकते हैं, तार और नियमित अभिव्यक्ति।
एकमात्र उदाहरण मैं यहाँ दूंगा:

 puts /p.*cock/ == 'peacock' #false,   ==    , puts /p.*cock/ === 'peacock' #true,    === 

बस यही छोटा सा अंतर है।

निष्कर्ष:

सबसे अधिक बार, हम केवल दो तरीकों का उपयोग करते हैं - बराबर? () और ==। मुख्य बात यह है कि बराबर याद रखना। () हमेशा है (!) और मैं दोहराता हूं, हमेशा, यह जांचता है कि चर एक वस्तु की ओर इशारा करते हैं या नहीं।

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

eql? हैश वर्ग द्वारा उपयोग किया जाता है, लेकिन यह सामान्य प्रोग्रामर के लिए विशेष रूप से आवश्यक नहीं है। केवल एक चीज है, यदि आप सरल प्रकारों के लिए == कार्यक्षमता का विस्तार करना चाहते हैं (जिसके लिए यह फ़ंक्शन ओवरराइड किया जाता है), एक वर्ग से संबंधित के लिए जाँच करके, क्या आप eql का उपयोग कर सकते हैं?

=== के लिए, यह शायद ही कभी उपयोग किया जाता है, क्योंकि यह फ़ंक्शन केस कंट्रोल के लिए सबसे अधिक भाग के लिए लागू किया गया था। हालांकि, अगर नियमित अभिव्यक्ति और स्ट्रिंग की तुलना करने की आवश्यकता है (= के अलावा कुछ के साथ ~, लेकिन क्यों?), तो ट्रिपल बराबर यहां उपयोगी है।