रेगुलर एक्सप्रेशन में

रेगुलर एक्सप्रेशन के बारे में

रेगुलर एक्सप्रेशन (रेगेक्स) अक्षरों का ऐसा क्रम होते हैं जो बताता है कि टेक्स्ट में क्या खोजना है।

रेगुलर एक्सप्रेशन का सिंटैक्स सीखना इस विषय के दायरे से बाहर है। हम उन एक्सप्रेशनों पर ध्यान देंगे जो jq रेगेक्स के इस्तेमाल के लिए देता है।

रेगेक्स का रूप

अलग-अलग टूल रेगुलर एक्सप्रेशन के अलग-अलग संस्करण लागू करते हैं। jq में Oniguruma रेगेक्स लाइब्रेरी शामिल है। यह Perl v5.8 के रेगेक्स से काफी हद तक मेल खाती है।

jq जो खास सिंटैक्स इस्तेमाल करता है, वह Oniguruma के GitHub रेपो पर मिलता है।

रेगेक्स फंक्शन

jq में रेगुलर एक्सप्रेशन कुछ फिल्टर तक ही सीमित हैं।

साधारण मैचिंग

जब आपको पता करना हो कि कोई स्ट्रिंग किसी पैटर्न से मेल खाती है या नहीं, तो test फिल्टर इस्तेमाल कीजिए।

STRING | test(REGEX)
STRING | test(REGEX; FLAGS)
STRING | test([REGEX, FLAGS])

यह फिल्टर एक बूलियन नतीजा देता है।

"Hello World!" | test("W")    # => true
"Goodbye Mars" | test("W")    # => false

मैच के बारे में जानकारी

जब आपको वह सबस्ट्रिंग निकालनी हो जो वाकई पैटर्न से मेल खाई हो, तो match फिल्टर इस्तेमाल कीजिए।

STRING | match(REGEX)
STRING | match(REGEX; FLAGS)
STRING | match([REGEX, FLAGS])

यह फिल्टर देता है:

• अगर कोई मैच नहीं मिला तो कुछ नहीं, या
• अगर मैच मिला तो कई प्रॉपर्टी वाला एक ऑब्जेक्ट।

यह उदाहरण बैकरेफ सिंटैक्स \1 का इस्तेमाल करके लगातार आने वाले दो एक जैसे स्वर ढूँढता है।

"Hello World!" | match("([aeiou])\\1")
# => empty

"Goodbye Mars" | match("([aeiou])\\1")
# => {
#      "offset": 1,
#      "length": 2,
#      "string": "oo",
#      "captures": [
#        {
#          "offset": 1,
#          "length": 1,
#          "string": "o",
#          "name": null
#        }
#      ]
#    }

match फिल्टर हर मैच के लिए एक ऑब्जेक्ट लौटाता है। यह उदाहरण "g" फ्लैग को काम करते हुए दिखाता है, जो सारे स्वर ढूँढ लेता है।

"Goodbye Mars" | match("[aeiou]"; "g")
# => { "offset": 1, "length": 1, "string": "o", "captures": [] }
#    { "offset": 2, "length": 1, "string": "o", "captures": [] }
#    { "offset": 6, "length": 1, "string": "e", "captures": [] }
#    { "offset": 9, "length": 1, "string": "a", "captures": [] }

कैप्चर की गई सबस्ट्रिंग

match फिल्टर की तरह ही, capture फिल्टर भी मैच मिलने पर एक ऑब्जेक्ट लौटाता है।

STRING | capture(REGEX)
STRING | capture(REGEX; FLAGS)
STRING | capture([REGEX, FLAGS])

लौटाया गया ऑब्जेक्ट नेम्ड कैप्चर का मैपिंग होता है।

"JIRAISSUE-1234" | capture("(?<project>\\w+)-(?<issue_num>\\d+)")
# => {
#      "project": "JIRAISSUE",
#      "issue_num": "1234"
#    }

सिर्फ सबस्ट्रिंग

scan फिल्टर "g" फ्लैग वाले match जैसा ही है।

STRING | scan(REGEX)
STRING | scan(REGEX; FLAGS)

# note, there is no scan([REGEX, FLAGS]) version, unlike other filters

scan सबस्ट्रिंग की एक स्ट्रीम देता है।

"Goodbye Mars" | scan("[aeiou]")
# => "o"
#    "o"
#    "e"
#    "a"

सबस्ट्रिंग को इकट्ठा करने के लिए [...] ऐरे कंस्ट्रक्टर इस्तेमाल कीजिए।

"Goodbye Mars" | [ scan("[aeiou]") ]
# => ["o", "o", "e", "a"]

स्ट्रिंग को तोड़ना

अगर आप जानते हैं कि स्ट्रिंग के कौन-से हिस्से आप रखना चाहते हैं, तो match या scan इस्तेमाल कीजिए। अगर आप जानते हैं कि कौन-से हिस्से हटाने हैं, तो split इस्तेमाल कीजिए।

STRING | split(REGEX; FLAGS)

एक उदाहरण जो स्ट्रिंग को किसी भी तरह के व्हाइटस्पेस पर तोड़ता है।

"first   second           third fourth" | split("\\s+"; "")
# => ["first", "second", "third", "fourth"]

"first   second           third fourth" | split("\\s+")
# => ["first   second           third fourth"]

"first   second           third fourth" | split(" ")
# => ["first", "", "", "second", "", "", "", "",
#     "", "", "", "", "", "", "third", "fourth" ]

प्रतिस्थापन

sub और gsub फिल्टर इनपुट स्ट्रिंग को बदल सकते हैं: इनपुट के जिन हिस्सों का मैच हुआ है, उन्हें किसी रिप्लेसमेंट स्ट्रिंग से बदल देते हैं।

सिर्फ पहला मैच बदलने के लिए sub इस्तेमाल कीजिए। सारे मैच बदलने के लिए gsub इस्तेमाल कीजिए।

STRING | sub(REGEX; REPLACEMENT)
STRING | sub(REGEX; REPLACEMENT; FLAGS)
STRING | gsub(REGEX; REPLACEMENT)
STRING | gsub(REGEX; REPLACEMENT; FLAGS)

"Goodnight kittens. Goodnight mittens." | sub("night"; " morning")
# => "Good morning kittens. Goodnight mittens."

"Goodnight kittens. Goodnight mittens." | gsub("night"; " morning")
# => "Good morning kittens. Good morning mittens."

रिप्लेसमेंट टेक्स्ट मैच हुई सबस्ट्रिंग को दिखा सकता है; इसके लिए नेम्ड कैप्चर और स्ट्रिंग इंटरपोलेशन इस्तेमाल कीजिए।

"Some 3-letter acronyms: gnu, csv, png"
| gsub( "\\b(?<tla>[[:alpha:]]{3})\\b";     # find words 3 letters long
        "\(.tla | ascii_upcase)" )          # upper-case the match
# => "Some 3-letter acronyms: GNU, CSV, PNG"

फ्लैग

ऊपर दिए सभी फिल्टरों में FLAGS एक स्ट्रिंग होती है, जिसमें समर्थित फ्लैग में से शून्य या अधिक फ्लैग हो सकते हैं।

• g - ग्लोबल सर्च (सिर्फ पहला नहीं, सारे मैच ढूँढिए)
• i - छोटे-बड़े अक्षरों में फर्क न करने वाली खोज
• m - मल्टी लाइन मोड ('.' नई लाइनों से भी मैच करेगा)
• n - खाली मैचों को अनदेखा करें
• p - s और m दोनों मोड चालू
• s - सिंगल लाइन मोड ('^' -> '\A', '$' -> '\Z')
• l - सबसे लंबे संभव मैच ढूँढिए
• x - एक्सटेंडेड रेगेक्स फॉर्मैट (व्हाइटस्पेस और कमेंट अनदेखा करें)

उदाहरण के लिए

"JIRAISSUE-1234" | capture("(?<project>\\w+)-(?<issue_num>\\d+)")

# or with Extended formatting

"JIRAISSUE-1234" | capture("
                     (?<project>   \\w+ )  # the Jira project
                     -                     # followed by a hyphen
                     (?<issue_num> \\d+ )  # followed by digits
                   "; "x")