Skip to content
DevToolKit

Regex चीटशीट और टेस्टर

45 से अधिक टोकन के साथ इंटरैक्टिव Regex संदर्भ और लाइव सैंडबॉक्स। मैच हाइलाइटिंग, कैप्चर ग्रुप और प्रतिस्थापन परीक्षण। पूरी तरह ब्राउज़र में।

Search Reference

49 of 49 tokens
.
Any character

Matches any single character except newline (unless s flag is set).

\d
Digit

Matches any digit character (0-9). Equivalent to [0-9].

\D
Non-digit

Matches any character that is not a digit. Equivalent to [^0-9].

\w
Word character

Matches any alphanumeric character plus underscore. Equivalent to [a-zA-Z0-9_].

\W
Non-word character

Matches any character that is not a word character. Equivalent to [^a-zA-Z0-9_].

\s
Whitespace

Matches any whitespace character: space, tab, newline, carriage return, form feed.

\S
Non-whitespace

Matches any character that is not whitespace.

[abc]
Character set

Matches any one of the characters inside the brackets.

[^abc]
Negated set

Matches any character NOT inside the brackets.

[a-z]
Character range

Matches any character in the specified range (inclusive).

[a-zA-Z]
Combined range

Matches any uppercase or lowercase letter using combined ranges.

[0-9a-fA-F]
Hex digit range

Matches hexadecimal characters by combining digit and letter ranges.

^
Start of string

Matches the start of a string (or line in multiline mode).

$
End of string

Matches the end of a string (or line in multiline mode).

\b
Word boundary

Matches the position between a word character and a non-word character.

\B
Non-word boundary

Matches any position that is NOT a word boundary.

*
Zero or more

Matches the preceding element zero or more times (greedy).

+
One or more

Matches the preceding element one or more times (greedy).

?
Zero or one

Matches the preceding element zero or one time (optional).

{n}
Exactly n

Matches the preceding element exactly n times.

{n,}
n or more

Matches the preceding element at least n times (greedy).

{n,m}
Between n and m

Matches the preceding element between n and m times (inclusive, greedy).

*?
Lazy zero or more

Matches zero or more times, but as few as possible (lazy/non-greedy).

+?
Lazy one or more

Matches one or more times, but as few as possible (lazy/non-greedy).

??
Lazy zero or one

Matches zero or one time, preferring zero (lazy/non-greedy).

(abc)
Capturing group

Groups multiple tokens together and captures the matched text for back-referencing.

(?:abc)
Non-capturing group

Groups tokens together without capturing. Useful for applying quantifiers to groups.

(?<name>abc)
Named group

Captures the matched text and assigns it a name for easier reference.

\1
Backreference

Matches the same text as previously captured by the nth capturing group.

(a|b)
Group alternation

Captures one alternative from inside a group. Combines grouping with alternation.

|
Alternation (OR)

Matches the expression before or after the pipe. Acts as a boolean OR.

\\
Escaped backslash

Matches a literal backslash character.

\n
Newline

Matches a line feed character (LF, U+000A).

\t
Tab

Matches a horizontal tab character (U+0009).

\r
Carriage return

Matches a carriage return character (CR, U+000D).

\.
Escaped dot

Matches a literal period/dot character.

\^
Escaped caret

Matches a literal caret character.

\$
Escaped dollar

Matches a literal dollar sign character.

\(
Escaped parenthesis

Matches a literal opening parenthesis.

g
Global

Find all matches rather than stopping after the first match.

i
Case-insensitive

Makes the entire pattern case-insensitive.

m
Multiline

Makes ^ and $ match the start/end of each line rather than the whole string.

s
Dotall (single-line)

Makes the dot (.) match newline characters as well.

u
Unicode

Enables full Unicode matching. Required for proper emoji and surrogate pair handling.

y
Sticky

Matches only at the index indicated by the lastIndex property. Does not search forward.

(?=abc)
Positive lookahead

Asserts that what follows the current position matches the pattern, without consuming characters.

(?!abc)
Negative lookahead

Asserts that what follows the current position does NOT match the pattern.

(?<=abc)
Positive lookbehind

Asserts that what precedes the current position matches the pattern, without consuming characters.

(?<!abc)
Negative lookbehind

Asserts that what precedes the current position does NOT match the pattern.

Live Sandbox

//g
Flags
No matches found

Common Patterns

Was this tool helpful?

कैसे इस्तेमाल करें

Regex चीटशीट का उपयोग करने के लिए इन सरल चरणों का पालन करें। सभी प्रोसेसिंग आपके डिवाइस पर होती है — कोई डेटा कहीं भेजा नहीं जाता।

  1. इनपुट दें: अपना डेटा टेक्स्ट बॉक्स में पेस्ट करें या फ़ाइल ड्रॉप ज़ोन में खींचें। कई फ़ॉर्मेट सपोर्टेड हैं।
  2. कॉन्फ़िगर करें: अपनी आवश्यकता अनुसार सेटिंग्स और विकल्प चुनें। डिफ़ॉल्ट सेटिंग्स अधिकांश उपयोग के लिए उपयुक्त हैं।
  3. प्रोसेस करें: प्रोसेस बटन दबाएं — रिज़ल्ट तुरंत दिखाई देगा। रियल-टाइम प्रीव्यू उपलब्ध है।
  4. एक्सपोर्ट: आउटपुट कॉपी करें या फ़ाइल के रूप में डाउनलोड करें। JSON, CSV और अन्य फ़ॉर्मेट उपलब्ध हैं।

कोई रजिस्ट्रेशन या सॉफ़्टवेयर इंस्टॉलेशन ज़रूरी नहीं। मोबाइल, टैबलेट और डेस्कटॉप सभी पर काम करता है।

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

क्लाइंट-साइड प्रोसेसिंग से आपके डेटा की पूर्ण गोपनीयता सुनिश्चित होती है — कोई फ़ाइल या जानकारी किसी बाहरी सर्वर पर नहीं भेजी जाती। यह दृष्टिकोण संवेदनशील डेटा जैसे वित्तीय दस्तावेज़, व्यक्तिगत फ़ोटो और गोपनीय कोड के लिए आदर्श बनाता है।

इस टूल के बारे में

Regex चीटशीट एक व्यापक संदर्भ गाइड है जिसमें सभी प्रमुख कमांड, सिंटैक्स और उदाहरण शामिल हैं। श्रेणी अनुसार व्यवस्थित और खोज योग्य।

हर कमांड/पैटर्न के साथ व्यावहारिक उदाहरण और आउटपुट दिखाया गया है। कॉपी बटन से कोड सीधे टर्मिनल या एडिटर में पेस्ट करें। शुरुआती से लेकर एडवांस्ड स्तर तक।

PWA कैश से ऑफ़लाइन भी उपलब्ध। PDF में डाउनलोड करें। रियल-टाइम सर्च से तुरंत खोजें। डेवलपर्स और सिस्टम एडमिन के लिए आवश्यक संदर्भ।

Regex चीटशीट उद्योग-मानक एल्गोरिदम और प्रमाणित लाइब्रेरी पर आधारित है जो विश्वसनीय और विशिष्टता-अनुरूप परिणाम सुनिश्चित करते हैं। आधुनिक JavaScript इंजन और Web API की शक्ति का लाभ उठाकर नेटिव एप्लिकेशन के समकक्ष प्रदर्शन प्रदान किया जाता है।

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

यह टूल नियमित रूप से अपडेट किया जाता है ताकि नवीनतम सुधार और मानक अनुपालन सुनिश्चित हो। Chrome, Firefox, Safari और Edge सहित सभी आधुनिक ब्राउज़रों के साथ संगतता व्यवस्थित रूप से सत्यापित की जाती है।

यह टूल क्यों इस्तेमाल करें

Regex चीटशीट क्यों उपयोग करें:

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

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

सार्वभौमिक सुलभता: किसी भी आधुनिक ब्राउज़र में काम करता है, इसलिए किसी भी कनेक्टेड डिवाइस से अतिरिक्त सॉफ़्टवेयर इंस्टॉल किए बिना सुलभ है। मोबाइल, टैबलेट और डेस्कटॉप पर समान अनुभव मिलता है। PWA सपोर्ट से ऑफ़लाइन उपयोग भी संभव है जो इंटरनेट कनेक्शन न होने पर भी काम करता है।

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

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

Regex में greedy और lazy क्वांटिफ़ायर में क्या अंतर है?
Greedy क्वांटिफ़ायर जैसे * और + अधिकतम अक्षर मिलाते हैं फिर आवश्यकतानुसार वापस लौटते हैं। Lazy क्वांटिफ़ायर जैसे *? और +? न्यूनतम अक्षर मिलाते हैं और आवश्यकतानुसार बढ़ाते हैं। '<b>bold</b>' में greedy '<.*>' पूरी स्ट्रिंग मिलाता है जबकि lazy '<.*?>' केवल '<b>' मिलाता है।
lookahead और lookbehind कैसे काम करते हैं?
lookahead (?=...) और lookbehind (?<=...) शून्य-चौड़ाई अभिकथन हैं जो अक्षर उपभोग किए बिना पैटर्न जाँचते हैं। सकारात्मक lookahead (?=abc) पुष्टि करता है कि abc वर्तमान स्थिति के बाद है। नकारात्मक lookahead (?!abc) पुष्टि करता है कि abc नहीं है। ये विशिष्ट संदर्भ में टेक्स्ट मिलाने के लिए आवश्यक हैं।
'g' फ़्लैग क्या करता है?
ग्लोबल g फ़्लैग Regex इंजन को पहले के बजाय सभी मैच खोजने को कहता है। g बिना String.match() केवल पहला मैच लौटाता है। g के साथ सभी मैच का ऐरे लौटता है। जब भी सभी घटनाएँ खोजनी या बदलनी हों तब g उपयोग करें।
विशेष अक्षर शाब्दिक रूप से कैसे मिलाएँ?
विशेष Regex अक्षर . * + ? ^ $ आदि को शाब्दिक मिलान के लिए बैकस्लैश से एस्केप करना होता है। \. बिंदु मिलाता है, \( कोष्ठक मिलाता है और \\ बैकस्लैश। वर्ण वर्ग [.] के अंदर अधिकांश विशेष अक्षर अपना अर्थ खो देते हैं।
क्या लाइव टेस्टिंग डेटा सर्वर पर जाता है?
नहीं। Regex टेस्टिंग पूरी तरह आपके ब्राउज़र में JavaScript RegExp इंजन से होती है। कोई पैटर्न या टेस्ट डेटा सर्वर पर नहीं भेजा जाता। संवेदनशील डेटा पर पैटर्न परखने के लिए सुरक्षित।