रूबी नियमित अभिव्यक्तियों को माहिर करना

रूबी रेगुलर एक्सप्रेशन (रूबी रेगेक्स संक्षेप में) आपको आगे की प्रक्रिया के लिए डेटा निकालने के इरादे से स्ट्रिंग्स के अंदर विशिष्ट पैटर्न खोजने में मदद करता है।

रेगुलर एक्सप्रेशन के लिए दो सामान्य उपयोग के मामलों में सत्यापन और पार्सिंग शामिल हैं।

उदाहरण के लिए :

रूबी रेगेक्स . के साथ ईमेल पते के बारे में सोचें आप परिभाषित कर सकते हैं कि एक वैध ईमेल पता कैसा दिखता है। दूसरे शब्दों में, आपका प्रोग्राम एक मान्य और अमान्य ईमेल पते के बीच अंतर बताने में सक्षम होगा।

रूबी रेगुलर एक्सप्रेशन दो फ़ॉरवर्ड स्लैश के बीच परिभाषित होते हैं उन्हें अन्य भाषा वाक्य रचना से अलग करने के लिए। सबसे सरल भाव एक शब्द या एक अक्षर से मेल खाते हैं।

उदाहरण के लिए :

# Find the word 'like'
"Do you like cats?" =~ /like/

यह शब्द की पहली घटना की अनुक्रमणिका देता है यदि यह पाया गया था (सफल मिलान) या nil अन्यथा। अगर हमें इंडेक्स की परवाह नहीं है तो हम स्ट्रिंग # शामिल का उपयोग कर सकते हैं? विधि।

यह जांचने का एक और तरीका है कि कोई स्ट्रिंग रेगेक्स से मेल खाती है या नहीं, match . का उपयोग करना है विधि:

if "Do you like cats?".match(/like/)
  puts "Match found!"
end

अब:

आप अधिक उन्नत पैटर्न बनाना सीखेंगे ताकि आप दिनांक, फ़ोन नंबर, ईमेल, URL इत्यादि जैसी चीज़ों का मिलान, कैप्चर और प्रतिस्थापन कर सकें।

चरित्र वर्ग

एक वर्ण वर्ग आपको मिलान करने के लिए एक श्रेणी या वर्णों की सूची को परिभाषित करने देता है। उदाहरण के लिए, [aeiou] किसी भी स्वर से मेल खाता है।

उदाहरण :क्या स्ट्रिंग शामिल है एक स्वर?

def contains_vowel(str)
  str =~ /[aeiou]/
end

contains_vowel("test") # returns 1
contains_vowel("sky")  # returns nil

यह राशि . को ध्यान में नहीं रखेगा पात्रों की, हम देखेंगे कि इसे जल्द ही कैसे करना है।

श्रेणियां

हम कई अक्षरों या संख्याओं को टाइप किए बिना मिलान करने के लिए श्रेणियों का उपयोग कर सकते हैं। दूसरे शब्दों में, [2-5] . जैसी श्रेणी [2345] . जैसा ही है ।

कुछ उपयोगी श्रेणियां:

• [0-9] 0 से 9 तक किसी भी संख्या से मेल खाता है
• [a-z] a से z तक के किसी भी अक्षर से मेल खाता है (कोई कैप नहीं)
• [^a-z] नकारात्मक सीमा

उदाहरण :क्या इस स्ट्रिंग में कोई संख्या है?

def contains_number(str)
  str =~ /[0-9]/
end

contains_number("The year is 2015")  # returns 12
contains_number("The cat is black")  # returns nil

याद रखें:`=~` का उपयोग करते समय वापसी मूल्य या तो स्ट्रिंग इंडेक्स है या `शून्य`

वर्ण श्रेणियों को निर्दिष्ट करने के लिए एक अच्छा शॉर्टहैंड सिंटैक्स है:

• \w [0-9a-zA-Z_] . के बराबर है
• \d [0-9] . जैसा ही है
• \s सफेद स्थान matches से मेल खाता है (टैब, रेगुलर स्पेस, न्यूलाइन)

इनका एक नकारात्मक रूप भी है:

• \W कुछ भी जो [0-9a-zA-Z_] . में नहीं है
• \D कुछ भी जो एक संख्या नहीं है
• \S कुछ भी जो जगह नहीं है

डॉट कैरेक्टर . सब कुछ लेकिन नई लाइनों से मेल खाता है। यदि आपको शाब्दिक . . का उपयोग करने की आवश्यकता है तो आपको इससे बचना होगा।

उदाहरण :विशेष पात्रों से बचना

# If we don't escape, the letter will match
"5a5".match(/\d.\d/)

# In this case only the literal dot matches
"5a5".match(/\d\.\d/) # nil
"5.5".match(/\d\.\d/) # match

संशोधक

अब तक हम एक बार में केवल एक ही चरित्र का मिलान कर पाए हैं। कई वर्णों का मिलान करने के लिए हम पैटर्न संशोधक का उपयोग कर सकते हैं।

अधिक जटिल रेगुलर एक्सप्रेशन बनाने के लिए हम अब तक सीखी गई हर चीज़ को मिला सकते हैं।

उदाहरण :क्या यह IP पता जैसा दिखता है?

# Note that this will also match some invalid IP address
# like 999.999.999.999, but in this case we just care about the format.

def ip_address?(str)
  # We use !! to convert the return value to a boolean
  !!(str =~ /^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$/)
end

ip_address?("192.168.1.1")  # returns true
ip_address?("0000.0000")    # returns false

सटीक स्ट्रिंग मिलान

यदि आपको सटीक मिलान की आवश्यकता है तो आपको दूसरे प्रकार के संशोधक की आवश्यकता होगी। आइए एक उदाहरण देखें ताकि आप देख सकें कि मैं किस बारे में बात कर रहा हूं:

# We want to find if this string is exactly four letters long, this will
# still match because it has more than four, but it's not what we want.
"Regex are cool".match /\w{4}/

# Instead we will use the 'beginning of line' and 'end of line' modifiers
"Regex are cool".match /^\w{4}$/

# This time it won't match. This is a rather contrived example, since we could just
# have used .size to find the length, but I think it gets the idea across.

एक स्ट्रिंग की शुरुआत में सख्ती से मिलान करने के लिए और न केवल प्रत्येक पंक्ति पर (\n . के बाद) ) आपको \A . का उपयोग करने की आवश्यकता है और \Z ^ . के बजाय और $ ।

समूह कैप्चर करें

कैप्चर समूहों के साथ, हम मैच के हिस्से को कैप्चर कर सकते हैं और बाद में उसका पुन:उपयोग कर सकते हैं। एक मैच को कैप्चर करने के लिए हम उस हिस्से को संलग्न करते हैं जिसे हम कोष्ठक में कैप्चर करना चाहते हैं।

उदाहरण :लॉग फ़ाइल को पार्स करना

Line = Struct.new(:time, :type, :msg)
LOG_FORMAT = /(\d{2}:\d{2}) (\w+) (.*)/

def parse_line(line)
  line.match(LOG_FORMAT) { |m| Line.new(*m.captures) }
end

parse_line("12:41 INFO User has logged in.")
# This produces objects like this:
# 

इस उदाहरण में, हम .match . का उपयोग कर रहे हैं =~ . के बजाय ।

यह विधि MatchData returns लौटाती है यदि कोई मेल है तो वस्तु, अन्यथा शून्य। MatchData कक्षा में कई उपयोगी तरीके हैं, अधिक जानने के लिए दस्तावेज़ देखें!

यदि आप केवल एक बूलियन मान चाहते हैं (true / false ) तो आप match? . का उपयोग कर सकते हैं विधि, जो रूबी 2.4 के बाद से उपलब्ध है। यह match . से भी तेज़ है चूंकि रूबी को MatchData बनाने की आवश्यकता नहीं है वस्तु।

आप कैप्चर किए गए डेटा को .captures . का उपयोग करके एक्सेस कर सकते हैं विधि या उपचार MatchData एक सरणी की तरह वस्तु, शून्य अनुक्रमणिका का पूरा मिलान होगा और परिणामी अनुक्रमणिका में मेल खाने वाले समूह होंगे।

यदि आप पहला कैप्चर समूह चाहते हैं तो आप यह कर सकते हैं:

m = "John 31".match /\w+ (\d+)/

m[1]
# 31

आपके पास गैर-कैप्चरिंग समूह भी हो सकते हैं। वे आपको प्रदर्शन दंड के बिना अभिव्यक्ति को एक साथ समूहित करने देंगे। जटिल अभिव्यक्तियों को पढ़ने में आसान बनाने के लिए आपको नामित समूह भी उपयोगी लग सकते हैं।

उदाहरण :नामित समूह

m = "David 30".match /(?\w+) (?\d+)/
m[:age]
# => "30"
m[:name]
# => "David"

एक नामित समूह MatchData returns देता है ऑब्जेक्ट जिसे आप परिणाम पढ़ने के लिए एक्सेस कर सकते हैं।

आगे देखें और पीछे देखें

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

आगे देखें, आइए देखें और देखें कि पहले या बाद में कोई विशिष्ट मैच है या नहीं।

उदाहरण :क्या कम से कम एक अक्षर से पहले कोई संख्या है?

def number_after_word?(str)
  !!(str =~ /(?<=\w) (\d+)/)
end

number_after_word?("Grade 99")

रूबी की रेगेक्स क्लास

रूबी रेगुलर एक्सप्रेशन Regexp . के उदाहरण हैं कक्षा। अधिकांश समय आप सीधे इस कक्षा का उपयोग नहीं करेंगे, लेकिन यह जानना अच्छा है

puts /a/.class
# Regexp

एक संभावित उपयोग स्ट्रिंग से रेगेक्स बनाना है:

regexp = Regexp.new("a")

रेगेक्सपी बनाने का दूसरा तरीका:

regexp = %r{\w+}

रेगेक्स विकल्प

आप अपने रेगुलर एक्सप्रेशन को अलग तरह से व्यवहार करने के लिए कुछ विकल्प सेट कर सकते हैं।

इन विकल्पों का उपयोग करने के लिए आप रेगेक्स के अंत में अक्षर जोड़ते हैं, समापन के बाद / ।

इसे पसंद करें :

"abc".match?(/[A-Z]/i)

लंबे रेगुलर एक्सप्रेशन को फ़ॉर्मेट करना

जटिल रूबी नियमित अभिव्यक्ति पढ़ने में काफी कठिन हो सकती है, इसलिए यदि हम उन्हें कई पंक्तियों में तोड़ दें तो यह सहायक होगा। हम इसे 'x' संशोधक का उपयोग करके कर सकते हैं। यह प्रारूप आपको अपने रेगेक्स के अंदर टिप्पणियों का उपयोग करने की भी अनुमति देता है।

उदाहरण :

LOG_FORMAT = %r{
  (\d{2}:\d{2}) # Time
  \s(\w+)       # Event type
  \s(.*)        # Message
}x

रूबी रेगेक्स:सभी को एक साथ रखना

कई रूबी विधियों के साथ नियमित अभिव्यक्तियों का उपयोग किया जा सकता है।

• .विभाजन
• .स्कैन करें
• .gsub
• और भी बहुत कुछ...

उदाहरण :.scan का उपयोग करके एक स्ट्रिंग के सभी शब्दों का मिलान करें

"this is some string".scan(/\w+/)
# => ["this", "is", "some", "string"]

उदाहरण :एक स्ट्रिंग से सभी नंबर निकालें

"The year was 1492.".scan(/\d+/)
# => ["1492"]

उदाहरण :सभी शब्दों को एक स्ट्रिंग में बड़ा करें

str = "lord of the rings"

str.gsub(/\w+/) { |w| w.capitalize }
# => "Lord Of The Rings"

उदाहरण :ईमेल पता सत्यापित करें

email = "test@example.com"

!!email.match(/\A[\w.+-]+@\w+\.\w+\z/)

# true

यह अंतिम उदाहरण !! . का उपयोग करता है परिणाम को बूलियन मान में बदलने के लिए (true / false ), वैकल्पिक रूप से आप match? . का उपयोग कर सकते हैं रूबी 2.4+ में विधि जो आपके लिए पहले से ही ऐसा करती है और यह तेज़ भी है।

निष्कर्ष

रेगुलर एक्सप्रेशन अद्भुत होते हैं लेकिन कभी-कभी वे थोड़े मुश्किल हो सकते हैं। Rubular.com जैसे टूल का उपयोग करने से आपको अपना रूबी रेगेक्स . बनाने में मदद मिल सकती है अधिक संवादात्मक तरीके से। रुबुलर में रूबी रेगुलर एक्सप्रेशन चीट शीट भी शामिल है जो आपको बहुत उपयोगी लगेगी। अब उस संपादक को खोलने और कोडिंग शुरू करने की आपकी बारी है!

ओह, और इसे साझा करना करना न भूलें अपने दोस्तों के साथ अगर आपको मज़ा आया, तो और लोग सीख सकते हैं 🙂