Regex परीक्षक और डिबगर

त्वरित संदर्भ

नियमित अभिव्यक्तियों के बारे में

नियमित अभिव्यक्तियाँ (regex) ऐसे पैटर्न हैं जिनका उपयोग स्ट्रिंग्स में वर्ण संयोजनों से मिलान करने के लिए किया जाता है। वे प्रोग्रामिंग, टेक्स्ट प्रोसेसिंग, डेटा सत्यापन और खोज संचालन में एक आवश्यक उपकरण हैं। हर प्रमुख प्रोग्रामिंग भाषा regex का समर्थन करती है · JavaScript, Python, Java, PHP, Ruby, Go, और अधिक।

यह परीक्षक JavaScript के बिल्ट-इन RegExp इंजन का उपयोग करता है, जो ECMAScript regex सिंटैक्स का समर्थन करता है, जिसमें lookahead, वर्ण वर्ग, क्वांटिफ़ायर और g, i, m, तथा s फ़्लैग शामिल हैं। आप जैसे टाइप करते हैं मिलान रीयल टाइम में हाइलाइट किए जाते हैं, और कैप्चर समूह मिलान विवरण पैनल में प्रदर्शित किए जाते हैं।

सामान्य उपयोग

• ईमेल पते, फ़ोन नंबर और फ़ॉर्म इनपुट सत्यापित करें
• लॉग फ़ाइलों, CSVs, या HTML से डेटा निकालें
• कोड एडिटर में टेक्स्ट पैटर्न खोजें और बदलें
• URLs, फ़ाइल पथ और संरचित टेक्स्ट पार्स करें
• वेब स्क्रैपिंग सेलेक्टर और खोज फ़िल्टर लिखें

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

g, i, m और s फ़्लैग क्या करते हैं?

g (ग्लोबल) पहले पर रुकने के बजाय सभी मिलान ढूँढता है। i (केस असंवेदनशील) अपरकेस बनाम लोअरकेस को अनदेखा करता है। m (मल्टीलाइन) ^ और $ को हर लाइन के आरंभ/अंत से मिलान कराता है। s (dotAll) . को न्यूलाइन वर्णों से भी मिलान कराता है।

क्या यह regex Python / Java / PHP में काम करेगा?

अधिकांश regex सिंटैक्स भाषाओं में साझा है। हालाँकि, अंतर हैं · उदाहरण के लिए, JavaScript सभी ब्राउज़रों में lookbehind का समर्थन नहीं करता (हालाँकि आधुनिक करते हैं), और Python विभिन्न नामित समूह सिंटैक्स का उपयोग करता है। मूल पैटर्न के लिए, जो यहाँ काम करता है वह हर जगह काम करेगा।

क्या मेरा परीक्षण डेटा कहीं भेजा जाता है?

नहीं। सभी regex मिलान आपके ब्राउज़र में स्थानीय रूप से JavaScript के नेटिव RegExp इंजन का उपयोग करके होते हैं। किसी भी सर्वर पर कुछ नहीं भेजा जाता।

Regex tester kya hai?

Regex tester एक interactive editor है जो एक regular expression को एक sample string के विरुद्ध चलाता है और आपको ठीक वही दिखाता है जो match हुआ, जो नहीं हुआ, और capture groups में क्या है. Tester आपको जल्दी iterate करने देता है: pattern type करें, highlights देखें, समायोजित करें, दोहराएँ. यह source code edit करने, script चलाने, और console output पढ़ने के धीमे loop को बदलता है.

Regular expressions स्वयं Stephen Cole Kleene द्वारा 1956 में आविष्कृत एक pattern syntax हैं जो strings के sets का वर्णन करती है. आधुनिक regex implementations (PCRE, JavaScript का RegExp, Python का re, .NET का System.Text.RegularExpressions, Java का java.util.regex) अपने अधिकांश syntax को साझा करते हैं लेकिन lookbehinds, named groups, Unicode handling, और quantifier व्यवहार जैसे edge cases में भिन्न होते हैं.

यह tester आपके browser के देशी JavaScript RegExp engine का उपयोग करता है, जो सभी standard flags (g, i, m, s, u, y, d) और आधुनिक lookbehinds सहित ECMAScript 2024 regex लागू करता है. Output ठीक वही है जो आपका front-end code runtime पर देखेगा, जो tester को client-side validation, scraping selectors, या replace-with-callback रूपांतरण को debug करते समय विशेष रूप से उपयोगी बनाता है.

Tester ke andar kya hai

ऊपरी row में forward slashes से घिरा pattern input होता है, उसके बाद चार सबसे अधिक उपयोग किए जाने वाले flags (g, i, m, s) के toggle buttons होते हैं. एक Patterns button सामान्य regex snippets (email, URL, phone, date) की एक library खोलता है जिसे आप pattern field भरने के लिए click कर सकते हैं. पीछे की ओर input debounced होता है ताकि फिर से टाइप करना matcher को थकाए नहीं.

Pattern के नीचे, Test String textarea वहाँ है जहाँ आप sample text paste करते हैं. Matches Highlighted Matches panel में एक पीले background के साथ highlight होते हैं जो आप जब टाइप करते हैं तब update होता है. Replace with field backreferences ($1, $2, आदि) वाला एक replacement string स्वीकार करता है और परिणामी text live दिखाता है, string-replacement रूपांतरणों को अपने code में paste करने से पहले परखने के लिए सही.

Match Details list हर match को source में उसके शून्य-आधारित index, matched substring, और हर capture group के साथ दिखाती है. नीचे एक Quick Reference card character classes, quantifiers, anchors, और lookarounds के syntax का सारांश देता है, इसलिए आपको बुनियादी बातों के लिए documentation tab पर context-switch नहीं करना पड़ता.

Itihaas aur prishthbhumi

Stephen Cole Kleene regular events परिभाषित करते हैं (1956)

गणितज्ञ Stephen Cole Kleene ने 1956 में Representation of Events in Nerve Nets and Finite Automata नामक paper प्रकाशित किया, जिसमें उन्होंने regular events पेश की: वे patterns जो एक finite automaton द्वारा स्वीकृत strings के sets का वर्णन करते हैं. Kleene star (* operator) उनका नाम धारण करता है. उनकी algebraic notation आज उपयोग में आने वाली हर regex syntax की सीधी पूर्वज है.

Ken Thompson grep को ship करते हैं (1968)

Bell Labs में Ken Thompson ने 1968 में QED editor के अंदर एक regex engine लागू किया और फिर grep (1973) में, वह Unix utility जिसका नाम QED command g/regular-expression/p से आता है. Thompson का NFA-आधारित engine प्रति character रैखिक समय में चलता था, एक गारंटी जो backtracking engines ने बाद में खो दी जब उन्होंने backreferences जैसे features जोड़े.

Perl 5 extended regex पेश करता है (1994)

Larry Wall ने 1994 में Perl 5 release किया जिसमें lookaheads, lookbehinds, named captures (बाद में), inline modifiers, और backreferences जोड़ने वाला एक regex flavor था. Perl 5 regex इतना प्रमुख बन गया कि अन्य भाषाओं ने इसकी syntax की नकल की. Philip Hazel ने 1997 में C library के रूप में PCRE (Perl Compatible Regular Expressions) बनाया, और PCRE आज PHP, Apache, NGINX, और कई अन्य tools में regex को शक्ति देता है.

JavaScript RegExp को ship करता है (1995, 1999 में औपचारिक)

Brendan Eich का JavaScript 1.0 1995 में Perl 5 पर आधारित एक RegExp object के साथ shipped हुआ. ECMAScript edition 3 (1999) ने syntax को औपचारिक रूप दिया. बाद के editions ने Unicode flag u (ES2015), sticky flag y (ES2015), named groups (ES2018), lookbehinds (ES2018), और indices flag d (ES2022) जोड़े. Browsers समय के साथ पकड़ते गए, और आधुनिक engines (V8, SpiderMonkey, JavaScriptCore) पूर्ण ES2024 spec लागू करते हैं.

ReDoS, regex denial of service (2003 से आगे)

शोधकर्ताओं ने देखा कि backtracking regex engines कुछ inputs पर exponential समय ले सकते हैं, एक vulnerability की श्रेणी जिसे ReDoS (Regular expression Denial of Service) कहा जाता है. 2019 का एक Cloudflare outage catastrophic backtracking वाली एक regex तक पता लगाया गया था. rxxr और node-re2 जैसे tools समस्या का पता लगाने या उसे टालने के लिए सामने आए, और engines ने लंबे चलने वाले matches पर समय budgets लागू करना शुरू किया.

Unicode property escapes ECMAScript में आते हैं (2018)

ES2018 ने \p{Script=Latin} या \p{Letter} जैसे Unicode property escapes जोड़े, जो आपको code points को सूचीबद्ध किए बिना Unicode श्रेणी द्वारा match करने देते हैं. u flag के साथ संयुक्त, regex अब emoji को letters से, scripts को एक-दूसरे से अलग कर सकती है, और surrogate pairs को सही ढंग से संभाल सकती है. यह JavaScript regex को अंततः अंतरराष्ट्रीय text matching के लिए उपयुक्त बनाता है, एक समस्या जिसे पुरानी ASCII-केवल syntax हल नहीं कर सकती थी.

Praayogik workflows

Email सत्यापन

Test area में मान्य और अमान्य emails का एक sample drop करें, अपनी candidate regex type करें (एक सामान्य प्रारंभिक बिंदु ^[^@\s]+@[^@\s]+\.[^@\s]+$ है), और तब तक tweak करें जब तक मान्य emails highlight हों और अमान्य न हों. ध्यान रखें कि पूरी RFC 5321 email spec इतनी जटिल है कि सही email regex सैकड़ों characters लंबी है. एक व्यावहारिक regex typos पकड़ती है; अंतिम validation को वास्तविक SMTP के माध्यम से round-trip करना चाहिए.

URL parsing aur extraction

HTML या plain text का एक page paste करें और URLs निकालने के लिए एक regex लिखें. https?:\/\/\S+ जैसा एक प्रारंभिक pattern अधिकांश मामलों को पकड़ता है. Production code के लिए, URL constructor (new URL(string)) को प्राथमिकता दें जो हर edge case संभालता है; regex त्वरित one-off निष्कर्षण या log analysis के लिए सर्वोत्तम है.

Log file scraping

Apache और NGINX logs एक निश्चित प्रारूप का अनुसरण करते हैं. कुछ log lines paste करें, named captures ((?<ip>\S+) (?<ts>\S+ \S+) "(?<req>[^"]+)" ...) के साथ एक regex लिखें, और आपके पास एक structured-log analyzer में feed करने के लिए तैयार एक parser है. Deploy करने से पहले अपने वास्तविक logs के एक sample पर परखें.

Code editors में find और replace

VSCode, Sublime Text, JetBrains IDEs और vim सब अपने find-replace dialogs में regex स्वीकार करते हैं. पहले यहाँ pattern पर iterate करें, live highlighter के साथ जो ठीक दिखाता है कि क्या match होता है, फिर regex को editor के dialog में paste करें. अपने आप को 5,000-line codebase पर गलत निशानों के दर्द से बचाएँ.

CSS class names का web scraping

जब आपको बिना parser के HTML से data निकालना हो (एक one-off script, production नहीं), class="([^"]+)" जैसी एक regex class attributes बाहर खींचती है. त्वरित अन्वेषण से आगे किसी भी चीज़ के लिए, एक उचित DOM library पर switch करें; HTML एक regular भाषा नहीं है और regex edge cases से चूक जाती है.

Semantic version strings को मान्य करना

Semver ^\d+\.\d+\.\d+(-[\w.]+)?(\+[\w.]+)?$ का अनुसरण करता है. यह जाँचने के लिए कि regex pre-release और build metadata को सही ढंग से पकड़ती है, versions की एक list (1.0.0, 1.2.3-beta.1+build.456) test area में drop करें. यह CI scripts में dependencies को मान्य करते समय उपयोगी है.

Aam khataarey

Greedy बनाम lazy quantifiers

डिफ़ॉल्ट रूप से *, + और ? लालची हैं: वे जितना संभव हो उतना match करते हैं, फिर backtrack करते हैं यदि regex का बाकी हिस्सा विफल होता है. आलसी versions *?, +?, ?? जितना कम संभव हो उतना match करते हैं. क्लासिक उदाहरण <a>text</a> पर <.*> है जो पूरी string को match करता है, जबकि <.*?> केवल <a> और </a> को अलग-अलग match करता है. अति-मिलान आश्चर्यों से बचने के लिए सही चुनें.

विनाशकारी backtracking (ReDoS)

(a+)+ या (.*)* जैसे nested quantifiers एक लंबे गैर-match वाले input पर exponential समय ले सकते हैं जब engine हर संयोजन को आज़माता है. Browser tab freeze या crash हो सकता है. ओवरलैपिंग quantifier groups से बचें, जहाँ समर्थित हो वहाँ atomic groups (?>...) को प्राथमिकता दें, या input length को पहले से मान्य करें. npm library safe-regex जोखिम भरे patterns को स्वतः flag करती है.

Special characters को escape की आवश्यकता है

Regex में विशेष अर्थ वाले characters (. * + ? ^ $ ( ) [ ] { } | \) को literal रूप से match करने के लिए एक backslash से escape करना चाहिए. इसलिए \. एक dot match करता है, जबकि . कोई भी character match करता है. IPs, file extensions, या dotted version numbers मान्य करते समय false positives का सबसे आम कारण escape करना भूलना है.

Anchors aur multiline flag

m flag के बिना, ^ और $ केवल पूरी string के प्रारंभ और अंत को match करते हैं. m के साथ, वे हर line के प्रारंभ और अंत को match करते हैं. यदि आपकी regex एकल lines पर काम करती है लेकिन बहु-line input पर विफल होती है, m toggle करें. इसके विपरीत, यदि यह बहु-line input पर बहुत अधिक match करती है, m हटाएँ.

Cross-engine syntax भिन्नताएँ

यह tester JavaScript regex का उपयोग करता है. Python का re named captures के लिए (?<name>) के बजाय (?P<name>) का उपयोग करता है, .NET backreferences \k<name> को अलग ढंग से अनुमति देता है, और PCRE में recursive subpatterns (?R) जैसे features हैं जो JavaScript में नहीं हैं. यदि आपका अंतिम लक्ष्य Python या Java है, ship करने से पहले उन engines पर भी मान्य करें.

u flag ke bina Unicode

u flag के बिना, JavaScript regex surrogate pairs (emoji, CJK supplement) को दो अलग code units की तरह मानता है. \u{1F600} (मुस्कुराता चेहरा emoji) u के बिना काम नहीं करता. u flag के साथ, regex Unicode-aware बन जाती है, \p{Letter} जैसे property escapes उपलब्ध हो जाते हैं, और surrogate-pair handling सही होती है. अंतरराष्ट्रीय text matching के समय हमेशा u set करें.

Gopniyata aur data handling

हर regex आपके browser के RegExp engine द्वारा संकलित और निष्पादित होती है. हम आपका pattern, आपकी test string, या आपका replacement template किसी server को नहीं भेजते. Matcher स्थानीय रूप से चलता है, highlights स्थानीय रूप से render होते हैं, और match details list स्थानीय रूप से compute होती है. आपके inputs की सामग्री से जुड़े कोई analytics नहीं हैं.

Page load होने के बाद, tester offline काम करता है. आप network से disconnect कर सकते हैं, संवेदनशील log lines या PII paste कर सकते हैं, और उनके विरुद्ध patterns चला सकते हैं बिना आपके device से कोई data जाए. यह tool को उत्पादन data के विरुद्ध regex परखने के लिए सुरक्षित बनाता है बिना उसे किसी तीसरे पक्ष की सेवा के माध्यम से भेजे.

Regex कब उपयोग नहीं करना चाहिए

HTML ya XML parse karna

HTML एक regular भाषा नहीं है. आप regex के साथ nested tags को विश्वसनीय रूप से parse नहीं कर सकते; Zalgo और Cthulhu के बारे में प्रसिद्ध Stack Overflow उत्तर इस बिंदु को रंगीन ढंग से बनाता है. इसके बजाय DOMParser या cheerio (Node.js) या BeautifulSoup (Python) जैसी एक library का उपयोग करें. Regex one-off निष्कर्षण के लिए ठीक है लेकिन self-closing tags, comments, CDATA, और विकृत input जैसे edge cases पर टूटती है.

वे चीज़ें जो वास्तव में recursive हैं (JSON, source code, math expressions)

Balanced braces, balanced parens, nested function calls, arithmetic precedence, सभी के लिए एक context-free grammar चाहिए, एक regular नहीं. एक parser combinator (Parsimmon, nom) या एक generator (pegjs, antlr) का उपयोग करें. Regex opening या closing tokens को match कर सकती है लेकिन balance track नहीं कर सकती.

जब एक सरल string operation पर्याप्त हो

यदि आपको जाँचना है कि एक string prefix- से शुरू होती है, str.startsWith("prefix-") का उपयोग करें, /^prefix-/ का नहीं. String methods तेज़ हैं, स्पष्ट हैं, और quantifiers के साथ गलत होना असंभव है. Regex को उन patterns के लिए सुरक्षित रखें जिन्हें string methods व्यक्त नहीं कर सकतीं.

जटिल schema सत्यापन

यह मान्य करना कि एक JSON document का एक विशिष्ट आकार है (आवश्यक fields, nested types, value ranges) एक regex के बजाय एक JSON Schema validator (ajv, zod, joi) के साथ कहीं बेहतर किया जाता है. Regex format जाँच सकती है लेकिन संरचना नहीं, और एक regex जो JSON document को मान्य करने का प्रयास करती है एक maintenance दुःस्वप्न है.

Aur sawaal

मुझे lookahead बनाम lookbehind का उपयोग कब करना चाहिए?

Lookahead (?=...) यह assert करता है कि जो अनुसरण करता है वह उसे consume किए बिना match करता है; lookbehind (?<=...) जो पहले आता है उसके लिए वही करता है. Lookahead तब उपयोग करें जब trailing context तय करता है कि match करना है, lookbehind जब leading context करता है. JavaScript दोनों का 2018 से समर्थन करता है (ES2018), और सभी आधुनिक browsers करते हैं. 16.4 से पहले के पुराने Safari versions में lookbehind समर्थन नहीं था.

क्या सभी browsers में lookbehind समर्थित है?

Lookbehind (सकारात्मक और नकारात्मक) Chrome में version 62 (2017) से, Firefox में 78 (2020) से, Edge में 79 (2020) से, और Safari में 16.4 (2023) से समर्थित है. यदि आपका audience पुराने Safari का उपयोग कर सकता है, lookbehind से बचें या एक वैकल्पिक pattern के साथ polyfill करें. Node.js के लिए, lookbehind 10.0 से समर्थित रहा है.

Unicode (u) flag क्या करता है?

u flag Unicode मोड सक्षम करता है: surrogate pairs को एकल character की तरह माना जाता है, \u{...} escapes काम करते हैं, और \p{...} property escapes उपलब्ध हो जाते हैं. u के बिना, मुस्कुराते चेहरे जैसा एक emoji दो code units के रूप में गिनता है और . केवल पहले half को match करता है. ASCII से आगे text के साथ काम करते समय हमेशा u set करें.

Regex engine kitna tez hai?

V8 का RegExp engine एक Irregexp implementation का उपयोग करता है जो native code में संकलित होता है. सरल patterns के लिए यह प्रति second लाखों characters match करता है. Pathological patterns (विरोधी input पर nested quantifiers) exponential समय तक बढ़ सकते हैं, यही कारण है कि ReDoS एक वास्तविक attack vector है. आधुनिक engines runaway matches का पता लगाने और रोकने के लिए heuristics लागू करते हैं, लेकिन आपको फिर भी जोखिम भरे patterns से बचना चाहिए.

JavaScript और Python regex कैसे भिन्न हैं?

Named groups अलग syntax का उपयोग करते हैं (JS में ?<name>, Python में ?P<name>). Python में y (sticky) flag नहीं है; JavaScript में Python का verbose मोड नहीं है. Python तीसरे-पक्ष के regex module के माध्यम से recursion का समर्थन करता है लेकिन built-in re नहीं. Character class shorthand थोड़ा भिन्न है (\d दोनों में [0-9] का मतलब है, लेकिन Python में \w Unicode मोड में underscores शामिल करता है जबकि JS को उसी व्यवहार के लिए u flag चाहिए).

क्या मैं इसके बजाय regex उत्पन्न करने के लिए AI का उपयोग कर सकता हूँ?

LLMs प्रारंभिक regex patterns प्रस्तावित करने में अच्छे हैं लेकिन नियमित रूप से सूक्ष्म रूप से गलत output उत्पन्न करते हैं (जहाँ आलसी चाहिए था वहाँ लालची, अनुपस्थित escapes, गलत flags). पहले drafts के लिए AI का उपयोग करें, फिर इस tester में वास्तविक samples के विरुद्ध regex चलाकर मान्य करें. तब तक iterate करें जब तक highlights ठीक वही match करें जो आप अपेक्षा करते हैं. इंटरैक्टिव feedback loop LLM गलतियों को उत्पादन में shipping से पहले पकड़ता है.

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