यह आदेश perlfaq6 है जिसे हमारे कई मुफ्त ऑनलाइन वर्कस्टेशन जैसे कि उबंटू ऑनलाइन, फेडोरा ऑनलाइन, विंडोज ऑनलाइन एमुलेटर या मैक ओएस ऑनलाइन एमुलेटर में से एक का उपयोग करके ऑनवर्क्स मुफ्त होस्टिंग प्रदाता में चलाया जा सकता है।
कार्यक्रम:
नाम
perlfaq6 - नियमित अभिव्यक्तियाँ
VERSION
5.021009 संस्करण
वर्णन
यह अनुभाग आश्चर्यजनक रूप से छोटा है क्योंकि शेष FAQ उत्तरों से अटे पड़े हैं
नियमित अभिव्यक्ति शामिल है। उदाहरण के लिए, किसी URL को डिकोड करना और जाँचना कि क्या कुछ
यह एक संख्या है जिसे नियमित अभिव्यक्तियों के साथ नियंत्रित किया जा सकता है, लेकिन वे उत्तर कहीं और पाए जाते हैं
इस दस्तावेज़ में (perlfaq9 में: "मैं वेब पर उन %-एन्कोडिंग को कैसे डिकोड या बना सकता हूँ"
और perlfaq4: "मैं यह कैसे निर्धारित करूं कि एक अदिश एक संख्या/संपूर्ण/पूर्णांक/फ्लोट है",
सटीक)।
कैसे कर सकते हैं I आशा सेवा मेरे उपयोग नियमित भाव बिना बनाने अस्पष्ट और रखरखाव योग्य नहीं कोड?
तीन तकनीकें नियमित अभिव्यक्ति को रखरखाव योग्य और समझने योग्य बना सकती हैं।
रेगेक्स के बाहर टिप्पणियाँ
सामान्य पर्ल टिप्पणियों का उपयोग करके वर्णन करें कि आप क्या कर रहे हैं और कैसे कर रहे हैं।
# पंक्ति को पहले शब्द, कोलन और में बदलें
# पंक्ति के शेष भाग पर वर्णों की संख्या
s/^(\w+)(.*)/ lc($1) . ":" . लंबाई($2) /मेग;
रेगेक्स के अंदर टिप्पणियाँ
"/x" संशोधक के कारण रेगेक्स पैटर्न में व्हाइटस्पेस को नजरअंदाज कर दिया जाता है (ए को छोड़कर)।
चरित्र वर्ग और कुछ अन्य स्थान), और आपको सामान्य टिप्पणियों का उपयोग करने की भी अनुमति देता है
वहाँ भी। जैसा कि आप कल्पना कर सकते हैं, रिक्त स्थान और टिप्पणियाँ बहुत मदद करती हैं।
"/x" आपको इसे चालू करने देता है:
s{<(?:[^>'"]*|".*?"|'.*?')+>}{}gs;
इस मामले में:
s{ < # ओपनिंग एंगल ब्रैकेट
(?: # नॉन-बैकरेफ़िंग ग्रुपिंग पैरेन
[^>'"] * # 0 या अधिक चीजें जो न तो > न ही ' न ही " हैं
| # वरना
".*?" # दोहरे उद्धरण चिह्नों के बीच एक अनुभाग (कंजूस मिलान)
| # वरना
'.*?' # सिंगल कोट्स के बीच एक अनुभाग (कंजूस मिलान)
) + # सभी एक या अधिक बार घटित होते हैं
> # समापन कोण ब्रैकेट
}{}जीएसएक्स; # कुछ नहीं से बदलें, यानी हटाएं
यह अभी भी गद्य जितना स्पष्ट नहीं है, लेकिन इसका वर्णन करने के लिए यह बहुत उपयोगी है
पैटर्न के प्रत्येक भाग का अर्थ.
विभिन्न सीमांकक
जबकि हम आम तौर पर पैटर्न को "/" वर्णों के साथ सीमांकित मानते हैं, वे ऐसा कर सकते हैं
लगभग किसी भी वर्ण द्वारा सीमांकित किया जा सकता है। पर्ल्रे इसका वर्णन करता है। उदाहरण के लिए, "s///"
उपरोक्त ब्रेसिज़ को सीमांकक के रूप में उपयोग करता है। किसी अन्य सीमांकक का चयन करने से उद्धरण देने से बचा जा सकता है
पैटर्न के भीतर सीमांकक:
s// usr\/स्थानीय// usr\/शेयर/जी; # ख़राब सीमांकक चयन
s#/ Usr / स्थानीय#/ Usr / share#जी; # बेहतर
तार्किक रूप से युग्मित सीमांकक का उपयोग और भी अधिक पठनीय हो सकता है:
s{/ usr / स्थानीय /}{/ Usr / share}जी; # अभी भी बेहतर
मैं हूँ होने मुसीबत मिलान के ऊपर अधिक से एक लाइन. क्या है गलत?
या तो आप जिस स्ट्रिंग को देख रहे हैं उसमें एक से अधिक पंक्तियाँ नहीं हैं (संभवतः), या
अन्यथा आप अपने पैटर्न पर (संभवतः) सही संशोधक का उपयोग नहीं कर रहे हैं।
मल्टीलाइन डेटा को एक स्ट्रिंग में प्राप्त करने के कई तरीके हैं। अगर आप चाहते हैं कि ऐसा हो
इनपुट पढ़ते समय स्वचालित रूप से, आप पैराग्राफ के लिए $/ (संभवतः '' पर सेट करना चाहेंगे
संपूर्ण फ़ाइल के लिए "अनडेफ़") आपको एक समय में एक से अधिक पंक्तियाँ पढ़ने की अनुमति देता है।
यह तय करने में मदद के लिए पर्लरे पढ़ें कि आप "/s" और "/m" (या दोनों) में से किसका उपयोग करना चाहेंगे:
"/s" डॉट को न्यूलाइन शामिल करने की अनुमति देता है, और "/m" कैरेट और डॉलर को ए के आगे मिलान करने की अनुमति देता है
नई पंक्ति, केवल स्ट्रिंग के अंत में नहीं। आपको यह सुनिश्चित करने की ज़रूरत है कि आपने वास्तव में ऐसा किया है
वहां एक मल्टीलाइन स्ट्रिंग मिली।
उदाहरण के लिए, यह प्रोग्राम डुप्लिकेट शब्दों का पता लगाता है, भले ही वे लाइन ब्रेक करते हों (लेकिन
पैराग्राफ वाले नहीं)। इस उदाहरण के लिए, हमें "/s" की आवश्यकता नहीं है क्योंकि हम a में बिंदु का उपयोग नहीं कर रहे हैं
नियमित अभिव्यक्ति कि हम रेखा की सीमाओं को पार करना चाहते हैं। न ही हमें "/m" की आवश्यकता है क्योंकि
हम नहीं चाहते कि न्यूलाइन के आगे रिकॉर्ड के अंदर किसी भी बिंदु पर कैरेट या डॉलर का मिलान हो।
लेकिन यह जरूरी है कि $/ को डिफ़ॉल्ट के अलावा किसी अन्य पर सेट किया जाए, अन्यथा हम ऐसा नहीं करेंगे
वास्तव में कभी भी एक मल्टीलाइन रिकॉर्ड पढ़ा गया है।
$/ = ''; # सिर्फ एक लाइन नहीं बल्कि पूरा पैराग्राफ पढ़ें
जबकि ( <> ) {
जबकि ( /\b([\w'-]+)(\s+\g1)+\b/gi ) { # शब्द अल्फा शुरू होता है
"पैराग्राफ $.\n पर डुप्लिकेट $1" प्रिंट करें;
}
}
यहां कुछ कोड हैं जो ऐसे वाक्य ढूंढते हैं जो "से" से शुरू होते हैं (जो कि उलझ जाएंगे
कई मेलर्स):
$/ = ''; # सिर्फ एक लाइन नहीं बल्कि पूरा पैराग्राफ पढ़ें
जबकि ( <> ) {
जबकि ( /^From /gm ) { # /m, \n के आगे ^ का मिलान करता है
"पैराग्राफ $.\n से अग्रणी" प्रिंट करें;
}
}
यहां वह कोड है जो पैराग्राफ में START और END के बीच सब कुछ ढूंढता है:
अपरिभाषित $/; # पूरी फाइल पढ़ें, सिर्फ एक पंक्ति या पैराग्राफ नहीं
जबकि ( <> ) {
जबकि ( /START(.*?)END/sgm ) { # /s बनाता है . रेखा की सीमाओं को पार करें
"$1\n" प्रिंट करें;
}
}
कैसे कर सकते हैं I खींच आउट पंक्तियां के बीच दो पैटर्न उपयोग करें कि रहे अपने on विभिन्न पंक्तियाँ?
आप पर्ल के कुछ हद तक विदेशी ".." ऑपरेटर का उपयोग कर सकते हैं (पर्लॉप में प्रलेखित):
perl -ne 'प्रिंट करें यदि /START/ .. /END/' फ़ाइल1 फ़ाइल2...
यदि आप पाठ चाहते हैं, पंक्तियाँ नहीं, तो आप इसका उपयोग करेंगे
perl -0777 -ne 'प्रिंट "$1\n" जबकि /START(.*?)END/gs' फ़ाइल1 फ़ाइल2 ...
लेकिन यदि आप "START" से लेकर "END" तक नेस्टेड घटनाएँ चाहते हैं, तो आप इसका विरोध करेंगे
संतुलित पाठ के मिलान पर इस खंड में प्रश्न में वर्णित समस्या।
यहां ".." का उपयोग करने का एक और उदाहरण दिया गया है:
जबकि (<>) {
मेरा $in_header = 1 .. /^$/;
मेरा $in_body = /^$/ .. eof;
# अब इनमें से चुनें
} जारी रखें {
$. = 0 यदि ईओएफ; # ठीक करें $.
}
कैसे do I मैच एक्सएमएल, एचटीएमएल, or अन्य बुरा, कुरूप चीज़ें साथ में a रेगेक्स?
रेगेक्स का प्रयोग न करें. एक मॉड्यूल का उपयोग करें और नियमित अभिव्यक्तियों के बारे में भूल जाएं।
XML::LibXML, HTML::TokeParser और HTML::TreeBuilder मॉड्यूल अच्छी शुरुआत हैं, हालांकि प्रत्येक
नेमस्पेस में कुछ कार्यों और विभिन्न तरीकों के लिए विशेषीकृत अन्य पार्सिंग मॉड्यूल हैं
किया जा रहा है। सीपीएएन खोज से प्रारंभ करें (http://metacpan.org/> ) और सभी कार्यों पर आश्चर्य
लोग आपके लिए पहले ही कर चुके हैं! :)
I रखना a नियमित अभिव्यक्ति में $/ लेकिन it नहीं था काम। क्या है गलत?
$/ को एक स्ट्रिंग होना चाहिए। यदि आपको वास्तव में ऐसा करने की आवश्यकता है तो आप इन उदाहरणों का उपयोग कर सकते हैं।
यदि आपके पास फ़ाइल::स्ट्रीम है, तो यह आसान है।
फ़ाइल::स्ट्रीम का उपयोग करें;
मेरी $स्ट्रीम = फ़ाइल::स्ट्रीम->नया(
$फ़ाइलहैंडल,
विभाजक => qr/\s*,\s*/,
);
"$_\n" प्रिंट करें जबकि <$स्ट्रीम>;
यदि आपके पास फ़ाइल::स्ट्रीम नहीं है, तो आपको थोड़ा और काम करना होगा।
आप बफ़र में लगातार जोड़ने के लिए sysread के चार-तर्क वाले रूप का उपयोग कर सकते हैं। आप के बाद
बफ़र में जोड़ें, आप जांचें कि क्या आपके पास एक पूरी लाइन है (अपनी नियमित अभिव्यक्ति का उपयोग करके)।
स्थानीय $_ = "";
जबकि (sysread FH, $_, 8192, लंबाई) {
जबकि( s/^((?s).*?)आपका_पैटर्न// ) {
मेरा $रिकॉर्ड = $1;
#यहाँ सामान करो.
}
}
यदि आप सी फ़्लैग और \G एंकर का उपयोग करके फ़ोरैच और मैच के साथ भी यही काम कर सकते हैं
आपको अपनी संपूर्ण फ़ाइल के अंत में स्मृति में रहने पर कोई आपत्ति नहीं है।
स्थानीय $_ = "";
जबकि (sysread FH, $_, 8192, लंबाई) {
मेरे $रिकॉर्ड की खोज करें ( m/\G((?s).*?)your_pattern/gc ) {
#यहाँ सामान करो.
}
सबस्ट्र( $_, 0, स्थिति ) = "" यदि स्थिति;
}
कैसे do I विकल्प केस-असंवेदनशील ढंग से on la एलएचएस जब संरक्षण मामला on la आरएचएस?
यहां लैरी रोस्लर का एक सुंदर पर्लिश समाधान है। यह बिटवाइज एक्सओआर ऑन के गुणों का शोषण करता है
ASCII तार.
$_= "यह एक टीईएसटी मामला है";
$पुराना = 'परीक्षण';
$नया = 'सफलता';
s{(\Q$old\E)}
{ यूसी $नया | (यूसी $1 ^ $1) .
(यूसी(सबस्ट्र $1, -1) ^ सबस्ट्र $1, -1) एक्स
(लंबाई ($नया) - लंबाई $1)
}उदा;
प्रिंट;
और यहाँ यह एक सबरूटीन के रूप में है, जो उपरोक्त के अनुसार तैयार किया गया है:
उप प्रिजर्व_केस {
मेरा ($पुराना, $नया) = @_;
मेरा $मास्क = यूसी $पुराना ^ $पुराना;
यूसी $नया | $मास्क।
सबस्ट्र($मास्क, -1) x (लंबाई($नया) - लंबाई($पुराना))
}
$string = "यह एक TEST मामला है";
$string =~ s/(परीक्षण)/preserve_case($1, "सफलता")/egi;
"$string\n" प्रिंट करें;
यह प्रिंट करता है:
यह एक सफल मामला है
एक विकल्प के रूप में, प्रतिस्थापन शब्द के मामले को रखने के लिए यदि यह से अधिक लंबा है
मूल, आप जेफ पिनयान द्वारा इस कोड का उपयोग कर सकते हैं:
उप प्रिजर्व_केस {
मेरा ($से, $से) = @_;
मेरी ($lf, $lt) = मानचित्र की लंबाई, @_;
अगर ($lt < $lf) { $from = पदार्थ $from, 0, $lt }
अन्यथा { $से .= पदार्थ $से, $lf }
uc $को लौटाएँ | ($से ^ यूसी $से);
}
यह वाक्य को "यह एक सफल मामला है" में बदल देता है।
केवल यह दिखाने के लिए कि यदि आप चाहें तो C प्रोग्रामर किसी भी प्रोग्रामिंग भाषा में C लिख सकते हैं
अधिक सी-जैसे समाधान, निम्न स्क्रिप्ट प्रतिस्थापन को समान मामला बनाती है,
अक्षर दर अक्षर, मूल के रूप में। (यह उससे लगभग 240% धीमी गति से चलता है
पर्लिश समाधान चलता है।) यदि प्रतिस्थापन में स्ट्रिंग की तुलना में अधिक वर्ण हैं
प्रतिस्थापित, अंतिम वर्ण का मामला शेष प्रतिस्थापन के लिए उपयोग किया जाता है।
# नाथन टोर्किंगटन द्वारा मूल, जेफरी फ्राइडल द्वारा मालिश
#
उप संरक्षित_केस
{
मेरा ($पुराना, $नया) = @_;
मेरा $ राज्य = 0; # 0 = कोई परिवर्तन नहीं; 1 = एलसी; 2 = यूसी
मेरा ($i, $oldlen, $newlen, $c) = (0, लंबाई($पुराना), लंबाई($नया));
मेरा $len = $oldlen < $newlen ? $ओल्डलेन : $न्यूलेन;
के लिए ($i = 0; $i < $len; $i++) {
अगर ($c = पदार्थ($पुराना, $i, 1), $c =~ /[\W\d_]/) {
$राज्य = 0;
} एल्सिफ़ (एलसी $सी ईक्यू $सी) {
सबस्ट्र($नया, $i, 1) = एलसी(सबस्ट्र($नया, $i, 1));
$राज्य = 1;
और} {
सबस्ट्र($नया, $i, 1) = uc(substr($नया, $i, 1));
$राज्य = 2;
}
}
# किसी भी शेष नए के साथ समाप्त करें (जब नया पुराने से अधिक लंबा हो)
अगर ($न्यूलेन > $ओल्डलेन) {
अगर ($राज्य == 1) {
सबस्ट्र($नया, $ओल्डलेन) = एलसी(सबस्ट्र($नया, $ओल्डलेन));
} एल्सिफ़ ($राज्य == 2) {
सबस्ट्र($नया, $पुराना) = यूसी(सबस्ट्र($नया, $पुराना));
}
}
वापसी $नया;
}
कैसे कर सकते हैं I बनाना "\w" मैच राष्ट्रीय चरित्र सेट?
"लोकेल का उपयोग करें;" रखें आपकी स्क्रिप्ट में. \w वर्ण वर्ग वर्तमान स्थान से लिया गया है।
विवरण के लिए पर्लोकेल देखें।
कैसे कर सकते हैं I मैच a स्थानीय-स्मार्ट संस्करण of "/[a-zA-Z]/"?
आप perlre में प्रलेखित POSIX कैरेक्टर क्लास सिंटैक्स "/[[:अल्फ़ा:]]/" का उपयोग कर सकते हैं।
इससे कोई फर्क नहीं पड़ता कि आप किस स्थान पर हैं, वर्णमाला वर्ण \w में वर्ण हैं
अंक और अंडरस्कोर के बिना. रेगेक्स के रूप में, यह "/[^\W\d_]/" जैसा दिखता है। इसका
पूरक, गैर-वर्णमाला, फिर अंकों और के साथ \W में सब कुछ है
अंडरस्कोर, या "/[\W\d_]/"।
कैसे कर सकते हैं I उद्धरण a परिवर्तनशील सेवा मेरे उपयोग in a रेगेक्स?
पर्ल पार्सर नियमित अभिव्यक्तियों में $variable और @variable संदर्भों का विस्तार करेगा
जब तक कि सीमांकक एकल उद्धरण न हो। यह भी याद रखें कि a का दाहिना भाग
"एस ///" प्रतिस्थापन को एक डबल-उद्धृत स्ट्रिंग माना जाता है (अधिक विवरण के लिए पर्लोप देखें)।
यह भी याद रखें कि किसी भी रेगेक्स विशेष वर्ण पर तब तक कार्रवाई की जाएगी जब तक कि आप उससे पहले न आएं
\Q के साथ प्रतिस्थापन। यहाँ एक उदाहरण है:
$स्ट्रिंग = "प्लासीडो पी. ऑक्टोपस";
$regex = "पी";
$string =~ s/$regex/Polyp/;
# $स्ट्रिंग अब "पॉलीपेसिडो पी. ऑक्टोपस" है
क्योंकि "।" नियमित अभिव्यक्ति में विशेष है, और किसी भी एकल वर्ण से मेल खा सकता है
रेगेक्स "पी।" यहाँ से मेल खा गया है मूल स्ट्रिंग में.
"।" के विशेष अर्थ से बचने के लिए, हम "\Q" का उपयोग करते हैं:
$स्ट्रिंग = "प्लासीडो पी. ऑक्टोपस";
$regex = "पी";
$string =~ s/\Q$regex/Polyp/;
# $स्ट्रिंग अब "प्लासीडो पॉलीप ऑक्टोपस" है
"\Q" के उपयोग के कारण रेगेक्स में <.> को एक नियमित वर्ण के रूप में माना जाता है, ताकि
"पी।" एक बिंदु के बाद "पी" से मेल खाता है।
क्या is "/ओ" वास्तव में के लिए?
(ब्रायन डी फोय द्वारा योगदान दिया गया)
रेगुलर एक्सप्रेशन के लिए "/o" विकल्प (perlop और perlreref में प्रलेखित) पर्ल को बताता है
रेगुलर एक्सप्रेशन को केवल एक बार संकलित करें। यह केवल तभी उपयोगी है जब पैटर्न में a शामिल हो
चर। यदि पैटर्न नहीं बदलता है तो पर्ल्स 5.6 और बाद के संस्करण इसे स्वचालित रूप से संभालते हैं।
चूँकि मिलान ऑपरेटर "m//", प्रतिस्थापन ऑपरेटर "s///", और नियमित है
अभिव्यक्ति उद्धरण ऑपरेटर "qr //" डबल-कोटिश निर्माण हैं, आप इंटरपोलेट कर सकते हैं
पैटर्न में परिवर्तनशील. "मैं किसी वेरिएबल को उपयोग करने के लिए कैसे उद्धृत कर सकता हूं" का उत्तर देखें
अधिक जानकारी के लिए रेगेक्स?"
यह उदाहरण तर्क सूची से एक नियमित अभिव्यक्ति लेता है और पंक्तियों को प्रिंट करता है
इनपुट जो इससे मेल खाता है:
मेरा $पैटर्न = शिफ्ट @ARGV;
जबकि (<>) {
प्रिंट करें यदि m/$पैटर्न/;
}
5.6 से पहले पर्ल के संस्करण प्रत्येक पुनरावृत्ति के लिए नियमित अभिव्यक्ति को पुन: संकलित करेंगे,
भले ही $पैटर्न नहीं बदला हो। "/o" पर्ल को संकलन करने के लिए कहकर इसे रोकेगा
पहली बार पैटर्न, फिर बाद की पुनरावृत्तियों के लिए उसका पुन: उपयोग करें:
मेरा $पैटर्न = शिफ्ट @ARGV;
जबकि (<>) {
प्रिंट करें यदि m/$पैटर्न/ओ; # पर्ल के लिए उपयोगी <5.6
}
संस्करण 5.6 और बाद में, पर्ल वेरिएबल होने पर नियमित अभिव्यक्ति को पुन: संकलित नहीं करेगा
नहीं बदला है, इसलिए संभवतः आपको "/o" विकल्प की आवश्यकता नहीं है। इससे दर्द तो नहीं होता, लेकिन होता है
या तो मदद नहीं करता. यदि आप रेगुलर एक्सप्रेशन संकलित करने के लिए पर्ल का कोई संस्करण चाहते हैं
केवल एक बार भले ही वेरिएबल बदलता है (इस प्रकार, केवल इसके प्रारंभिक मूल्य का उपयोग करके), आप अभी भी
"/o" की आवश्यकता है.
आप स्वयं सत्यापित करने के लिए कि पर्ल है या नहीं, पर्ल के रेगुलर एक्सप्रेशन इंजन को काम करते हुए देख सकते हैं
नियमित अभिव्यक्ति को पुनः संकलित करना। "यूज़ री 'डीबग'" प्राग्मा (पर्ल 5.005 और के साथ आता है
बाद में) विवरण दिखाता है। 5.6 से पहले पर्ल्स के साथ, आपको "पुनः" रिपोर्ट करते हुए देखना चाहिए कि यह
प्रत्येक पुनरावृत्ति पर नियमित अभिव्यक्ति संकलित करना। पर्ल 5.6 या बाद के संस्करण के साथ, आपको ऐसा करना चाहिए
पहले पुनरावृत्ति के लिए केवल "पुनः" रिपोर्ट देखें।
पुनः 'डीबग' का उपयोग करें;
मेरा $regex = 'पर्ल';
foreach (qw(पर्ल जावा रूबी पायथन)) {
प्रिंट STDERR "-" x 73, "\n";
STDERR प्रिंट करें "$_...\n का प्रयास कर रहा हूँ";
STDERR प्रिंट करें "\t$_ अच्छा है!\n" यदि m/$regex/;
}
कैसे do I उपयोग a नियमित अभिव्यक्ति सेवा मेरे पट्टी सी-शैली टिप्पणियाँ से a फ़ाइल?
हालाँकि यह वास्तव में किया जा सकता है, यह जितना आप सोचते हैं उससे कहीं अधिक कठिन है। उदाहरण के लिए, यह
एक लाइन
perl -0777 -pe 's://\*.*?\*/}{}gs' foo.c
कई मामलों में काम करेगा लेकिन सभी मामलों में नहीं। आप देखिए, यह कुछ विशेष प्रकार के लोगों के लिए बहुत सरल है
सी प्रोग्राम, विशेष रूप से, वे जो उद्धृत स्ट्रिंग्स में टिप्पणियाँ प्रतीत होते हैं। के लिए
कि, आपको कुछ इस तरह की आवश्यकता होगी, जिसे जेफरी फ्रिडल द्वारा बनाया गया और बाद में फ्रेड द्वारा संशोधित किया गया
कर्टिस।
$/ = अपरिभाषित;
$_ = <>;
s#/\*[^*]*\*+([^/*][^*]*\*+)*/|("(\\.|[^"\\])*"|'( \\.|[^'\\])*'|.[^/''\\]*)#परिभाषित $2? $2 : ""#gse;
प्रिंट;
निःसंदेह, इसे "/x" संशोधक के साथ रिक्त स्थान जोड़कर अधिक स्पष्ट रूप से लिखा जा सकता है
और टिप्पणियाँ. यहां फ्रेड कर्टिस के सौजन्य से इसका विस्तार किया गया है।
s{
/\* ## का प्रारंभ /* ... */ टिप्पणी
[^*]*\*+ ## गैर-* के बाद 1-या-अधिक * का
(
[^/*][^*]*\*+
)* ## 0-या-अधिक चीजें जो / से शुरू नहीं होतीं
## लेकिन अंत '*' से करें
/ ## का अंत /* ... */ टिप्पणी
| ## या विभिन्न चीज़ें जो टिप्पणियाँ नहीं हैं:
(
" ## "..." स्ट्रिंग की शुरुआत
(
\\. ## भाग गया चार
| ## या
[^"\\] ## गैर "
)*
" ## "..." स्ट्रिंग का अंत
| ## या
' ## '...' स्ट्रिंग की शुरुआत
(
\\. ## भाग गया चार
| ## या
[^'\\] ## गैर '
)*
' ## '...' स्ट्रिंग का अंत
| ## या
. ## कुछ भी अन्य चार
[^/"'\\]* ## वर्ण जो कोई टिप्पणी, स्ट्रिंग या एस्केप प्रारंभ नहीं करते हैं
)
}{परिभाषित $2? $2 : ""}gxse;
एक मामूली संशोधन भी C++ टिप्पणियों को हटा देता है, संभवतः a का उपयोग करके कई पंक्तियों को फैलाता है
निरंतरता चरित्र:
s#/\*[^*]*\*+([^/*][^*]*\*+)*/|//([^\\]|[^\n][\n]? )*?\n|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*) #परिभाषित $3? $3 : ""#gse;
कर सकते हैं I उपयोग पर्ल नियमित भाव सेवा मेरे मैच संतुलित मूलपाठ?
(ब्रायन डी फोय द्वारा योगदान दिया गया)
आपका पहला प्रयास संभवतः टेक्स्ट::बैलेंस्ड मॉड्यूल होना चाहिए, जो पर्ल मानक में है
पर्ल 5.8 से लाइब्रेरी। इसमें पेचीदा पाठ से निपटने के लिए विभिन्न प्रकार के कार्य हैं।
रेगएक्सपी::कॉमन मॉड्यूल आपके द्वारा उपयोग किए जा सकने वाले डिब्बाबंद पैटर्न प्रदान करके भी मदद कर सकता है।
पर्ल 5.10 के अनुसार, आप पुनरावर्ती का उपयोग करके नियमित अभिव्यक्तियों के साथ संतुलित पाठ का मिलान कर सकते हैं
पैटर्न. पर्ल 5.10 से पहले, आपको विभिन्न तरकीबों का सहारा लेना पड़ता था जैसे कि पर्ल कोड का उपयोग करना
"(??{})" क्रम।
यहां पुनरावर्ती नियमित अभिव्यक्ति का उपयोग करने वाला एक उदाहरण दिया गया है। लक्ष्य सभी पर कब्ज़ा करना है
कोण कोष्ठक के भीतर का पाठ, जिसमें नेस्टेड कोण कोष्ठक का पाठ भी शामिल है। यह नमूना पाठ
इसके दो "प्रमुख" समूह हैं: एक समूह जिसमें घोंसला बनाने का एक स्तर होता है और एक समूह जिसमें दो स्तर होते हैं
घोंसला बनाना। कोण कोष्ठक में कुल पाँच समूह हैं:
मेरे पास कुछ > और
> >
और बस।
संतुलित पाठ से मिलान करने के लिए रेगुलर एक्सप्रेशन दो नए (पर्ल 5.10 तक) रेगुलर का उपयोग करता है
अभिव्यक्ति की विशेषताएं. ये perlre में शामिल हैं और यह उदाहरण इसका एक संशोधित संस्करण है
उस दस्तावेज़ में एक.
सबसे पहले, किसी भी क्वांटिफायर में नया स्वामित्व "+" जोड़ने से सबसे लंबा मिलान मिलता है और ऐसा होता है
पीछे नहीं हटना. यह महत्वपूर्ण है क्योंकि आप इसके माध्यम से किसी भी कोण कोष्ठक को संभालना चाहते हैं
प्रत्यावर्तन, पीछे नहीं हटना। समूह "[^<>]++" को एक या अधिक गैर-कोण कोष्ठक मिलते हैं
बिना पीछे हटे.
दूसरा, नया "(?PARNO)" दिए गए विशेष कैप्चर समूह में उप-पैटर्न को संदर्भित करता है
"पारनो" द्वारा. निम्नलिखित रेगेक्स में, पहला कैप्चर समूह पाता है (और याद रखता है)।
संतुलित पाठ, और इससे आगे निकलने के लिए आपको पहले बफ़र के भीतर उसी पैटर्न की आवश्यकता है
नेस्टेड पाठ. वह पुनरावर्ती भाग है. "(?1)" बाहरी कैप्चर में पैटर्न का उपयोग करता है
रेगेक्स के एक स्वतंत्र भाग के रूप में समूह।
यह सब एक साथ रखने पर, आपके पास है:
#!/usr/local/bin/perl5.10.0
मेरी $string =<<"यहाँ";
मेरे पास कुछ > और
> >
और बस।
यहाँ
मेरे @समूह = $स्ट्रिंग =~एम/
( # कैप्चर ग्रुप 1 की शुरुआत
< # एक उद्घाटन कोण ब्रैकेट से मिलान करें
(?:
[^<>]++ # एक या अधिक गैर कोण कोष्ठक, गैर बैकट्रैकिंग
|
(?1) # पाया गया < या >, इसलिए समूह 1 को पकड़ने के लिए पुनः प्रयास करें
)*
> # क्लोजिंग एंगल ब्रैकेट से मिलान करें
) # कैप्चर ग्रुप 1 का अंत
/xg;
$" = "\n\t";
प्रिंट करें "मिला:\n\t@groups\n";
आउटपुट से पता चलता है कि पर्ल को दो प्रमुख समूह मिले:
मिल गया:
>
> >
थोड़े से अतिरिक्त काम से, आप सभी समूहों को कोण कोष्ठक में पा सकते हैं, भले ही वे हों
अन्य कोण कोष्ठकों में भी. हर बार जब आपको एक संतुलित माचिस मिले, तो उसका बाहरी हिस्सा हटा दें
डिलीमिटर (यह वही है जिसका आपने अभी मिलान किया है इसलिए इसे दोबारा मिलान न करें) और इसे एक कतार में जोड़ें
संसाधित करने के लिए स्ट्रिंग्स की. ऐसा तब तक करते रहें जब तक आपको कोई मिलान न मिल जाए:
#!/usr/local/bin/perl5.10.0
मेरी @कतार =<<"यहाँ";
मेरे पास कुछ > और
> >
और बस।
यहाँ
मेरा $regex = qr/
(# ब्रैकेट 1 की शुरुआत
< # एक उद्घाटन कोण ब्रैकेट से मिलान करें
(?:
[^<>]++ # एक या अधिक गैर कोण कोष्ठक, गैर बैकट्रैकिंग
|
(?1) # कोष्ठक 1 पर पुनः जाएँ
)*
> # क्लोजिंग एंगल ब्रैकेट से मिलान करें
) # ब्रैकेट का अंत 1
/एक्स;
$" = "\n\t";
जबकि(@कतार) {
मेरी $स्ट्रिंग = शिफ्ट @कतार;
मेरे @groups = $string =~ m/$regex/g;
प्रिंट करें "मिला:\n\t@groups\n\n" यदि @groups;
@कतार को अनशिफ्ट करें, मानचित्र { s/^ $//; $_ } @समूह;
}
आउटपुट सभी समूहों को दिखाता है। सबसे बाहरी मिलान पहले और नेस्टेड दिखाई देते हैं
मैच बाद में दिखाई देते हैं:
मिल गया:
>
> >
मिल गया:
मिल गया:
>
मिल गया:
क्या कर देता है it मतलब कि regexes रहे लालची? कैसे कर सकते हैं I मिल चारों ओर यह?
ज्यादातर लोगों का मतलब है कि लालची रेगेक्स जितना हो सके उतना मेल खाते हैं। तकनीकी रूप से बोल रहा हूं,
यह वास्तव में क्वांटिफायर ("?", "*", "+", "{}") हैं जो संपूर्ण के बजाय लालची हैं
नमूना; पर्ल समग्र लालच के बजाय स्थानीय लालच और तत्काल संतुष्टि को प्राथमिकता देता है। पाने के
समान क्वांटिफायर के गैर-लालची संस्करण, ("??", "*?", "+?", "{}?") का उपयोग करें।
एक उदाहरण:
मेरा $s1 = मेरा $s2 = "मुझे बहुत ठंड लग रही है";
$s1 =~ s/ve.*y //; # मुझे ठंड लग रही है
$s2 =~ s/ve.*?y //; # मैं बहुत ठंडी हूँ
ध्यान दें कि कैसे दूसरा प्रतिस्थापन "y" का सामना करते ही मेल खाना बंद कर देता है।
"*?" क्वांटिफायर प्रभावी ढंग से रेगुलर एक्सप्रेशन इंजन को जल्द से जल्द एक मैच खोजने के लिए कहता है
जितना संभव हो सके और अगली पंक्ति में जो कुछ भी हो उस पर नियंत्रण रखें, जैसा कि यदि आप होते तो करते
गरम आलू बजाना.
कैसे do I प्रक्रिया से प्रत्येक शब्द on से प्रत्येक रेखा?
स्प्लिट फ़ंक्शन का उपयोग करें:
जबकि (<>) {
मेरे $ शब्द को फ़ोरैच करें (विभाजित करें) {
# यहां $word के साथ कुछ करें
}
}
ध्यान दें कि यह वास्तव में अंग्रेजी अर्थ में एक शब्द नहीं है; यह क्रमागत टुकड़े मात्र हैं
गैर-व्हाट्सएप वर्ण.
केवल अल्फ़ान्यूमेरिक अनुक्रमों (अंडरस्कोर सहित) के साथ काम करने के लिए, आप इस पर विचार कर सकते हैं
जबकि (<>) {
foreach $शब्द (m/(\w+)/g) {
# यहां $word के साथ कुछ करें
}
}
कैसे कर सकते हैं I छाप आउट a शब्द-आवृत्ति or रेखा आवृत्ति सारांश?
ऐसा करने के लिए, आपको इनपुट स्ट्रीम में प्रत्येक शब्द को पार्स करना होगा। हम ऐसा दिखावा करेंगे
जिस शब्द से आपका तात्पर्य गैर-शब्दों के बजाय वर्णमाला, हाइफ़न या एपोस्ट्रोफ़ के समूह से है
पिछले प्रश्न में दिए गए एक शब्द का व्हाइटस्पेस खंड विचार:
मेरा (%देखा);
जबकि (<>) {
जबकि ( /(\b[^\W_\d][\w'-]+\b)/g ) { # "`भेड़'' छूट गया
$देखा{$1}++;
}
}
जबकि (मेरा ($ शब्द, $ गिनती) = प्रत्येक % देखा गया) {
प्रिंट करें "$गिनती $शब्द\n";
}
यदि आप पंक्तियों के लिए वही काम करना चाहते हैं, तो आपको नियमित अभिव्यक्ति की आवश्यकता नहीं होगी:
मेरा (%देखा);
जबकि (<>) {
$देखा गया{$_}++;
}
जबकि (मेरी ($ पंक्ति, $ गिनती) = प्रत्येक % देखा गया) {
"$गिनती $लाइन" प्रिंट करें;
}
यदि आप इन आउटपुट को क्रमबद्ध क्रम में चाहते हैं, तो perlfaq4 देखें: "मैं हैश को कैसे क्रमबद्ध करूं
(वैकल्पिक रूप से कुंजी के बजाय मूल्य से)?"।
कैसे कर सकते हैं I do अनुमानित मेल मिलाना?
सीपीएएन से उपलब्ध मॉड्यूल स्ट्रिंग::लगभग देखें।
कैसे do I कुशलता मैच बहुत नियमित भाव at एक बार?
(ब्रायन डी फोय द्वारा योगदान दिया गया)
यदि आपके पास पर्ल 5.10 या बाद का संस्करण है, तो यह लगभग मामूली बात है। आप बस एक के खिलाफ चतुराई से मेल खाते हैं
नियमित अभिव्यक्ति वस्तुओं की सरणी:
मेरा @पैटर्न = (qr/Fr.d/, qr/B.rn.y/, qr/W.lm./);
यदि ($स्ट्रिंग ~~@पैटर्न) {
...
};
स्मार्ट मैच तब रुक जाता है जब उसे कोई मैच मिल जाता है, इसलिए उसे हर अभिव्यक्ति को आज़माना नहीं पड़ता है।
पर्ल 5.10 से पहले, आपको थोड़ा सा काम करना है। आप संकलन करने से बचना चाहते हैं
हर बार जब आप इसका मिलान करना चाहें तो नियमित अभिव्यक्ति। इस उदाहरण में, पर्ल को पुनः संकलित करना होगा
"foreach" लूप के प्रत्येक पुनरावृत्ति के लिए नियमित अभिव्यक्ति क्योंकि इसका कोई रास्ता नहीं है
जानिए $पैटर्न क्या होगा:
मेरा @पैटर्न = qw(फू बार बाज़);
लाइन: जबकि( ) {
foreach $पैटर्न (@पैटर्न) {
यदि( /\b$पैटर्न\b/i ) {
प्रिंट;
अगली पंक्ति;
}
}
}
"qr//" ऑपरेटर पर्ल 5.005 में दिखाई दिया। यह एक नियमित अभिव्यक्ति संकलित करता है, लेकिन नहीं करता है
इसे लागाएं। जब आप रेगेक्स के पूर्व-संकलित संस्करण का उपयोग करते हैं, तो पर्ल कम काम करता है। इस में
उदाहरण के लिए, मैंने प्रत्येक पैटर्न को उसके पूर्व-संकलित रूप में बदलने के लिए एक "मानचित्र" डाला। के बाकी
स्क्रिप्ट वही है, लेकिन तेज़ है:
मेरा @पैटर्न = मानचित्र { qr/\b$_\b/i } qw( foo bar baz );
लाइन: जबकि( <> ) {
foreach $पैटर्न (@पैटर्न) {
यदि( /$पैटर्न/ ) {
प्रिंट;
अगली पंक्ति;
}
}
}
कुछ मामलों में, आप कई पैटर्न को एक ही रेगुलर एक्सप्रेशन में बनाने में सक्षम हो सकते हैं।
हालाँकि उन स्थितियों से सावधान रहें जिनमें पीछे हटने की आवश्यकता होती है।
मेरा $regex = '|', qw(foo bar baz ); से जुड़ें;
लाइन: जबकि( <> ) {
प्रिंट करें यदि /\b(?:$regex)\b/i;
}
रेगुलर एक्सप्रेशन दक्षता पर अधिक विवरण के लिए देखें माहिर नियमित एक्सप्रेशंस by
जेफरी फ्रीडल. वह बताते हैं कि रेगुलर एक्सप्रेशन इंजन कैसे काम करता है और कुछ पैटर्न क्यों
आश्चर्यजनक रूप से अक्षम हैं. एक बार जब आप समझ जाएं कि पर्ल रेगुलर एक्सप्रेशन कैसे लागू करता है,
आप उन्हें व्यक्तिगत स्थितियों के लिए ट्यून कर सकते हैं।
क्यों नहीं है शब्द-सीमा खोजें साथ में "\बी" काम एसटी मुझे?
(ब्रायन डी फोय द्वारा योगदान दिया गया)
सुनिश्चित करें कि आप जानते हैं कि \b वास्तव में क्या करता है: यह एक शब्द वर्ण के बीच की सीमा है, \w,
और कुछ ऐसा जो शब्द-चरित्र नहीं है। वह चीज़ जो शब्द-चरित्र नहीं है, हो सकती है
\W, लेकिन यह स्ट्रिंग का आरंभ या अंत भी हो सकता है।
यह व्हाईटस्पेस और गैर-व्हाइटस्पेस के बीच की सीमा नहीं है (नहीं!), और यह सामान नहीं है
शब्दों के बीच का उपयोग हम वाक्य बनाने के लिए करते हैं।
रेगेक्स स्पीक में, एक शब्द सीमा (\b) एक "शून्य चौड़ाई का दावा" है, जिसका अर्थ है कि यह नहीं है
स्ट्रिंग में एक वर्ण का प्रतिनिधित्व करें, लेकिन एक निश्चित स्थिति पर एक शर्त का प्रतिनिधित्व करें।
रेगुलर एक्सप्रेशन, /\bPerl\b/ के लिए, "P" से पहले एक शब्द सीमा होनी चाहिए और
"एल" के बाद. जब तक किसी शब्द वर्ण के अलावा कुछ और "पी" से पहले आता है और
"एल" के बाद पैटर्न मेल खाएगा। ये तार /\bPerl\b/ से मेल खाते हैं।
"पर्ल" # P से पहले या l के बाद कोई शब्द char नहीं
"पर्ल" # पिछले जैसा ही (स्पेस एक शब्द वर्ण नहीं है)
"'पर्ल'" # 'चार' एक शब्द चार नहीं है
"पर्ल का" # P से पहले कोई शब्द char नहीं, "l" के बाद गैर-शब्द char
ये तार /\bPerl\b/ से मेल नहीं खाते।
"पर्ल_" # _ एक शब्द चार है!
"पर्लर" # पी से पहले कोई शब्द नहीं, लेकिन एल के बाद एक
हालाँकि आपको शब्दों का मिलान करने के लिए \b का उपयोग करने की आवश्यकता नहीं है। आप गैर-शब्द वर्णों की तलाश कर सकते हैं
शब्द वर्णों से घिरा हुआ। ये तार पैटर्न /\b'\b/ से मेल खाते हैं।
"मत करो" # 'चार' "एन" और "टी" से घिरा हुआ है
"qep'a'" # 'चार' "पी" और "ए" से घिरा हुआ है
ये तार /\b'\b/ से मेल नहीं खाते।
"foo'" # गैर-शब्द के बाद कोई शब्द char नहीं है'
यह निर्दिष्ट करने के लिए कि कोई शब्द नहीं होना चाहिए, आप \b, \B के पूरक का भी उपयोग कर सकते हैं
सीमा।
पैटर्न /\Bam\B/ में, "ए" से पहले और "एम" के बाद एक शब्द वर्ण होना चाहिए।
ये पैटर्न /\Bam\B/ से मेल खाते हैं:
"लामा" # "हूँ" शब्द वर्णों से घिरा हुआ
"सैमुअल" # वही
ये तार /\Bam\B/ से मेल नहीं खाते
"सैम" # "ए" से पहले कोई शब्द सीमा नहीं, लेकिन "एम" के बाद एक
"मैं सैम हूँ" # "हूँ" गैर-शब्द वर्णों से घिरा हुआ है
क्यों कर देता है का उपयोग $&, $`, or $' धीमा my कार्यक्रम नीचे?
(एनो सीगल द्वारा योगदान)
एक बार जब पर्ल देखता है कि आपको प्रोग्राम में कहीं भी इनमें से किसी एक वेरिएबल की आवश्यकता है, तो वह प्रदान करता है
वे प्रत्येक पैटर्न पर मेल खाते हैं। इसका मतलब है कि हर पैटर्न पर संपूर्ण मेल खाता है
स्ट्रिंग की प्रतिलिपि बनाई जाएगी, इसका एक भाग $` में, कुछ भाग $& में, और कुछ भाग $' में। इस प्रकार है जुर्माना
लंबे तारों और पैटर्न के साथ सबसे गंभीर जो अक्सर मेल खाते हैं। यदि आप $&, $', और $` से बचें
कर सकते हैं, लेकिन यदि आप नहीं कर सकते हैं, तो एक बार जब आप उनका उपयोग कर लें, तो उन्हें अपनी इच्छानुसार उपयोग करें क्योंकि आप ऐसा कर चुके हैं
पहले ही कीमत चुका दी है. याद रखें कि कुछ एल्गोरिदम वास्तव में उनकी सराहना करते हैं। के रूप में
5.005 रिलीज़, $& वैरिएबल अब अन्य दो की तरह "महंगा" नहीं है।
पर्ल 5.6.1 के बाद से विशेष चर @- और @+ कार्यात्मक रूप से $`, $& और $' को प्रतिस्थापित कर सकते हैं।
इन सरणियों में प्रत्येक मैच की शुरुआत और अंत के लिए संकेतक होते हैं (इसके लिए पर्लवर देखें)।
पूरी कहानी), इसलिए वे आपको मूलतः वही जानकारी देते हैं, लेकिन जोखिम के बिना
अत्यधिक स्ट्रिंग प्रतिलिपि.
पर्ल 5.10 ने ऐसा करने के लिए तीन विशेष, "${^MATCH}", "${^PREMATCH}", और "${^POSTMATCH}" जोड़े।
समान कार्य लेकिन वैश्विक प्रदर्शन दंड के बिना। पर्ल 5.10 केवल इन वेरिएबल्स को सेट करता है
यदि आप "/p" संशोधक के साथ नियमित अभिव्यक्ति संकलित या निष्पादित करते हैं।
क्या अच्छा is "\जी" in a नियमित अभिव्यक्ति?
आप अगला मैच उसी स्ट्रिंग पर शुरू करने के लिए "\G" एंकर का उपयोग करते हैं जहां पिछला मैच था
छोड़ दिया। रेगुलर एक्सप्रेशन इंजन अगले अक्षर को खोजने के लिए किसी भी अक्षर को नहीं छोड़ सकता
इस एंकर से मेल खाता है, इसलिए "\G" स्ट्रिंग एंकर की शुरुआत, "^" के समान है।
"\G" एंकर का उपयोग आमतौर पर "g" ध्वज के साथ किया जाता है। यह "pos()" के मान का उपयोग करता है
अगला मैच शुरू करने की स्थिति। चूंकि मैच ऑपरेटर क्रमिक मिलान करता है, यह
पिछले मैच (या पहले) के बाद अगले कैरेक्टर की स्थिति के साथ "pos()" को अपडेट करता है
अगले मैच का चरित्र, इस पर निर्भर करता है कि आप इसे कैसे देखना पसंद करते हैं)। प्रत्येक स्ट्रिंग का अपना है
स्वयं का "pos()" मान।
मान लीजिए कि आप "1122a44" जैसी स्ट्रिंग में अंकों के सभी लगातार जोड़े का मिलान करना चाहते हैं
और जब आपका सामना गैर-अंकों से हो तो मिलान बंद कर दें। आप 11 और 22 का मिलान करना चाहते हैं लेकिन
अक्षर 22 और 44 के बीच दिखाई देता है और आप "ए" पर रुकना चाहते हैं। बस जोड़े मिला रहे हैं
अंकों की संख्या "ए" से ऊपर चली जाती है और फिर भी 44 से मेल खाती है।
$_ = "1122a44";
मेरे @जोड़े = m/(\d\d)/g; #qw(11 22 44 )
यदि आप "\G" एंकर का उपयोग करते हैं, तो आप 22 के बाद के मैच को "ए" से शुरू करने के लिए बाध्य करते हैं।
रेगुलर एक्सप्रेशन वहां मेल नहीं खा सकता क्योंकि इसमें कोई अंक नहीं मिलता, इसलिए अगला मैच होता है
विफल हो जाता है और मिलान ऑपरेटर पहले से पाए गए जोड़े लौटा देता है।
$_ = "1122a44";
मेरे @जोड़े = m/\G(\d\d)/g; #qw(11 22 )
आप अदिश संदर्भ में "\G" एंकर का भी उपयोग कर सकते हैं। आपको अभी भी "जी" ध्वज की आवश्यकता है।
$_ = "1122a44";
जबकि( m/\G(\d\d)/g ) {
प्रिंट करें "$1 मिला\n";
}
मैच "a" अक्षर पर विफल होने के बाद, पर्ल "pos()" को रीसेट करता है और अगला मैच अक्षर पर रीसेट करता है
शुरुआत में वही स्ट्रिंग शुरू होती है।
$_ = "1122a44";
जबकि( m/\G(\d\d)/g ) {
प्रिंट करें "$1 मिला\n";
}
यदि m/(\d\d)/g; तो "थोड़ी देर बाद $1 मिला" प्रिंट करें; # "11" ढूँढता है
आप "सी" ध्वज के साथ विफल होने पर "पॉस ()" रीसेट को अक्षम कर सकते हैं, जिसे पर्लोप में प्रलेखित किया गया है
perlreref. बाद के मैच वहीं से शुरू होते हैं जहां पिछला सफल मैच समाप्त हुआ था (का मान)।
"pos()") भले ही इस बीच उसी स्ट्रिंग पर कोई मिलान विफल हो गया हो। इस मामले में,
"जबकि ()" लूप के बाद मैच "ए" (जहां आखिरी मैच रुका था) पर शुरू होता है, और तब से
यह किसी भी एंकर का उपयोग नहीं करता है, यह 44 खोजने के लिए "ए" को छोड़ सकता है।
$_ = "1122a44";
जबकि( m/\G(\d\d)/gc ) {
प्रिंट करें "$1 मिला\n";
}
यदि m/(\d\d)/g; तो "थोड़ी देर बाद $1 मिला" प्रिंट करें; # "44" ढूँढता है
आमतौर पर जब आप कोई भिन्न मिलान आज़माना चाहते हैं तो आप "सी" ध्वज के साथ "\G" एंकर का उपयोग करते हैं
यदि कोई विफल हो जाता है, जैसे कि टोकनाइज़र में। जेफ़री फ़्रीडल यह उदाहरण प्रस्तुत करता है जो काम करता है
5.004 या बाद में।
जबकि (<>) {
चॉम्प;
पार्सर: {
m/ \G( \d+\b )/gcx && do { print "number: $1\n"; पुनः करना; };
m/ \G( \w+ )/gcx && do { print "word: $1\n"; पुनः करना; };
m/ \G( \s+ )/gcx && do { print "space: $1\n"; पुनः करना; };
m/ \G( [^\w\d]+ )/gcx && do { print "other: $1\n"; पुनः करना; };
}
}
प्रत्येक पंक्ति के लिए, "PARSER" लूप पहले अंकों की एक श्रृंखला से मिलान करने का प्रयास करता है, उसके बाद a
शब्द सीमा. यह मैच वहीं से शुरू होना चाहिए जहां पिछला मैच खत्म हुआ था (या
पहले मैच में स्ट्रिंग की शुरुआत)। चूँकि "m/ \G( \d+\b )/gcx" "c" ध्वज का उपयोग करता है,
यदि स्ट्रिंग उस नियमित अभिव्यक्ति से मेल नहीं खाती है, तो पर्ल रीसेट नहीं होता है स्थिति () और
एक अलग पैटर्न आज़माने के लिए अगला मैच उसी स्थिति में शुरू होता है।
रहे पर्ल regexes डीएफए or एनएफए? रहे वे POSIX आज्ञाकारी?
हालांकि यह सच है कि पर्ल के रेगुलर एक्सप्रेशन डीएफए (नियतात्मक परिमित) से मिलते जुलते हैं
ऑटोमेटा) का उदा(1) कार्यक्रम, वे वास्तव में एनएफए (गैर-नियतात्मक) के रूप में कार्यान्वित किए जाते हैं
परिमित ऑटोमेटा) बैकट्रैकिंग और बैकरेफ़रिंग की अनुमति देने के लिए। और वे POSIX-शैली नहीं हैं
या तो, क्योंकि वे सभी मामलों के लिए सबसे खराब स्थिति वाले व्यवहार की गारंटी देते हैं। (ऐसा लगता है कि कुछ
लोग निरंतरता की गारंटी पसंद करते हैं, तब भी जब गारंटी धीमी गति की होती है।) देखें
सभी विवरणों के लिए जेफरी फ्रीडल की पुस्तक "मास्टरिंग रेगुलर एक्सप्रेशंस" (ओ'रेली से)।
आप कभी भी इन मामलों पर जानने की उम्मीद कर सकते हैं (पूर्ण उद्धरण perlfaq2 में दिखाई देता है)।
क्या है गलतियों को सुधारने साथ में का उपयोग ग्रेप in a शून्य प्रसंग?
समस्या यह है कि संदर्भ की परवाह किए बिना, grep एक रिटर्न सूची बनाता है। इसका मतलब यह है
आप पर्ल को एक ऐसी सूची बनाने की परेशानी में डाल रहे हैं जिसे आप फेंक देते हैं। अगर
सूची बड़ी है, आप समय और स्थान दोनों बर्बाद करते हैं। यदि आपका इरादा इसे दोहराने का है
सूची बनाएं, फिर इस उद्देश्य के लिए फॉर लूप का उपयोग करें।
5.8.1 से पुराने पर्ल्स में, मानचित्र भी इस समस्या से ग्रस्त है। लेकिन 5.8.1 के बाद से, यह
ठीक कर दिया गया है, और मानचित्र संदर्भ से अवगत है - शून्य संदर्भ में, कोई सूची नहीं बनाई जाती है।
कैसे कर सकते हैं I मैच तार साथ में मल्टीबाइट वर्ण?
पर्ल 5.6 से शुरू करके पर्ल को कुछ स्तर का मल्टीबाइट कैरेक्टर सपोर्ट मिला है। पर्ल 5.8 या
बाद में अनुशंसित है. समर्थित मल्टीबाइट कैरेक्टर प्रदर्शनों की सूची में यूनिकोड, और शामिल हैं
एनकोड मॉड्यूल के माध्यम से विरासत एन्कोडिंग। Perluniintro, perlunicode और Encode देखें।
यदि आप पुराने पर्ल्स में फंस गए हैं, तो आप यूनिकोड::स्ट्रिंग मॉड्यूल के साथ यूनिकोड कर सकते हैं, और
यूनिकोड::मैप8 और यूनिकोड::मैप मॉड्यूल का उपयोग करके वर्ण रूपांतरण। यदि आप उपयोग कर रहे हैं
जापानी एन्कोडिंग, आप jperl 5.005_03 का उपयोग करने का प्रयास कर सकते हैं।
अंत में, दृष्टिकोणों का निम्नलिखित सेट जेफरी फ्रिडल द्वारा प्रस्तुत किया गया था, जिसका लेख इसमें है
पर्ल जर्नल का अंक #5 इसी विषय पर बात करता है।
मान लीजिए कि आपके पास कुछ अजीब मार्टियन एन्कोडिंग है जहां ASCII अपरकेस अक्षरों के जोड़े हैं
एकल मंगल ग्रह के अक्षरों को एनकोड करें (यानी दो बाइट्स "सीवी" एक एकल मंगल ग्रह के अक्षर को बनाते हैं, जैसा कि करते हैं
दो बाइट्स "एसजी", "वीएस", "एक्सएक्स", आदि)। अन्य बाइट्स एकल वर्णों का प्रतिनिधित्व करते हैं, ठीक वैसे ही जैसे
एएससीआईआई।
तो, मार्टियन की स्ट्रिंग "मैं CVSGXX हूँ!" नौ अक्षर 'I' को एन्कोड करने के लिए 12 बाइट्स का उपयोग करता है,
'', 'ए', 'एम', '', 'सीवी', 'एसजी', 'एक्सएक्स', '!'।
अब, मान लीजिए कि आप एकल वर्ण "/GX/" खोजना चाहते हैं। पर्ल को इसके बारे में पता नहीं है
मंगल ग्रह का निवासी, तो यह "मैं CVSGXX हूँ!" में दो बाइट्स "GX" ढूंढेगा। स्ट्रिंग, भले ही वह
चरित्र वहां नहीं है: ऐसा लगता है कि ऐसा इसलिए है क्योंकि "एसजी" "एक्सएक्स" के बगल में है, लेकिन वहां है
कोई वास्तविक "जीएक्स" नहीं। यह बहुत बड़ी समस्या है।
इससे निपटने के लिए यहां कुछ तरीके दिए गए हैं, जो सभी दर्दनाक हैं:
# सुनिश्चित करें कि आसन्न "मार्टियन" बाइट्स अब आसन्न नहीं हैं।
$मार्टियन =~ s/([AZ][AZ])/ $1 /g;
"मिल गया GX!\n" प्रिंट करें यदि $martian =~ /GX/;
या इस तरह:
मेरे @chars = $martian =~ m/([AZ][AZ]|[^AZ])/g;
# उपरोक्त अवधारणात्मक रूप से समान है: my @chars = $text =~ m/(.)/g;
#
मेरे $char (@chars) को फ़ोरैच करें {
"मिल गया GX!\n" प्रिंट करें, अंतिम यदि $char eq 'GX';
}
या इस तरह:
जबकि ($मार्टियन =~ m/\G([AZ][AZ]|.)/gs) { # \G शायद अनावश्यक है
यदि ($1 eq 'GX') {
प्रिंट करें "जीएक्स मिला!\n";
अंतिम;
}
}
यहां बेंजामिन गोल्डबर्ग का एक और, थोड़ा कम दर्दनाक तरीका है, जो इसका उपयोग करता है
शून्य-चौड़ाई नकारात्मक लुक-बैक दावा।
"मिल गया GX!\n" प्रिंट करें यदि $मार्टियन =~ मी/
(?
(?:[AZ][AZ])*?
GX
/एक्स;
यह सफल होता है यदि "मार्टियन" वर्ण GX स्ट्रिंग में है, और अन्यथा विफल हो जाता है। अगर आप
(?) का उपयोग करना पसंद नहीं है
(?
इसमें $-[0] और $+[0] में गलत चीज़ डालने की कमी है, लेकिन यह आमतौर पर होता है
आसपास काम किया जा सकता है.
कैसे do I मैच a नियमित अभिव्यक्ति है कि in a चर?
(ब्रायन डी फोय द्वारा योगदान दिया गया)
हमें मैच ऑपरेटर (या कुछ और जो काम करता है) में पैटर्न को हार्ड-कोड करने की ज़रूरत नहीं है
नियमित अभिव्यक्तियों के साथ)। हम बाद में उपयोग के लिए पैटर्न को एक वेरिएबल में रख सकते हैं।
मिलान ऑपरेटर एक दोहरा उद्धरण संदर्भ है, इसलिए आप अपने वेरिएबल को आसानी से प्रक्षेपित कर सकते हैं
एक दोहरी उद्धृत स्ट्रिंग की तरह। इस मामले में, आप रेगुलर एक्सप्रेशन को उपयोगकर्ता इनपुट के रूप में पढ़ते हैं
और इसे $regex में संग्रहीत करें। एक बार जब आपके पास $regex में पैटर्न आ जाता है, तो आप उस वेरिएबल का उपयोग करते हैं
मिलान संचालक.
chomp(मेरा $regex= );
अगर ($स्ट्रिंग =~ एम/$रेगेक्स/ ) { ... }
$regex में कोई भी नियमित अभिव्यक्ति विशेष वर्ण अभी भी विशेष हैं, और पैटर्न
अभी भी वैध होना होगा अन्यथा पर्ल शिकायत करेगा। उदाहरण के लिए, इस पैटर्न में एक है
अयुग्मित कोष्ठक.
मेरा $regex = "बेजोड़ (paren");
"उन सभी को बांधने के लिए दो माता-पिता" =~ m/$regex/;
जब पर्ल रेगुलर एक्सप्रेशन संकलित करता है, तो यह कोष्ठक को a की शुरुआत के रूप में मानता है
स्मृति मिलान. जब उसे समापन कोष्ठक नहीं मिलता, तो वह शिकायत करता है:
बेजोड़ (रेगेक्स में; <-- HERE में m/Unmatched द्वारा चिह्नित ( <-- HERE Paren/ स्क्रिप्ट लाइन 3 पर।
आप हमारी स्थिति के आधार पर कई तरीकों से इससे निजात पा सकते हैं। सबसे पहले, यदि आप नहीं करते हैं
यदि आप चाहते हैं कि स्ट्रिंग में कोई भी पात्र विशेष हो, तो आप उनसे बच सकते हैं
स्ट्रिंग का उपयोग करने से पहले "कोटमेटा"।
chomp(मेरा $regex= );
$regex = quotemeta( $regex );
अगर ($स्ट्रिंग =~ एम/$रेगेक्स/ ) { ... }
आप इसे "\Q" और "\E" अनुक्रमों का उपयोग करके सीधे मिलान ऑपरेटर में भी कर सकते हैं।
"\Q" पर्ल को बताता है कि विशेष वर्णों से बचना कहाँ से शुरू करना है, और "\E" बताता है कि कहाँ से बचना है
रुकें (अधिक जानकारी के लिए पर्लोप देखें)।
chomp(मेरा $regex= );
यदि( $string =~ m/\Q$regex\E/ ) { ... }
वैकल्पिक रूप से, आप रेगुलर एक्सप्रेशन कोट ऑपरेटर "qr//" का उपयोग कर सकते हैं (इसके लिए पर्लोप देखें)।
अधिक जानकारी)। यह पैटर्न को उद्धृत करता है और शायद संकलित करता है, और आप इसे नियमित रूप से लागू कर सकते हैं
पैटर्न के लिए अभिव्यक्ति झंडे।
चॉम्प(मेरा $इनपुट = );
मेरा $regex = qr/$input/is;
$string =~ m/$regex/ # m/$input/is के समान;
हो सकता है कि आप पूरी चीज़ के चारों ओर एक "eval" ब्लॉक लपेटकर किसी भी त्रुटि को फंसाना चाहें।
चॉम्प(मेरा $इनपुट = );
ईवल {
यदि( $string =~ m/\Q$input\E/ ) { ... }
};
$@ चेतावनी दें यदि $@;
या ...
मेरा $regex = eval { qr/$input/is };
यदि (परिभाषित $regex) {
$string =~ m/$regex/;
}
और {
चेतावनी $@;
}
लेखक और कॉपीराइट
कॉपीराइट (सी) 1997-2010 टॉम क्रिस्टियनसेन, नाथन टोर्किंगटन, और अन्य लेखकों के रूप में उल्लेख किया गया।
सर्वाधिकार सुरक्षित।
यह दस्तावेज़ीकरण मुफ़्त है; आप इसे उसी शर्तों के तहत पुनर्वितरित और/या संशोधित कर सकते हैं
पर्ल के रूप में ही।
इसके वितरण के बावजूद, इस फ़ाइल के सभी कोड उदाहरण एतद्द्वारा में रखे गए हैं
सार्वजनिक डोमेन। आपको अपने कार्यक्रमों में इस कोड का उपयोग करने की अनुमति है और प्रोत्साहित किया जाता है
मनोरंजन के लिए या लाभ के लिए जैसा कि आप फिट देखते हैं। क्रेडिट देने वाले कोड में एक साधारण टिप्पणी होगी
विनम्र लेकिन आवश्यक नहीं है।
onworks.net सेवाओं का उपयोग करके perlfaq6 का ऑनलाइन उपयोग करें