जावास्क्रिप्ट पॅटर्न मॅचिंग रेग्युलर एक्सप्रेशन्ससह: एक सर्वसमावेशक मार्गदर्शक

रेग्युलर एक्सप्रेशन्स (regex) जावास्क्रिप्टमध्ये पॅटर्न मॅचिंग आणि टेक्स्ट मॅनिप्युलेशनसाठी एक शक्तिशाली साधन आहे. ते डेव्हलपर्सना परिभाषित पॅटर्नच्या आधारावर स्ट्रिंग शोधण्याची, प्रमाणित करण्याची आणि रूपांतरित करण्याची परवानगी देतात. हे मार्गदर्शक जावास्क्रिप्टमधील रेग्युलर एक्सप्रेशन्सचे सिंटॅक्स, वापर आणि प्रगत तंत्रांसह सर्वसमावेशक आढावा प्रदान करते.

रेग्युलर एक्सप्रेशन्स म्हणजे काय?

रेग्युलर एक्सप्रेशन हे अक्षरांची एक साखळी आहे जी एक शोध पॅटर्न परिभाषित करते. हे पॅटर्न स्ट्रिंग जुळवण्यासाठी आणि मॅनिप्युलेट करण्यासाठी वापरले जातात. रेग्युलर एक्सप्रेशन्स प्रोग्रामिंगमध्ये खालील कामांसाठी मोठ्या प्रमाणावर वापरले जातात:

• डेटा व्हॅलिडेशन: वापरकर्त्याने इनपुट केलेले डेटा विशिष्ट फॉरमॅटमध्ये आहे की नाही हे सुनिश्चित करणे (उदा. ईमेल ॲड्रेस, फोन नंबर).
• डेटा एक्सट्रॅक्शन: टेक्स्टमधून विशिष्ट माहिती मिळवणे (उदा. तारखा, यूआरएल किंवा किंमती काढणे).
• शोध आणि बदली: गुंतागुंतीच्या पॅटर्नच्या आधारावर टेक्स्ट शोधणे आणि बदलणे.
• टेक्स्ट प्रोसेसिंग: परिभाषित नियमांनुसार स्ट्रिंग तोडणे, जोडणे किंवा रूपांतरित करणे.

जावास्क्रिप्टमध्ये रेग्युलर एक्सप्रेशन्स तयार करणे

जावास्क्रिप्टमध्ये, रेग्युलर एक्सप्रेशन्स दोन प्रकारे तयार केले जाऊ शकतात:

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 वेळा दरम्यान जुळते.
• () (पॅरेंथेसिस): अक्षरांना एकत्र गटबद्ध करते आणि जुळलेल्या सबस्ट्रिंगला कॅप्चर करते.
• \ (बॅकस्लॅश): मेटाकॅरेक्टर्सना एस्केप करते, ज्यामुळे तुम्ही त्यांना अक्षरशः जुळवू शकता.
• | (पाइप): "or" ऑपरेटर म्हणून काम करते, जे त्याच्या आधीच्या किंवा नंतरच्या एक्सप्रेशनशी जुळते.

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

• [abc]: a, b, किंवा c यापैकी कोणत्याही एका अक्षराशी जुळते.
• [^abc]: 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 (global): पॅटर्नच्या सर्व घटनांशी जुळते, फक्त पहिल्या नाही.
• i (ignore case): केस-इन्सेन्सिटिव्ह मॅचिंग करते.
• m (multiline): मल्टीलाइन मोड सक्षम करते, जिथे ^ आणि $ प्रत्येक ओळीच्या (\n ने विभक्त) सुरुवातीला आणि शेवटी जुळतात.
• s (dotAll): डॉट (.) ला न्यूलाइन अक्षरांशी जुळण्याची परवानगी देते.
• u (unicode): पूर्ण युनिकोड समर्थन सक्षम करते.
• y (sticky): फक्त रेजेक्सच्या 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]

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

// match() 'g' फ्लॅगशिवाय
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 ने नेम्ड कॅप्चरिंग ग्रुप्स सादर केले, जे तुम्हाला (?...) सिंटॅक्स वापरून कॅप्चरिंग ग्रुप्सना नावे देण्याची परवानगी देतात. यामुळे कोड अधिक वाचनीय आणि देखरेख करण्यायोग्य बनतो.

const regex = /(?\d{4})-(?\d{2})-(?\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 = /(?

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"]

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 अक्षरांपेक्षा कमी)