रेगुलर एक्सप्रेशन में महारत 2026

"रेगुलर एक्सप्रेशन कठिन हैं" - यह सच है। लेकिन एक बार जब आप इन्हें सीख लेते हैं, तो आप टेक्स्ट प्रोसेसिंग समय को 90% तक कम कर सकते हैं।

यह गाइड व्यवहार में सबसे अधिक उपयोग किए जाने वाले regex पैटर्न को उदाहरणों के साथ कवर करती है।

---

Regex की मूल बातें

मूल सिंटैक्स

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

[abc]     - a, b, c में से एक
[^abc]    - a, b, c को छोड़कर
[a-z]     - a से z तक
[A-Z]     - A से Z तक
[0-9]     - 0 से 9 तक
[a-zA-Z]  - सभी अक्षर

क्वांटिफायर

{n}       - बिल्कुल n
{n,}      - n या अधिक
{n,m}     - n और m के बीच
*         - 0 या अधिक ({0,})
+         - 1 या अधिक ({1,})
?         - 0 या 1 ({0,1})

ग्रुप और कैप्चर

(abc)     - कैप्चर ग्रुप
(?:abc)   - नॉन-कैप्चरिंग ग्रुप
(?<name>abc) - नामित ग्रुप
\1        - पहले ग्रुप का बैकरेफरेंस

---

व्यावहारिक पैटर्न: सत्यापन

ईमेल एड्रेस

// मूल पैटर्न
const emailRegex = /^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$/;

// परीक्षण
emailRegex.test('user@example.com');  // true
emailRegex.test('invalid-email');      // false

पैटर्न विश्लेषण:

^                     - शुरुआत
[a-zA-Z0-9._%+-]+     - लोकल पार्ट (1+ वर्ण)
@                     - @ प्रतीक
[a-zA-Z0-9.-]+        - डोमेन (1+ वर्ण)
\.                    - . (एस्केप्ड)
[a-zA-Z]{2,}          - TLD (2+ वर्ण)
$                     - अंत

URL

const urlRegex = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w .-]*)*\/?$/;

// परीक्षण
urlRegex.test('https://example.com');           // true
urlRegex.test('https://sub.example.com/path');  // true
urlRegex.test('invalid url');                   // false

फोन नंबर (भारत)

// भारतीय मोबाइल
const mobileRegex = /^(\+91)?[6-9]\d{9}$/;

// परीक्षण
mobileRegex.test('+919876543210');  // true
mobileRegex.test('9876543210');     // true

पासवर्ड स्ट्रेंथ

// न्यूनतम 8 वर्ण, अपरकेस/लोअरकेस, नंबर, स्पेशल कैरेक्टर
const strongPassword = /^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$/;

// पैटर्न विश्लेषण
// (?=.*[a-z])   - कम से कम 1 लोअरकेस (lookahead)
// (?=.*[A-Z])   - कम से कम 1 अपरकेस
// (?=.*\d)      - कम से कम 1 अंक
// (?=.*[@$!%*?&]) - कम से कम 1 स्पेशल कैरेक्टर
// {8,}          - 8 या अधिक वर्ण

क्रेडिट कार्ड नंबर

// Visa
const visaRegex = /^4[0-9]{12}(?:[0-9]{3})?$/;

// MasterCard
const mastercardRegex = /^5[1-5][0-9]{14}$/;

// सभी कार्ड (वैकल्पिक हाइफन के साथ)
const cardRegex = /^\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}$/;

---

व्यावहारिक पैटर्न: टेक्स्ट एक्सट्रैक्शन

HTML टैग कंटेंट एक्सट्रैक्शन

const html = '<div class="title">Hello World</div>';

// टैग कंटेंट निकालें
const contentRegex = /<div[^>]*>(.*?)<\/div>/;
const match = html.match(contentRegex);
console.log(match[1]); // "Hello World"

// सभी टैग हटाएं
const noTags = html.replace(/<[^>]*>/g, '');
console.log(noTags); // "Hello World"

URL से डोमेन निकालें

const url = 'https://www.example.com/path/page.html';

const domainRegex = /^(?:https?:\/\/)?(?:www\.)?([^/]+)/;
const domain = url.match(domainRegex)[1];
console.log(domain); // "example.com"

लॉग फाइल पार्सिंग

const logLine = '[2026-02-21 14:30:45] ERROR: Connection timeout at module.js:42';

const logRegex = /\[(\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\] (\w+): (.+) at (.+):(\d+)/;

const [, datetime, level, message, file, line] = logLine.match(logRegex);

console.log({
  datetime,  // "2026-02-21 14:30:45"
  level,     // "ERROR"
  message,   // "Connection timeout"
  file,      // "module.js"
  line,      // "42"
});

CSV पार्सिंग (कॉमा-सेपरेटेड)

const csvLine = 'John,"Doe, Jr.",30,"New York, NY"';

// कॉमा से विभाजित करें (कोट्स के अंदर कॉमा को अनदेखा करें)
const csvRegex = /(?:^|,)("(?:[^"]*(?:""[^"]*)*)"|[^,]*)/g;

const fields = [];
let match;
while ((match = csvRegex.exec(csvLine)) !== null) {
  fields.push(match[1].replace(/^"|"$/g, '').replace(/""/g, '"'));
}

console.log(fields); // ["John", "Doe, Jr.", "30", "New York, NY"]

---

व्यावहारिक पैटर्न: खोज और प्रतिस्थापन

फोन नंबर फॉर्मेटिंग

const phone = '9876543210';

// स्पेस जोड़ें
const formatted = phone.replace(/(\d{5})(\d{5})/, '$1 $2');
console.log(formatted); // "98765 43210"

नंबर फॉर्मेटिंग

const amount = '1234567890';

// हजार सेपरेटर
const formatted = amount.replace(/\B(?=(\d{3})+(?!\d))/g, ',');
console.log(formatted); // "1,234,567,890"

मास्किंग

// ईमेल मास्किंग
const email = 'username@example.com';
const masked = email.replace(/(.{2})(.*)(@.*)/, '$1***$3');
console.log(masked); // "us***@example.com"

// फोन नंबर मास्किंग
const phone = '98765-43210';
const maskedPhone = phone.replace(/(\d{5})-(\d{5})/, '$1-*****');
console.log(maskedPhone); // "98765-*****"

व्हाइटस्पेस क्लीनअप

const text = '  Hello    World  ';

// आगे/पीछे का व्हाइटस्पेस हटाएं
const trimmed = text.replace(/^\s+|\s+$/g, '');

// कई स्पेस को एक में बदलें
const normalized = text.replace(/\s+/g, ' ').trim();
console.log(normalized); // "Hello World"

---

उन्नत सुविधाएं

Lookahead

// Positive Lookahead: (?=...)
// "foo" मैच करें केवल अगर "bar" फॉलो करे
const regex = /foo(?=bar)/;
'foobar'.match(regex);  // ["foo"]
'foobaz'.match(regex);  // null

// Negative Lookahead: (?!...)
// "foo" मैच करें केवल अगर "bar" फॉलो न करे
const regex2 = /foo(?!bar)/;
'foobaz'.match(regex2); // ["foo"]
'foobar'.match(regex2); // null

Lookbehind

// Positive Lookbehind: (?<=...)
// "$" से पहले वाले नंबर
const priceRegex = /(?<=\$)\d+/g;
'$100 and $200'.match(priceRegex); // ["100", "200"]

// Negative Lookbehind: (?<!...)
// "$" से पहले न वाले नंबर
const nonPriceRegex = /(?<!\$)\d+/g;
'$100 and 200'.match(nonPriceRegex); // ["200"]

Named Groups

const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/;
const match = '2026-02-21'.match(dateRegex);

console.log(match.groups.year);  // "2026"
console.log(match.groups.month); // "02"
console.log(match.groups.day);   // "21"

Non-Greedy

const html = '<div>Hello</div><div>World</div>';

// Greedy (डिफॉल्ट): जितना संभव हो उतना मैच करें
/<div>.*<\/div>/.exec(html)[0];
// "<div>Hello</div><div>World</div>"

// Non-Greedy: जितना कम संभव हो उतना मैच करें
/<div>.*?<\/div>/.exec(html)[0];
// "<div>Hello</div>"

---

भाषा-विशिष्ट कार्यान्वयन

JavaScript

// निर्माण विधियां
const regex1 = /pattern/flags;
const regex2 = new RegExp('pattern', 'flags');

// विधियां
regex.test(str);        // boolean
str.match(regex);       // array या null
str.replace(regex, replacement);
str.split(regex);
regex.exec(str);        // विस्तृत मैच जानकारी

// फ्लैग
// g: ग्लोबल खोज
// i: केस असंवेदनशील
// m: मल्टीलाइन
// s: dotAll (. न्यूलाइन मैच करे)
// u: यूनिकोड

Python

import re

# कंपाइल
pattern = re.compile(r'pattern', re.IGNORECASE)

# विधियां
re.match(pattern, string)   # शुरुआत से मैच
re.search(pattern, string)  # पूरी स्ट्रिंग में खोजें
re.findall(pattern, string) # सभी मैच की सूची
re.sub(pattern, repl, string) # प्रतिस्थापित करें

# उदाहरण
emails = re.findall(r'[\w.+-]+@[\w.-]+\.\w+', text)
cleaned = re.sub(r'\s+', ' ', text).strip()

Go

import "regexp"

// कंपाइल
re := regexp.MustCompile(`\d+`)

// विधियां
re.MatchString(s)          // bool
re.FindString(s)           // पहला मैच
re.FindAllString(s, -1)    // सभी मैच
re.ReplaceAllString(s, r)  // प्रतिस्थापित करें

// उदाहरण
numbers := re.FindAllString("a1b2c3", -1)
// ["1", "2", "3"]

---

प्रदर्शन अनुकूलन

कंपाइल किए गए Regex का पुन: उपयोग

// धीमा: हर बार कंपाइल होता है
function validate(email) {
  return /^[\w.+-]+@[\w.-]+\.\w+$/.test(email);
}

// तेज: एक बार कंपाइल करें
const emailRegex = /^[\w.+-]+@[\w.-]+\.\w+$/;
function validate(email) {
  return emailRegex.test(email);
}

नॉन-कैप्चरिंग ग्रुप का उपयोग करें

// अनावश्यक कैप्चर
const regex = /(https?):\/\/(www\.)?(.+)/;

// अनावश्यक ग्रुप के लिए नॉन-कैप्चरिंग
const regex = /(?:https?):\/\/(?:www\.)?(.+)/;

कैटास्ट्रोफिक बैकट्रैकिंग से बचें

// खतरनाक: (a+)+ पैटर्न
const bad = /^(a+)+$/;
'aaaaaaaaaaaaaaaaaaaaaa!'.match(bad); // बहुत धीमा

// सुरक्षित: पैटर्न को पुनर्गठित करें
const good = /^a+$/;

---

डिबगिंग टिप्स

Regex Tester का उपयोग करें

1. पैटर्न दर्ज करें
2. टेस्ट स्ट्रिंग दर्ज करें
3. हाइलाइटेड मैच देखें
4. कैप्चर ग्रुप सत्यापित करें

चरण-दर-चरण सत्यापन

// जटिल पैटर्न को चरण-दर-चरण सत्यापित करें
const parts = [
  '^',                    // शुरुआत
  '[a-zA-Z0-9._%+-]+',    // लोकल पार्ट
  '@',                    // @
  '[a-zA-Z0-9.-]+',       // डोमेन
  '\\.',                  // .
  '[a-zA-Z]{2,}',         // TLD
  '$',                    // अंत
];

const emailRegex = new RegExp(parts.join(''));

---

अक्सर पूछे जाने वाले प्रश्न

Q1: . और \. में क्या अंतर है?

A: . कोई भी वर्ण मैच करता है (वाइल्डकार्ड), \. एक लिटरल डॉट मैच करता है।

Q2: * और + में क्या अंतर है?

A: * 0 या अधिक मैच करता है, + 1 या अधिक मैच करता है।

• ab*c -> "ac", "abc", "abbc"
• ab+c -> "abc", "abbc" ("ac" मैच नहीं होता)

Q3: केस को कैसे अनदेखा करें?

A: i फ्लैग का उपयोग करें।

• JavaScript: /pattern/i
• Python: re.IGNORECASE

Q4: . से न्यूलाइन कैसे मैच करें?

A: s फ्लैग (dotAll) का उपयोग करें।

• JavaScript: /pattern/s
• Python: re.DOTALL

Q5: किन कैरेक्टर को एस्केप करना जरूरी है?

A: \ ^ $ . | ? * + ( ) [ ] { } - इन्हें \ से एस्केप करें।

---

निष्कर्ष

Regex की मूल बातें:

1. मूल सिंटैक्स: ., *, +, ?, [], ()
2. मेटा कैरेक्टर: \d, \w, \s, ^, $
3. क्वांटिफायर: {n}, {n,}, {n,m}
4. उन्नत सुविधाएं: Lookahead, Lookbehind, Named Groups

अभ्यास ही कुंजी है। Regex Tester पर रीयल-टाइम में टेस्ट करें।

---

संबंधित उपकरण