पैटर्न मिलान करते समय = ~ और मैच() के बीच क्या अंतर है?

Question

मैं Ruby 1.9.3 का उपयोग कर रहा हूं। मैं कुछ पैटर्न के साथ खेल रहे हैं और कुछ दिलचस्प पाया गया था:

उदाहरण 1:

irb(main):001:0> /hay/ =~ 'haystack' 
=> 0 
irb(main):003:0> /st/ =~ 'haystack' 
=> 3 

उदाहरण 2:

irb(main):002:0> /hay/.match('haystack') 
=> #<MatchData "hay"> 
irb(main):004:0> /st/.match('haystack') 
=> #<MatchData "st"> 

=~ रिटर्न अपने पहले मैच के पहले स्थान, जबकि match पैटर्न रिटर्न । इसके अलावा, =~ और match() के बीच कोई अंतर है?

निष्पादन समय अंतर(@Casper के अनुसार)

irb(main):005:0> quickbm(10000000) { "foobar" =~ /foo/ } 
Rehearsal ------------------------------------ 
    8.530000 0.000000 8.530000 ( 8.528367) 
--------------------------- total: 8.530000sec 

     user  system  total  real 
    8.450000 0.000000 8.450000 ( 8.451939) 
=> nil 

irb(main):006:0> quickbm(10000000) { "foobar".match(/foo/) } 
Rehearsal ------------------------------------ 
    15.360000 0.000000 15.360000 (15.363360) 
-------------------------- total: 15.360000sec 

     user  system  total  real 
    15.240000 0.010000 15.250000 (15.250471) 
=> nil 

Answer 1

पहले सुनिश्चित करें कि आप सही ऑपरेटर उपयोग कर रहे हैं: =~ सही है, ~= नहीं है।

ऑपरेटर =~ पहले मैच के सूचकांक (nil अगर कोई मुकाबला नहीं) और दुकानों वैश्विक चर $~ में MatchData देता है। नामित कैप्चर समूह को $~ पर हैश पर असाइन किया गया है, और जब RegExp ऑपरेटर के बाईं ओर एक शाब्दिक है, तो उन नामों के साथ स्थानीय चर को भी असाइन किया जाता है।

>> str = "Here is a string" 
>> re = /(?<vowel>[aeiou])/ # Contains capture group named "vowel" 
>> str =~ re 
=> 1 
>> $~ 
=> #<MatchData "e" vowel:"e"> 
>> $~[:vowel] # Accessible using symbol... 
=> "e" 
>> $~["vowel"] # ...or string 
=> "e" 
>> /(?<s_word>\ss\w*)/ =~ str 
=> 9 
>> s_word # This was assigned to a local variable 
=> " string" 

विधि matchMatchData ही (फिर से, nil अगर कोई मुकाबला नहीं) देता है। विधि कॉल के दोनों तरफ, इस मामले में नामित कैप्चर समूह, MatchData पर एक हैश को असाइन किए गए हैं।

>> m = str.match re 
=> #<MatchData "e" vowel:"e"> 
>> m[:vowel] 
=> "e" 

अधिक जानकारी के लिए http://www.ruby-doc.org/core-1.9.3/Regexp.html (और साथ ही MatchData पर वर्गों और String) देखें।

Answer 2

जब आपके पास ऐसी कोई विधि है जो राज्य को संशोधित नहीं करती है, तो ये सभी महत्वपूर्ण मूल्य है। तो रंग के अलावा लाल और नीले रंग के बीच क्या अंतर है? मेरा मुद्दा यह है कि यह एक अजीब सवाल है, जिसे आप पहले ही जवाब जानते हैं। (@sawa मुझे सीधे सेट करें)

लेकिन कहा कि दोनों विधियां nil (एक झूठी मान) लौटाती हैं जब रेगेक्स मेल नहीं खाता है। और, जब यह मेल खाता है तो दोनों विधियां एक सच्चे मूल्य लौटती हैं। =~ एक पूर्णांक देता है जो मैच के पहले अक्षर का प्रतिनिधित्व करता है, और भले ही वह 0 है, क्योंकि 0 रूबी में सत्य है। match एक ऑब्जेक्ट को बहुत विस्तृत मिलान डेटा के साथ देता है, जो कि आसान है जब आप मैच के बारे में बहुत सारी जानकारी चाहते हैं।

=~ आम तौर पर अगर कुछ मेल खाता है, सशर्त, में प्रयोग किया जाता है जब आप केवल परवाह:

do_stuff if "foobar" =~ /foo/ 
do_stuff if "foobar".match(/foo/) # same effect, but probably slower and harder to read 

match आम तौर पर प्रयोग किया जाता है जब आप क्या मिलान किया गया था के बारे में विवरण हैं:

name = "name:bob".match(/^name:(\w+)$/)[1] 
puts name #=> 'bob'