बही की निगरानी

आप मूल बातें पहले ही जानते हैं: \d और [A-Z] जैसे कैरेक्टर क्लास, {4} और + जैसे क्वांटिफायर, और matches?, all-matching-subseqs तथा re-replace जैसे वर्ड। यह अभ्यास रेगुलर एक्सप्रेशन के उन हिस्सों को जोड़ता है जो संरचना और संदर्भ बताते हैं। ये सब उसी regexp वोकैबुलरी में रहते हैं और उसी R/ / लिटरल से लिखे जाते हैं।

एंकर

एंकर किसी अक्षर के बजाय एक स्थिति से मेल खाते हैं:

^    ! the start of the string
$    ! the end of the string
\b   ! a word boundary

चूँकि $ स्ट्रिंग के अंत को बताता है, जब आपका मतलब असली डॉलर चिह्न हो तो \$ लिखिए।

एक वर्ड बाउंड्री (\b) वह जगह है जहाँ एक वर्ड कैरेक्टर किसी गैर-वर्ड कैरेक्टर से मिलता है। वर्ड कैरेक्टर अक्षर, अंक और अंडरस्कोर होते हैं; बाकी सब कुछ, यानी स्पेस, विराम चिह्न और स्ट्रिंग के दोनों सिरे, बाउंड्री गिने जाते हैं। इसलिए \bcat\b cat से तभी मेल खाता है जब वह अकेला खड़ा हो:

USING: regexp ;

"cat nap" R/ \bcat\b/ re-contains? .   ! => t
"scatter" R/ \bcat\b/ re-contains? .   ! => f   (cat sits inside a word)

ग्रुपिंग और अल्टरनेशन

गोल ब्रैकेट ( ) पैटर्न के एक हिस्से को समूह में बाँधते हैं, ताकि कोई क्वांटिफायर, या | (यानी "यह या वह"), पूरे समूह पर लागू हो:

USING: regexp ;

"abab" R/ (ab)+/ matches? .                ! => t   (+ applies to "ab")
"dog"  R/ cat|dog/ matches? .              ! => t   (either word)
"$100.50" R/ \$\d+(\.\d{2})?/ matches? .   ! => t
"$100"    R/ \$\d+(\.\d{2})?/ matches? .   ! => t   (the group is optional)

आखिरी पैटर्न का मतलब है "एक डॉलर चिह्न, एक या अधिक अंक, फिर एक डॉट और दो अंकों का वैकल्पिक समूह"।

ध्यान दीजिए: Factor में समूह पैटर्न को सिर्फ व्यवस्थित करता है। कुछ रेगेक्स टूल की तरह यहाँ आप समूह द्वारा मैच किए गए टेक्स्ट को वापस नहीं निकाल सकते। कैप्चर-ग्रुप निकालने की कोई सुविधा नहीं है, और \1 जैसे बैक-रेफरेंस काम नहीं करते। किसी लैंडमार्क के आसपास का टेक्स्ट निकालने के लिए इसके बजाय लुकअराउंड इस्तेमाल कीजिए (नीचे देखिए)।

लुकअराउंड: संदर्भ से मिलान, बिना उसे खर्च किए

एक लुकअराउंड यह जाँचता है कि मौजूदा जगह के ठीक पहले या ठीक बाद क्या आता है, बिना उन अक्षरों को मैच का हिस्सा बनाए। यह "ज़ीरो-विड्थ" होता है, यानी जो यह जाँचता है वह नतीजे में शामिल नहीं होता।

(?=...)    ! lookahead:           ... must follow
(?!...)    ! negative lookahead:  ... must NOT follow
(?<=...)   ! lookbehind:          ... must come before
(?<!...)   ! negative lookbehind: ... must NOT come before

लुकअराउंड चुनिंदा होता है, यानी वही अक्षर इस बात पर मैच होते हैं या नहीं होते कि उनके बगल में क्या बैठा है। एक सादा \d+ हर संख्या उठा लेता है; लुकबिहाइंड और लुकअहेड सिर्फ उन्हीं को रखते हैं जिनका पड़ोसी सही है:

USING: regexp ;

"3 for $10 or 10 for $30" R/ \d+/ all-matching-subseqs .
! => { "3" "10" "10" "30" }   (every number)

"3 for $10 or 10 for $30" R/ (?<=\$)\d+/ all-matching-subseqs .
! => { "10" "30" }            (only the prices — the bare 3 and 10 drop)

"buy 2 at 15% off, 4 at 30% off" R/ \d+(?=%)/ all-matching-subseqs .
! => { "15" "30" }            (only the discounts — the bare 2 and 4 drop)

ऑप्शन

क्लोज़िंग / के बाद एक अक्षर जोड़ने से पूरे पैटर्न का व्यवहार बदल जाता है। i इसे केस-असंवेदनशील बना देता है:

USING: regexp ;

"REFUND"  R/ refund/i matches? .       ! => t
"Refund"  R/ refund/i matches? .       ! => t

हर मैच को बदलना

all-matching-subseqs आपको मैच हुआ टेक्स्ट देता है। map-matches एक कदम आगे जाता है: यह हर मैच पर एक क्वोटेशन चलाता है और नतीजे इकट्ठा करता है। क्वोटेशन को मैच का start इंडेक्स, उसका end इंडेक्स और पूरी स्ट्रिंग मिलते हैं; subseq इन तीनों से मैच हुआ टेक्स्ट बनाता है, जिसे फिर आप बदलते हैं:

map-matches ( string regexp quot: ( start end string -- obj ) -- seq )

USING: math regexp sequences ;

"a1 b22 c333" R/ \d+/ [ subseq length ] map-matches .
! => { 1 2 3 }     (the length of each run of digits)

इसका सिर्फ साइड-इफेक्ट वाला साथी, each-match, हर मैच पर एक क्वोटेशन चलाता है और कुछ भी इकट्ठा नहीं करता।