रेगुलर एक्सप्रेशन्स के साथ जावास्क्रिप्ट पैटर्न मैचिंग: एक विस्तृत गाइड

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

रेगुलर एक्सप्रेशन्स क्या हैं?

एक रेगुलर एक्सप्रेशन कैरेक्टर्स का एक क्रम है जो एक खोज पैटर्न को परिभाषित करता है। इन पैटर्नों का उपयोग स्ट्रिंग्स को मैच करने और मैनिपुलेट करने के लिए किया जाता है। रेगुलर एक्सप्रेशन्स का व्यापक रूप से प्रोग्रामिंग में निम्नलिखित कार्यों के लिए उपयोग किया जाता है:

• डेटा वैलिडेशन: यह सुनिश्चित करना कि उपयोगकर्ता इनपुट विशिष्ट प्रारूपों (जैसे, ईमेल पते, फ़ोन नंबर) के अनुरूप है।
• डेटा एक्सट्रैक्शन: टेक्स्ट से विशिष्ट जानकारी प्राप्त करना (जैसे, तारीखें, यूआरएल, या कीमतें निकालना)।
• खोजें और बदलें: जटिल पैटर्न के आधार पर टेक्स्ट को खोजना और बदलना।
• टेक्स्ट प्रोसेसिंग: परिभाषित नियमों के आधार पर स्ट्रिंग्स को विभाजित करना, जोड़ना या बदलना।

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

जावास्क्रिप्ट में, रेगुलर एक्सप्रेशन्स दो तरीकों से बनाए जा सकते हैं:

1. एक रेगुलर एक्सप्रेशन लिटरल का उपयोग करके: पैटर्न को फॉरवर्ड स्लैश (/) के भीतर संलग्न करें।
2. RegExp कंस्ट्रक्टर का उपयोग करके: पैटर्न को एक स्ट्रिंग के रूप में RegExp ऑब्जेक्ट बनाएं।

उदाहरण:

// एक रेगुलर एक्सप्रेशन लिटरल का उपयोग करके
const regexLiteral = /hello/;

// RegExp कंस्ट्रक्टर का उपयोग करके
const regexConstructor = new RegExp("hello");

दोनों तरीकों के बीच का चुनाव इस बात पर निर्भर करता है कि पैटर्न कंपाइल समय पर ज्ञात है या गतिशील रूप से उत्पन्न होता है। जब पैटर्न निश्चित हो और पहले से ज्ञात हो तो लिटरल नोटेशन का उपयोग करें। जब पैटर्न को प्रोग्रामेटिक रूप से बनाने की आवश्यकता हो, खासकर जब वेरिएबल्स को शामिल करना हो, तो कंस्ट्रक्टर का उपयोग करें।

बेसिक रेगेक्स सिंटैक्स

रेगुलर एक्सप्रेशन्स में कैरेक्टर्स होते हैं जो मैच किए जाने वाले पैटर्न का प्रतिनिधित्व करते हैं। यहां कुछ मौलिक रेगेक्स घटक दिए गए हैं:

• लिटरल कैरेक्टर्स: कैरेक्टर्स को स्वयं मैच करते हैं (जैसे, /a/ कैरेक्टर 'a' से मैच करता है)।
• मेटाकैरेक्टर्स: विशेष अर्थ होते हैं (जैसे, ., ^, $, *, +, ?, [], {}, (), \, |)।
• कैरेक्टर क्लासेस: कैरेक्टर्स के सेट का प्रतिनिधित्व करते हैं (जैसे, [abc] 'a', 'b', या 'c' से मैच करता है)।
• क्वांटिफायर्स: निर्दिष्ट करते हैं कि एक कैरेक्टर या समूह कितनी बार आना चाहिए (जैसे, *, +, ?, {n}, {n,}, {n,m})।
• एंकर: स्ट्रिंग में स्थितियों को मैच करते हैं (जैसे, ^ शुरुआत से मैच करता है, $ अंत से मैच करता है)।

सामान्य मेटाकैरेक्टर्स:

• . (डॉट): न्यूलाइन को छोड़कर किसी भी एकल कैरेक्टर से मैच करता है।
• ^ (कैरेट): स्ट्रिंग की शुरुआत से मैच करता है।
• $ (डॉलर): स्ट्रिंग के अंत से मैच करता है।
• * (एस्टरिस्क): पिछले कैरेक्टर या समूह की शून्य या अधिक घटनाओं से मैच करता है।
• + (प्लस): पिछले कैरेक्टर या समूह की एक या अधिक घटनाओं से मैच करता है।
• ? (प्रश्न चिह्न): पिछले कैरेक्टर या समूह की शून्य या एक घटना से मैच करता है। वैकल्पिक कैरेक्टर्स के लिए उपयोग किया जाता है।
• [] (स्क्वायर ब्रैकेट्स): एक कैरेक्टर क्लास को परिभाषित करता है, जो ब्रैकेट्स के भीतर किसी भी एकल कैरेक्टर से मैच करता है।
• {} (कर्ली ब्रेसेस): मैच करने के लिए घटनाओं की संख्या निर्दिष्ट करता है। {n} ठीक n बार मैच करता है, {n,} n या अधिक बार मैच करता है, {n,m} n और m बार के बीच मैच करता है।
• () (पैरेंथेसिस): कैरेक्टर्स को एक साथ समूहित करता है और मैच्ड सबस्ट्रिंग को कैप्चर करता है।
• \ (बैकस्लैश): मेटाकैरेक्टर्स को एस्केप करता है, जिससे आप उन्हें शाब्दिक रूप से मैच कर सकते हैं।
• | (पाइप): "या" ऑपरेटर के रूप में कार्य करता है, जो इसके पहले या बाद के एक्सप्रेशन से मैच करता है।

कैरेक्टर क्लासेस:

• [abc]: a, b, या c में से किसी एक कैरेक्टर से मैच करता है।
• [^abc]: किसी भी कैरेक्टर से मैच करता है जो *not* a, b, या c है।
• [a-z]: a से z तक किसी भी लोअरकेस अक्षर से मैच करता है।
• [A-Z]: A से Z तक किसी भी अपरकेस अक्षर से मैच करता है।
• [0-9]: 0 से 9 तक किसी भी अंक से मैच करता है।
• [a-zA-Z0-9]: किसी भी अल्फान्यूमेरिक कैरेक्टर से मैच करता है।
• \d: किसी भी अंक से मैच करता है ([0-9] के बराबर)।
• \D: किसी भी गैर-अंक कैरेक्टर से मैच करता है ([^0-9] के बराबर)।
• \w: किसी भी वर्ड कैरेक्टर से मैच करता है (अल्फान्यूमेरिक प्लस अंडरस्कोर; [a-zA-Z0-9_] के बराबर)।
• \W: किसी भी गैर-वर्ड कैरेक्टर से मैच करता है ([^a-zA-Z0-9_] के बराबर)।
• \s: किसी भी व्हाइटस्पेस कैरेक्टर से मैच करता है (स्पेस, टैब, न्यूलाइन, आदि)।
• \S: किसी भी गैर-व्हाइटस्पेस कैरेक्टर से मैच करता है।

क्वांटिफायर्स:

• *: पिछले तत्व को शून्य या अधिक बार मैच करता है। उदाहरण के लिए, a* "", "a", "aa", "aaa", और इसी तरह मैच करता है।
• +: पिछले तत्व को एक या अधिक बार मैच करता है। उदाहरण के लिए, a+ "a", "aa", "aaa" से मैच करता है, लेकिन "" से नहीं।
• ?: पिछले तत्व को शून्य या एक बार मैच करता है। उदाहरण के लिए, a? "" या "a" से मैच करता है।
• {n}: पिछले तत्व को ठीक *n* बार मैच करता है। उदाहरण के लिए, a{3} "aaa" से मैच करता है।
• {n,}: पिछले तत्व को *n* या अधिक बार मैच करता है। उदाहरण के लिए, a{2,} "aa", "aaa", "aaaa", और इसी तरह मैच करता है।
• {n,m}: पिछले तत्व को *n* और *m* बार (समावेशी) के बीच मैच करता है। उदाहरण के लिए, a{2,4} "aa", "aaa", या "aaaa" से मैच करता है।

एंकर:

• ^: स्ट्रिंग की शुरुआत से मैच करता है। उदाहरण के लिए, ^Hello उन स्ट्रिंग्स से मैच करता है जो "Hello" से *शुरू* होती हैं।
• $: स्ट्रिंग के अंत से मैच करता है। उदाहरण के लिए, World$ उन स्ट्रिंग्स से मैच करता है जो "World" पर *समाप्त* होती हैं।
• \b: एक शब्द सीमा से मैच करता है। यह एक शब्द कैरेक्टर (\w) और एक गैर-शब्द कैरेक्टर (\W) या स्ट्रिंग की शुरुआत या अंत के बीच की स्थिति है। उदाहरण के लिए, \bword\b पूरे शब्द "word" से मैच करता है।

फ्लैग्स:

रेगेक्स फ्लैग रेगुलर एक्सप्रेशन्स के व्यवहार को संशोधित करते हैं। वे रेगेक्स लिटरल के अंत में जोड़े जाते हैं या RegExp कंस्ट्रक्टर के दूसरे आर्ग्यूमेंट के रूप में पास किए जाते हैं।

• g (ग्लोबल): पैटर्न की सभी घटनाओं से मैच करता है, न कि केवल पहली घटना से।
• i (इग्नोर केस): केस-इनसेंसिटिव मैचिंग करता है।
• m (मल्टीलाइन): मल्टीलाइन मोड को सक्षम करता है, जहां ^ और $ प्रत्येक लाइन की शुरुआत और अंत से मैच करते हैं (\n द्वारा अलग)।
• s (डॉटऑल): डॉट (.) को न्यूलाइन कैरेक्टर्स से भी मैच करने की अनुमति देता है।
• u (यूनिकोड): पूर्ण यूनिकोड समर्थन सक्षम करता है।
• y (स्टिकी): केवल रेगेक्स की lastIndex प्रॉपर्टी द्वारा इंगित इंडेक्स से मैच करता है।

जावास्क्रिप्ट रेगेक्स मेथड्स

जावास्क्रिप्ट रेगुलर एक्सप्रेशन्स के साथ काम करने के लिए कई मेथड्स प्रदान करता है:

• test(): जांचता है कि कोई स्ट्रिंग पैटर्न से मेल खाती है या नहीं। true या false लौटाता है।
• exec(): एक स्ट्रिंग में एक मैच के लिए एक खोज निष्पादित करता है। मैच्ड टेक्स्ट और कैप्चर किए गए समूहों वाला एक ऐरे लौटाता है, या यदि कोई मैच नहीं मिलता है तो null लौटाता है।
• match(): एक रेगुलर एक्सप्रेशन के खिलाफ एक स्ट्रिंग के मिलान के परिणामों वाला एक ऐरे लौटाता है। g फ्लैग के साथ और बिना अलग तरह से व्यवहार करता है।
• search(): एक स्ट्रिंग में एक मैच के लिए परीक्षण करता है। पहले मैच का इंडेक्स लौटाता है, या -1 यदि कोई मैच नहीं मिलता है।
• replace(): एक पैटर्न की घटनाओं को एक रिप्लेसमेंट स्ट्रिंग या एक फ़ंक्शन के साथ बदलता है जो रिप्लेसमेंट स्ट्रिंग लौटाता है।
• split(): एक रेगुलर एक्सप्रेशन के आधार पर एक स्ट्रिंग को सबस्ट्रिंग्स के ऐरे में विभाजित करता है।

रेगेक्स मेथड्स का उपयोग करके उदाहरण:

// test()
const regex = /hello/;
const str = "hello world";
console.log(regex.test(str)); // आउटपुट: true

// exec()
const regex2 = /hello (\w+)/;
const str2 = "hello world";
const result = regex2.exec(str2);
console.log(result); // आउटपुट: ["hello world", "world", index: 0, input: "hello world", groups: undefined]

// 'g' फ्लैग के साथ match()
const regex3 = /\d+/g; // विश्व स्तर पर एक या अधिक अंकों से मेल खाता है
const str3 = "There are 123 apples and 456 oranges.";
const matches = str3.match(regex3);
console.log(matches); // आउटपुट: ["123", "456"]

// 'g' फ्लैग के बिना match()
const regex4 = /\d+/;
const str4 = "There are 123 apples and 456 oranges.";
const match = str4.match(regex4);
console.log(match); // आउटपुट: ["123", index: 11, input: "There are 123 apples and 456 oranges.", groups: undefined]

// search()
const regex5 = /world/;
const str5 = "hello world";
console.log(str5.search(regex5)); // आउटपुट: 6

// replace()
const regex6 = /world/;
const str6 = "hello world";
const newStr = str6.replace(regex6, "JavaScript");
console.log(newStr); // आउटपुट: hello JavaScript

// एक फ़ंक्शन के साथ replace()
const regex7 = /(\d+)-(\d+)-(\d+)/;
const str7 = "Today's date is 2023-10-27";
const newStr2 = str7.replace(regex7, (match, year, month, day) => {
  return `${day}/${month}/${year}`;
});
console.log(newStr2); // आउटपुट: Today's date is 27/10/2023

// split()
const regex8 = /, /;
const str8 = "apple, banana, cherry";
const arr = str8.split(regex8);
console.log(arr); // आउटपुट: ["apple", "banana", "cherry"]

उन्नत रेगेक्स तकनीकें

कैप्चरिंग ग्रुप्स:

पैरेंथेसिस () का उपयोग रेगुलर एक्सप्रेशन्स में कैप्चरिंग ग्रुप्स बनाने के लिए किया जाता है। कैप्चर किए गए समूह आपको मैच्ड टेक्स्ट के विशिष्ट भागों को निकालने की अनुमति देते हैं। exec() और match() मेथड्स एक ऐरे लौटाते हैं जहां पहला तत्व पूरा मैच होता है, और बाद के तत्व कैप्चर किए गए समूह होते हैं।

const regex = /(\d{4})-(\d{2})-(\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);

console.log(match[0]); // आउटपुट: 2023-10-27 (पूरा मैच)
console.log(match[1]); // आउटपुट: 2023 (पहला कैप्चर किया गया समूह - वर्ष)
console.log(match[2]); // आउटपुट: 10 (दूसरा कैप्चर किया गया समूह - महीना)
console.log(match[3]); // आउटपुट: 27 (तीसरा कैप्चर किया गया समूह - दिन)

नामित कैप्चरिंग ग्रुप्स:

ES2018 ने नामित कैप्चरिंग ग्रुप्स पेश किए, जो आपको (?<name>...) सिंटैक्स का उपयोग करके कैप्चरिंग ग्रुप्स को नाम देने की अनुमति देते हैं। यह कोड को अधिक पठनीय और रखरखाव योग्य बनाता है।

const regex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const dateString = "2023-10-27";
const match = regex.exec(dateString);

console.log(match.groups.year);  // आउटपुट: 2023
console.log(match.groups.month); // आउटपुट: 10
console.log(match.groups.day);   // आउटपुट: 27

नॉन-कैप्चरिंग ग्रुप्स:

यदि आपको किसी रेगेक्स के भागों को बिना कैप्चर किए समूहित करने की आवश्यकता है (उदाहरण के लिए, एक समूह पर एक क्वांटिफायर लागू करने के लिए), तो आप एक नॉन-कैप्चरिंग ग्रुप का उपयोग (?:...) सिंटैक्स के साथ कर सकते हैं। यह कैप्चर किए गए समूहों के लिए अनावश्यक मेमोरी आवंटन से बचाता है।

const regex = /(?:https?:\/\/)?([\w\.]+)/; // एक URL से मेल खाता है लेकिन केवल डोमेन नाम कैप्चर करता है
const url = "https://www.example.com/path";
const match = regex.exec(url);

console.log(match[1]); // आउटपुट: www.example.com

लुकाअराउंड्स:

लुकाअराउंड्स शून्य-चौड़ाई के दावे हैं जो एक स्ट्रिंग में एक स्थिति से मेल खाते हैं जो उस स्थिति से पहले (लुकबिहाइंड) या बाद में (लुकाहेड) एक पैटर्न पर आधारित होता है, बिना लुकअराउंड पैटर्न को मैच में शामिल किए।

• पॉजिटिव लुकाहेड: (?=...) मैच करता है यदि लुकअराउंड के अंदर का पैटर्न वर्तमान स्थिति का *अनुसरण* करता है।
• नेगेटिव लुकाहेड: (?!...) मैच करता है यदि लुकअराउंड के अंदर का पैटर्न वर्तमान स्थिति का *अनुसरण नहीं* करता है।
• पॉजिटिव लुकबिहाइंड: (?<=...) मैच करता है यदि लुकबिहाइंड के अंदर का पैटर्न वर्तमान स्थिति से *पहले* आता है।
• नेगेटिव लुकबिहाइंड: (?<!...) मैच करता है यदि लुकबिहाइंड के अंदर का पैटर्न वर्तमान स्थिति से *पहले नहीं* आता है।

उदाहरण:

// पॉजिटिव लुकाहेड: कीमत केवल तभी प्राप्त करें जब उसके बाद USD हो
const regex = /\d+(?= USD)/;
const text = "The price is 100 USD";
const match = text.match(regex);
console.log(match); // आउटपुट: ["100"]

// नेगेटिव लुकाहेड: शब्द केवल तभी प्राप्त करें जब उसके बाद कोई संख्या न हो
const regex2 = /\b\w+\b(?! \d)/;
const text2 = "apple 123 banana orange 456";
const matches = text2.match(regex2);
console.log(matches); // आउटपुट: null क्योंकि match() केवल 'g' फ्लैग के बिना पहला मैच लौटाता है, जो हमें नहीं चाहिए।
// इसे ठीक करने के लिए:
const regex3 = /\b\w+\b(?! \d)/g;
const text3 = "apple 123 banana orange 456";
const matches3 = text3.match(regex3);
console.log(matches3); // आउटपुट: [ 'banana' ]

// पॉजिटिव लुकबिहाइंड: मान केवल तभी प्राप्त करें जब उसके पहले $ हो
const regex4 = /(?<=\$)\d+/;
const text4 = "The price is $200";
const match4 = text4.match(regex4);
console.log(match4); // आउटपुट: ["200"]

// नेगेटिव लुकबिहाइंड: शब्द केवल तभी प्राप्त करें जब उसके पहले 'not' शब्द न हो
const regex5 = /(?<!not )\w+/;
const text5 = "I am not happy, I am content.";
const match5 = text5.match(regex5); //यदि मैच होता है तो पहला मैच लौटाता है, ऐरे नहीं
console.log(match5); // आउटपुट: ['am', index: 2, input: 'I am not happy, I am content.', groups: undefined]
// इसे ठीक करने के लिए, g फ्लैग और exec() का उपयोग करें, लेकिन सावधान रहें क्योंकि regex.exec इंडेक्स को सहेजता है
const regex6 = /(?<!not )\w+/g;
let text6 = "I am not happy, I am content.";
let match6; let matches6=[];
while ((match6 = regex6.exec(text6)) !== null) {
  matches6.push(match6[0]);
}

console.log(matches6); // आउटपुट: [ 'I', 'am', 'happy', 'I', 'am', 'content' ]

बैकरेफरेंसेज:

बैकरेफरेंसेज आपको उसी रेगुलर एक्सप्रेशन के भीतर पहले से कैप्चर किए गए समूहों को संदर्भित करने की अनुमति देते हैं। वे \1, \2, आदि सिंटैक्स का उपयोग करते हैं, जहां संख्या कैप्चर किए गए समूह संख्या से मेल खाती है।

const regex = /([a-z]+) \1/;
const text = "hello hello world";
const match = regex.exec(text);
console.log(match); // आउटपुट: ["hello hello", "hello", index: 0, input: "hello hello world", groups: undefined]

रेगुलर एक्सप्रेशन्स के व्यावहारिक अनुप्रयोग

ईमेल पतों का सत्यापन:

रेगुलर एक्सप्रेशन्स के लिए एक सामान्य उपयोग का मामला ईमेल पतों का सत्यापन करना है। जबकि एक आदर्श ईमेल सत्यापन रेगेक्स अत्यंत जटिल है, यहाँ एक सरलीकृत उदाहरण है:

const emailRegex = /^[\w-\.]+@([\w-]+\.)+[\w-]{2,4}$/;

console.log(emailRegex.test("test@example.com"));    // आउटपुट: true
console.log(emailRegex.test("invalid-email"));       // आउटपुट: false
console.log(emailRegex.test("test@sub.example.co.uk")); // आउटपुट: true

टेक्स्ट से यूआरएल निकालना:

आप टेक्स्ट के एक ब्लॉक से यूआरएल निकालने के लिए रेगुलर एक्सप्रेशन्स का उपयोग कर सकते हैं:

const urlRegex = /https?:\/\/(www\.)?[-a-zA-Z0-9@:%._\+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_\+.~#?&\/\/=]*)/g;
const text = "Visit our website at https://www.example.com or check out http://blog.example.org.";
const urls = text.match(urlRegex);
console.log(urls); // आउटपुट: ["https://www.example.com", "http://blog.example.org"]

CSV डेटा पार्स करना:

रेगुलर एक्सप्रेशन्स का उपयोग CSV (Comma-Separated Values) डेटा को पार्स करने के लिए किया जा सकता है। यहां एक CSV स्ट्रिंग को मानों के ऐरे में विभाजित करने का एक उदाहरण है, जो क्वोटेड फ़ील्ड्स को संभालता है:

const csvString = 'John,Doe,"123, Main St",New York';
const csvRegex = /(?:"([^"]*(?:""[^"]*)*)")|([^,]+)/g; //सही किया गया CSV रेगेक्स
let values = [];
let match;  

while (match = csvRegex.exec(csvString)) {
  values.push(match[1] ? match[1].replace(/""/g, '"') : match[2]);
}


console.log(values); // आउटपुट: ["John", "Doe", "123, Main St", "New York"]

अंतर्राष्ट्रीय फ़ोन नंबर सत्यापन

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

const phoneRegex = /^\+(?:[0-9] ?){6,14}[0-9]$/;
console.log(phoneRegex.test("+1 555 123 4567")); // आउटपुट: true (US उदाहरण)
console.log(phoneRegex.test("+44 20 7946 0500")); // आउटपुट: true (UK उदाहरण)
console.log(phoneRegex.test("+81 3 3224 5000"));  // आउटपुट: true (जापान उदाहरण)
console.log(phoneRegex.test("123-456-7890"));   // आउटपुट: false

पासवर्ड शक्ति सत्यापन

रेगुलर एक्सप्रेशन्स पासवर्ड शक्ति नीतियों को लागू करने के लिए उपयोगी हैं। नीचे दिया गया उदाहरण न्यूनतम लंबाई, अपरकेस, लोअरकेस और एक संख्या की जाँच करता है।

const passwordRegex = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)[a-zA-Z\d]{8,}$/;

console.log(passwordRegex.test("P@ssword123")); // आउटपुट: true
console.log(passwordRegex.test("password"));       // आउटपुट: false (कोई अपरकेस या संख्या नहीं)
console.log(passwordRegex.test("Password"));       // आउटपुट: false (कोई संख्या नहीं)
console.log(passwordRegex.test("Pass123"));        // आउटपुट: false (कोई लोअरकेस नहीं)
console.log(passwordRegex.test("P@ss1"));          // आउटपुट: false (8 वर्णों से कम)

रेगेक्स ऑप्टिमाइज़ेशन तकनीकें

रेगुलर एक्सप्रेशन्स कम्प्यूटेशनली महंगे हो सकते हैं, खासकर जटिल पैटर्न या बड़े इनपुट के लिए। रेगेक्स प्रदर्शन को अनुकूलित करने के लिए यहां कुछ तकनीकें दी गई हैं:

• विशिष्ट बनें: अत्यधिक सामान्य पैटर्न का उपयोग करने से बचें जो इरादे से अधिक मेल खा सकते हैं।
• एंकर का उपयोग करें: जब भी संभव हो रेगेक्स को स्ट्रिंग की शुरुआत या अंत में एंकर करें (^, $)।
• बैकट्रैकिंग से बचें: पजेसिव क्वांटिफायर्स (जैसे, + के बजाय ++) या एटॉमिक ग्रुप्स ((?>...)) का उपयोग करके बैकट्रैकिंग को कम करें।
• एक बार कंपाइल करें: यदि आप एक ही रेगेक्स का कई बार उपयोग करते हैं, तो इसे एक बार कंपाइल करें और RegExp ऑब्जेक्ट का पुन: उपयोग करें।
• कैरेक्टर क्लासेस का बुद्धिमानी से उपयोग करें: कैरेक्टर क्लासेस ([]) आमतौर पर अल्टरनेशन (|) से तेज होती हैं।
• इसे सरल रखें: अत्यधिक जटिल रेगेक्स से बचें जिन्हें समझना और बनाए रखना मुश्किल है। कभी-कभी, एक जटिल कार्य को कई सरल रेगेक्स में तोड़ना या अन्य स्ट्रिंग मैनिपुलेशन तकनीकों का उपयोग करना अधिक कुशल हो सकता है।

आम रेगेक्स गलतियाँ

• मेटाकैरेक्टर्स को एस्केप करना भूल जाना: विशेष कैरेक्टर्स जैसे ., *, +, ?, $, ^, (, ), [, ], {, }, |, और \ को एस्केप करने में विफल होना जब आप उन्हें शाब्दिक रूप से मैच करना चाहते हैं।
• . (डॉट) का अत्यधिक उपयोग: डॉट किसी भी कैरेक्टर से मेल खाता है (कुछ मोड में न्यूलाइन को छोड़कर), जो सावधानी से उपयोग न करने पर अप्रत्याशित मैचों का कारण बन सकता है। जब संभव हो तो कैरेक्टर क्लासेस या अन्य अधिक प्रतिबंधात्मक पैटर्न का उपयोग करके अधिक विशिष्ट बनें।
• लालच (Greediness): डिफ़ॉल्ट रूप से, * और + जैसे क्वांटिफायर लालची होते हैं और जितना संभव हो उतना मैच करेंगे। जब आपको सबसे छोटी संभव स्ट्रिंग से मैच करने की आवश्यकता हो तो लेज़ी क्वांटिफायर्स (*?, +?) का उपयोग करें।
• एंकर का गलत उपयोग: ^ (स्ट्रिंग/लाइन की शुरुआत) और $ (स्ट्रिंग/लाइन का अंत) के व्यवहार को गलत समझना गलत मिलान का कारण बन सकता है। मल्टीलाइन स्ट्रिंग्स के साथ काम करते समय m (मल्टीलाइन) फ्लैग का उपयोग करना याद रखें और चाहते हैं कि ^ और $ प्रत्येक लाइन की शुरुआत और अंत से मैच करें।
• एज केसेस को हैंडल न करना: सभी संभावित इनपुट परिदृश्यों और एज केसेस पर विचार करने में विफल रहने से बग हो सकते हैं। अपने रेगेक्स का विभिन्न प्रकार के इनपुट के साथ पूरी तरह से परीक्षण करें, जिसमें खाली स्ट्रिंग्स, अमान्य कैरेक्टर्स और सीमा शर्तें शामिल हैं।
• प्रदर्शन संबंधी समस्याएं: अत्यधिक जटिल और अक्षम रेगेक्स बनाने से प्रदर्शन समस्याएं हो सकती हैं, खासकर बड़े इनपुट के साथ। अधिक विशिष्ट पैटर्न का उपयोग करके, अनावश्यक बैकट्रैकिंग से बचकर, और बार-बार उपयोग किए जाने वाले रेगेक्स को कंपाइल करके अपने रेगेक्स को अनुकूलित करें।
• कैरेक्टर एन्कोडिंग को अनदेखा करना: कैरेक्टर एन्कोडिंग (विशेषकर यूनिकोड) को ठीक से हैंडल न करने से अप्रत्याशित परिणाम हो सकते हैं। सही मिलान सुनिश्चित करने के लिए यूनिकोड कैरेक्टर्स के साथ काम करते समय u फ्लैग का उपयोग करें।

निष्कर्ष

रेगुलर एक्सप्रेशन्स जावास्क्रिप्ट में पैटर्न मैचिंग और टेक्स्ट मैनिपुलेशन के लिए एक मूल्यवान टूल हैं। रेगेक्स सिंटैक्स और तकनीकों में महारत हासिल करने से आप डेटा सत्यापन से लेकर जटिल टेक्स्ट प्रोसेसिंग तक की समस्याओं की एक विस्तृत श्रृंखला को कुशलतापूर्वक हल कर सकते हैं। इस गाइड में चर्चा की गई अवधारणाओं को समझकर और वास्तविक दुनिया के उदाहरणों के साथ अभ्यास करके, आप अपने जावास्क्रिप्ट डेवलपमेंट स्किल्स को बढ़ाने के लिए रेगुलर एक्सप्रेशन्स का उपयोग करने में कुशल बन सकते हैं।

याद रखें कि रेगुलर एक्सप्रेशन्स जटिल हो सकते हैं, और उन्हें regex101.com या regexr.com जैसे ऑनलाइन रेगेक्स टेस्टर्स का उपयोग करके अच्छी तरह से परीक्षण करना अक्सर सहायक होता है। यह आपको मैचों की कल्पना करने और किसी भी मुद्दे को प्रभावी ढंग से डीबग करने की अनुमति देता है। हैप्पी कोडिंग!