Ruby Language
रेगुलर एक्सप्रेशंस एंड रेगेक्स बेस्ड ऑपरेशंस

समूह, नाम और अन्यथा।

रूबी एक नामित समूह के साथ मानक समूह वाक्यविन्यास (...) विस्तार करता है, (?<name>...) । यह आपके पास कितने समूह हैं, यह गिनने के बजाय नाम से निष्कर्षण की अनुमति देता है।

name_reg = /h(i|ello), my name is (?<name>.*)/i #i means case insensitive

name_input = "Hi, my name is Zaphod Beeblebrox"

match_data = name_reg.match(name_input) #returns either a MatchData object or nil
match_data = name_input.match(name_reg) #works either way

if match_data.nil? #Always check for nil! Common error.
  puts "No match"
else
  match[0] #=> "Hi, my name is Zaphod Beeblebrox"
  match[1] #=> "i" #the first group, (i|ello)
  match[2] #=> "Zaphod Beeblebrox"
  #Because it was a named group, we can get it by name
  match[:name]  #=> "Zaphod Beeblebrox"
  match["name"] #=> "Zaphod Beeblebrox"
  puts "Hello #{match[:name]}!"
end

मैच के सूचकांक को बाएं कोष्ठकों के क्रम के आधार पर गिना जाता है (पूरे रेगेक्स इंडेक्स एक्स में पहला समूह होने के साथ)

reg = /(((a)b)c)(d)/
match = reg.match 'abcd'
match[0] #=> "abcd"
match[1] #=> "abc"
match[2] #=> "ab"
match[3] #=> "a"
match[4] #=> "d"

= ~ संचालक

if /hay/ =~ 'haystack'
  puts "There is hay in the word haystack"
end

नोट: आदेश महत्वपूर्ण है । हालांकि 'haystack' =~ /hay/ ज्यादातर मामलों में एक समान है, साइड इफेक्ट अलग हो सकते हैं:

• नामित कैप्चर समूहों से कैप्चर किए गए स्ट्रिंग्स को केवल स्थानीय वेरिएबल्स को सौंपा जाता है, जब Regexp#=~ कहा जाता है ( regexp =~ str );
• चूंकि सही ऑपरेंड हो सकता है, एक मनमाना ऑब्जेक्ट है, regexp =~ str वहाँ या तो Regexp#=~ या String#=~ ।

ध्यान दें कि यह सही / गलत मान नहीं लौटाता है, यह बदले में या तो मैच का इंडेक्स देता है, या नहीं मिला तो शून्य। क्योंकि माणिक में सभी पूर्णांक सत्य हैं (0 सहित) और नील मिथ्या है, यह काम करता है। यदि आप बूलियन मान चाहते हैं, तो #=== उपयोग करें जैसा कि एक अन्य उदाहरण में दिखाया गया है।

परिमाणकों

क्वांटिफायर बार-बार तार की गिनती निर्दिष्ट करने की अनुमति देता है।

• शून्य या एक:

  /a?/
  

• शून्य या कई:

  /a*/
  

• एक या कई:

  /a+/
  

• सटीक संख्या:

  /a{2,4}/ # Two, three or four
  /a{2,}/  # Two or more
  /a{,4}/  # Less than four (including zero)
  

डिफ़ॉल्ट रूप से, क्वांटिफायर लालची होते हैं , जिसका अर्थ है कि वे उतने ही पात्रों को लेते हैं, जितने कि वे अभी भी एक मैच बना रहे हैं। आम तौर पर यह ध्यान देने योग्य नहीं है:

/(?<site>.*) Stack Exchange/ =~ 'Motor Vehicle Maintenance & Repair Stack Exchange'

नामित कैप्चर समूह site को अपेक्षित रूप में '' मोटर वाहन रखरखाव और मरम्मत '' पर सेट किया जाएगा। लेकिन अगर the स्टैक एक्सचेंज ’स्ट्रिंग का एक वैकल्पिक हिस्सा है (क्योंकि इसके बजाय flow स्टैक ओवरफ्लो’ हो सकता है), तो भोली समाधान अपेक्षा के अनुरूप काम नहीं करेगा:

/(?<site>.*)( Stack Exchange)?/

यह संस्करण अभी भी मेल खाएगा, लेकिन नामित कैप्चर में 'स्टैक एक्सचेंज' शामिल होगा क्योंकि * उन पात्रों को लालच देता है। * आलसी बनाने के लिए एक और सवालिया निशान जोड़ने का उपाय है:

/(?<site>.*?)( Stack Exchange)?/

लागू हो रहा है ? किसी भी मात्रा में यह आलसी कर देगा।

चरित्र वर्ग

प्रतीकों की श्रेणियों का वर्णन करता है

आप स्पष्ट रूप से प्रतीकों की गणना कर सकते हैं

/[abc]/ # 'a' or 'b' or 'c'

या पर्वतमाला का उपयोग करें

/[a-z]/ # from 'a' to 'z'

पर्वतमाला और एकल प्रतीकों को संयोजित करना संभव है

/[a-cz]/ # 'a' or 'b' or 'c' or 'z'

अग्रणी डैश ( - ) को चरचर के रूप में माना जाता है

/[-a-c]/ # '-' or 'a' or 'b' or 'c'

^ साथ प्रतीकों को पूर्व में देने पर कक्षाएं ऋणात्मक हो सकती हैं

/[^a-c]/ # Not 'a', 'b' or 'c'

व्यापक वर्गों और विशेष चरकों, प्लस लाइन अंत के लिए कुछ शॉर्टकट हैं

^  # Start of line
$  # End of line
\A # Start of string
\Z # End of string, excluding any new line at the end of string
\z # End of string
.  # Any single character
\s # Any whitespace character
\S # Any non-whitespace character
\d # Any digit
\D # Any non-digit
\w # Any word character (letter, number, underscore)
\W # Any non-word character
\b # Any word boundary

\n बस नई लाइन के रूप में समझा जाएगा

किसी भी आरक्षित चरचर से बचने के लिए, जैसे / या [] और अन्य बैकस्लैश का उपयोग करते हैं (बाएं स्लैश)

\\ # => \
\[\] # => []

केस स्टेटमेंट में नियमित अभिव्यक्तियाँ

यदि कोई स्ट्रिंग स्विच स्टेटमेंट का उपयोग करके कई नियमित अभिव्यक्तियों से मेल खाती है तो आप परीक्षण कर सकते हैं।

उदाहरण

case "Ruby is #1!"
when /\APython/
    puts "Boooo."
when /\ARuby/
    puts "You are right."
else 
    puts "Sorry, I didn't understand that."
end

यह काम करता है क्योंकि मामले के बयानों को === ऑपरेटर के उपयोग के लिए समानता के लिए जांचा जाता है, == ऑपरेटर को नहीं। जब एक regex === का उपयोग करके तुलना के बाएं हाथ पर होता है, तो यह देखने के लिए एक स्ट्रिंग का परीक्षण करेगा कि क्या यह मेल खाता है।

एक Regexp को परिभाषित करना

रूबी में तीन अलग-अलग तरीकों से एक Regexp बनाया जा सकता है।

• स्लैश का उपयोग करना: / /

• %r{} का उपयोग करना

• Regex.new का उपयोग Regex.new

  #The following forms are equivalent
  regexp_slash = /hello/
  regexp_bracket = %r{hello}
  regexp_new = Regexp.new('hello')
  
  string_to_match = "hello world!"
  
  #All of these will return a truthy value
  string_to_match =~ regexp_slash    # => 0
  string_to_match =~ regexp_bracket  # => 0
  string_to_match =~ regexp_new      # => 0
  

मेल खाते हैं? - बुलियन परिणाम

true या false रिटर्न, जो इंगित करता है कि $~ और अन्य संबंधित चर को अपडेट किए बिना regexp मिलान किया गया है या नहीं। यदि दूसरा पैरामीटर मौजूद है, तो यह खोज शुरू करने के लिए स्ट्रिंग में स्थिति निर्दिष्ट करता है।

/R.../.match?("Ruby")    #=> true
/R.../.match?("Ruby", 1) #=> false
/P.../.match?("Ruby")    #=> false

रूबी 2.4+

सामान्य त्वरित उपयोग

नियमित अभिव्यक्तियों का उपयोग अक्सर तरीकों में किया जाता है ताकि जाँच की जा सके कि क्या अन्य तार मौजूद हैं या तार को खोजने और / या बदलने के लिए।

आप अक्सर निम्नलिखित देखेंगे:

string = "My not so long string"
string[/so/] # gives so
string[/present/] # gives nil
string[/present/].nil? # gives true

तो आप बस इसे एक चेक के रूप में उपयोग कर सकते हैं यदि एक स्ट्रिंग में एक विकल्प है

puts "found" if string[/so/]

अधिक उन्नत लेकिन अभी भी कम और त्वरित: दूसरे पैरामीटर का उपयोग करके एक विशिष्ट समूह की खोज करें, 2 इस उदाहरण में दूसरा है क्योंकि नंबर 1 पर शुरू होता है और 0 नहीं, एक समूह जो कोष्ठक में संलग्न है।

string[/(n.t).+(l.ng)/, 2] # gives long

इसके अलावा अक्सर उपयोग किया जाता है: sub या gsub साथ खोजें और बदलें, \1 पहला पाया गया समूह, दूसरा \2 :

string.gsub(/(n.t).+(l.ng)/, '\1 very \2') # My not very long string

अंतिम परिणाम को याद किया जाता है और निम्नलिखित पंक्तियों पर उपयोग किया जा सकता है

$2 # gives long