మీ బ్రౌజర్లో regex ఎలా పనిచేస్తుంది?
ప్రతి JavaScript రన్టైమ్ నేటివ్ రెగులర్ ఎక్స్ప్రెషన్ ఇంజిన్తో వస్తుంది — new RegExp(pattern, flags) మీ పాటర్న్ కంపైల్ చేస్తుంది, తర్వాత String.prototype.match, String.prototype.replace, మరియు RegExp.prototype.exec వంటి మెథడ్లు దాన్ని ఏ ఇన్పుట్ స్ట్రింగ్కు అయినా నడుపుతాయి. ఈ టెస్టర్ ఆ ఇంజిన్ను UIలో wrap చేస్తుంది, తద్వారా మీరు బ్రౌజర్ వదిలి వెళ్ళకుండా పాటర్న్లు ఎడిట్, నడుపు మరియు తనిఖీ చేయవచ్చు. మీరు టైప్ చేసేది — పాటర్న్, ఫ్లాగ్లు, టెస్ట్ స్ట్రింగ్, లేదా రిప్లేస్మెంట్ — నెట్వర్క్ మీదుగా పంపబడదు.
Regex టెస్టర్ ఎలా పనిచేస్తుంది?
పైప్లైన్ కొన్ని చిన్న దశలు, వీటన్నింటినీ ప్రతి కీస్ట్రోక్పై క్లయింట్-సైడ్లో నడుపుతారు (టైపింగ్ ఫ్లూయిడ్గా ఉండేందుకు 150 ms కి డెబౌన్స్ చేయబడింది):
- మీ పాటర్న్ బాడీ పైన ఉన్న ఇన్పుట్ నుండి చదవబడుతుంది (ముందు లేదా వెనక
/డిలిమిటర్లు లేవు — అవి అలంకారం). ఎంచుకున్న ఫ్లాగ్ పిల్స్giలేదాgimsuyవంటి ఫ్లాగ్ల స్ట్రింగ్లో కలుపబడతాయి. new RegExp(patternBody, flags)పాటర్న్ కంపైల్ చేస్తుంది. ఇంజిన్SyntaxErrorవిసిరితే (ఉదా. మ్యాచ్ కాని పేరెంథీసెస్ లేదా చెల్లుబాటు కాని ఎస్కేప్), టెస్ట్ స్ట్రింగ్ పైన సందేశం రెండర్ చేయబడుతుంది మరియు మ్యాచ్ లిస్ట్ క్లియర్ చేయబడుతుంది.- మ్యాచ్ లిస్ట్ కోసం, టెస్టర్ ఎప్పుడూ synthetic global ఫ్లాగ్తో ఎన్యూమరేట్ చేస్తుంది — కాబట్టి మీరు
gఆఫ్ చేసినా, లిస్ట్ ఇంకా ప్రతి మ్యాచ్ చూపుతుంది. స్టాండర్డ్ జీరో-విడ్త్-మ్యాచ్ గార్డ్ (if (m.index === rx.lastIndex) rx.lastIndex++) ఖాళీ స్ట్రింగ్ను మ్యాచ్ చేసే పాటర్న్లపై లూప్ తిరగకుండా చేస్తుంది. - ప్రతి ఇటరేషన్ మధ్య టెస్టర్
performance.now() - startతనిఖీ చేస్తుంది మరియు 50 ms గడిచిన తర్వాత అబార్ట్ చేస్తుంది. ఇదిaయొక్క పొడవైన రన్ అగెయిన్స్ట్(a+)+$వంటి ఇన్పుట్లపై వినాశకర బ్యాక్ట్రాకింగ్ నుండి రక్షిస్తుంది — లేకుంటే ట్యాబ్ హ్యాంగ్ అవుతుంది. - టెస్ట్ స్ట్రింగ్ ప్రతి మ్యాచ్ రేంజ్లో సెగ్మెంట్లుగా విభజించబడుతుంది మరియు మ్యాచ్ అయిన సెగ్మెంట్లు
<mark class="rx-match rx-cap-N">ఎలిమెంట్లలో wrap చేయబడతాయి, ఇక్కడNఆరు పాలెట్ రంగుల గుండా సైకిల్ చేస్తుంది, తద్వారా ఒకదానికొకటి ఉన్న మ్యాచ్లు ఒకే చూపులో సులభంగా వేరు చేయవచ్చు.
ఈ regex టెస్టర్ ఎందుకు ఉపయోగించాలి?
- గోప్యత: ప్రతి పాటర్న్, టెస్ట్ స్ట్రింగ్, మరియు రిప్లేస్మెంట్ బిల్ట్-ఇన్ JavaScript RegExp ఇంజిన్ ఉపయోగించి మీ బ్రౌజర్లో నడుస్తుంది. ఇన్పుట్ కస్టమర్ లాగ్, లీక్ అయిన క్రెడెన్షియల్ పాటర్న్, లేదా హోస్ట్ చేసిన SaaS regex ప్లేగ్రౌండ్లో పేస్ట్ చేయకూడని ఏ విషయమైనా ఉన్నప్పుడు ఇది ముఖ్యం.
- నిజమైన ఫ్లేవర్: టెస్టర్ Node.js, Chrome, Safari, Firefox, మరియు ప్రతి బ్రౌజర్-ఆధారిత ఫారమ్ వాలిడేటర్ నడిపే ఖచ్చితమైన regex ఇంజిన్ బహిర్గతం చేస్తుంది. సూక్ష్మమైన తేడాలు దాచే Perl-ఫ్లేవర్ ట్రాన్స్లేషన్ లేయర్ లేదు.
- క్యాప్చర్ మరియు నేమ్డ్-గ్రూప్ డీబగ్గింగ్: ప్రతి నంబర్డ్ గ్రూప్ (
$1,$2, …) మరియు నేమ్డ్ గ్రూప్ ($<year>) ప్రతి మ్యాచ్కు చూపబడుతుంది. రిప్లేస్ మోడ్ మిమ్మల్ని గ్రూప్లు స్వేచ్ఛగా కలపనిస్తుంది —$2-$1మొదటి రెండు స్లాట్లు మార్చుకుంటుంది,$<name>నేమ్డ్ స్లాట్ వేస్తుంది, మరియు$&పూర్తి మ్యాచ్ ప్రతిధ్వనిస్తుంది. - వినాశకర-బ్యాక్ట్రాకింగ్ గార్డ్: ఎన్యూమరేషన్పై 50 ms సీలింగ్
(a+)+$వంటి పాథలాజికల్ పాటర్న్లను ట్యాబ్ ఫ్రీజ్ చేయడానికి ముందు ఆపివేస్తుంది. హ్యాంగ్ అయిన బ్రౌజర్ బదులు వివరణాత్మక లోపం కనిపిస్తుంది, మరియు పేజీ వెంటనే రికవర్ అవుతుంది.
Regex టెస్టర్ సాధారణ అప్లికేషన్లు ఏమిటి?
రెగులర్ ఎక్స్ప్రెషన్లు వెబ్ డెవలప్మెంట్, సెక్యూరిటీ, మరియు డేటా పని అంతటా కనిపిస్తాయి — ఈ టెస్టర్ అత్యంత సాధారణ యూజ్ కేసులు లక్ష్యంగా చేసుకుంటుంది:
- ఫారమ్ వాలిడేషన్: ఇమెయిల్, ఫోన్, లేదా పోస్టల్-కోడ్ పాటర్న్ ప్రొటోటైప్ చేయండి, టెస్ట్ స్ట్రింగ్లో శాంపిల్ ఇన్పుట్లు పేస్ట్ చేయండి, మరియు ప్రతి పాజిటివ్ కేసు మ్యాచ్ అవుతుందో లేదో ప్రొడక్షన్ కోడ్కు పంపే ముందు నిర్ధారించండి.
- లాగ్ స్క్రేపింగ్: NGINX, అప్లికేషన్, లేదా ఆడిట్-లాగ్ అవుట్పుట్ ముక్క పేస్ట్ చేయండి, మీరు పట్టించుకునే భాగాలకు నేమ్డ్ గ్రూప్లతో పాటర్న్ రాయండి (
(?<ip>…) (?<path>…)), మరియు మీ పార్సర్ సరైనదో నిర్ధారించడానికి ప్రతి మ్యాచ్కు క్యాప్చర్ చేసిన స్లాట్లు చదవండి. - రిఫాక్టర్ సర్చ్-అండ్-రిప్లేస్: స్నిప్పెట్ అంతటా ఐడెంటిఫయర్లు రీరైట్ చేయడానికి రిప్లేస్ మోడ్ ఉపయోగించండి —
(\w+)\.set(\w+)\(→$1.$2 =గెట్టర్ కాల్లను ప్రాపర్టీ అసైన్మెంట్లుగా మారుస్తుంది, మరియు లైవ్ ప్రివ్యూ కోడ్మోడ్కు కమిట్ చేయడానికి ముందు ఫలితం చూపుతుంది.
Regex ఉదాహరణ ఎలా ఉంటుంది?
g ఫ్లాగ్తో (\d{4})-(\d{2})-(\d{2}) పాటర్న్ తీసుకోండి, release 2025-11-15, prerelease 2026-05-25 టెస్ట్ స్ట్రింగ్పై నడుపండి. ఇంజిన్ రెండు మ్యాచ్లు కనుగొంటుంది. మొదటి మ్యాచ్ 2025-11-15 గ్రూప్ 1 = 2025, గ్రూప్ 2 = 11, గ్రూప్ 3 = 15. రిప్లేస్ మోడ్లో, రిప్లేస్మెంట్ టెంప్లేట్ $3/$2/$1 రెండు తేదీలను 15/11/2025 మరియు 25/05/2026 కి రీరైట్ చేస్తుంది — పాటర్న్ను స్క్రిప్ట్లో చొప్పించే ముందు దృశ్యమానంగా వెరిఫై చేయగలిగే వన్-పాటర్న్ ISO-to-DMY కన్వర్షన్.
ఏ regex పనికైనా — పాటర్న్లు నిర్మించడం, డీబగ్గింగ్ చేయడం, లేదా రీరైటింగ్ చేయడం — ఈ టెస్టర్ వేగవంతమైన మార్గంగా ఉపయోగించండి. ప్రతిదీ స్థానికంగా నడుస్తుంది; ఏదీ లాగ్ చేయబడదు; regex ఇంజిన్ మీ బ్రౌజర్ ఏది వస్తుందో అది, కాబట్టి ప్రొడక్షన్ కోడ్ రన్టైమ్లో చూసేది ప్రవర్తన సరిపోతుంది.