Tester Regex

Testerul nostru regex îți permite să scrii și să testezi expresii regulate în timp real, cu evidențierea instantanee a potrivirilor. Vezi toate potrivirile, grupurile de captură și indicii potrivirilor pe măsură ce tastezi. Suportă toate flagurile regex JavaScript (global, ignorarea majusculelor, pe mai multe rânduri, dotAll, unicode, sticky). Include un mod de înlocuire pentru testarea căutării și înlocuirii, plus o fișă de sinteză regex cuprinzătoare pentru referință rapidă.

star 4.9
auto_awesome AI
New

Tester Regex calculator

/ /
global | case-insensitive | multiline | dotAll | unicode
info Enter a pattern to start matching
0 matches
find_replace Replace Mode

                        

No matches yet

lightbulb Tips

  • •\d = digit, \w = word, \s = space
  • •Use 'g' flag to find all matches
  • •Escape special chars: \. \( \[ \+
  • •Use (?:...) for non-capturing groups

How to Use the Tester Regex

edit

Introdu tiparul

Tastează tiparul tău regex în câmpul pentru tipar. Erorile de sintaxă sunt evidențiate în timp real.

text_fields

Adaugă text de test

Lipește sau tastează textul pe care dorești să îl testezi. Potrivirile sunt evidențiate instantaneu.

tune

Comută fanioanele

Activează fanioane precum global (g), ignorarea majusculelor (i) sau pe mai multe rânduri (m) pentru a modifica comportamentul de potrivire.

visibility

Vezi rezultatele

Vezi toate potrivirile, grupurile capturate și pozițiile potrivirilor. Folosește modul de înlocuire pentru a testa funcția de căutare și înlocuire.

The Formula

Expresiile regulate sunt tipare folosite pentru a găsi combinații de caractere în șiruri de text. Motorul regex scanează șirul de test de la stânga la dreapta, încercând să potrivească modelul în fiecare poziție. Fanioanele modifică comportamentul de potrivire — 'g' găsește toate potrivirile, 'i' ignoră diferențele dintre majuscule și minuscule, 'm' face ca ^ și $ să se potrivească cu limitele rândurilor.

new RegExp(pattern, flags).exec(testString)

lightbulb Variables Explained

  • pattern Modelul de expresie regulată pentru potrivire
  • flags Fanioane Regex: g (global), i (fără distincție între majuscule și minuscule), m (multi-linie), s (dotAll), u (unicode)
  • testString Textul de intrare pentru a testa modelul
  • exec() Returnează detaliile potrivirii, inclusiv grupurile capturate și indicii

tips_and_updates Pro Tips

1

Folosește flagul 'g' pentru a găsi toate potrivirile, nu doar pe prima

2

Evidențiază caracterele speciale cu bară inversă: \. \( \) \[ \] \{ \} \+ \* \?

3

Folosește (?:...) pentru grupuri fără captură atunci când nu ai nevoie de valoarea potrivită

4

\d = cifră, \w = caracter cuvânt, \s = spațiu alb, \b = limită de cuvânt

5

Folosește .+? (leneș) în loc de .+ (lacom) pentru a potrivi cât mai puțin posibil

6

Flagul 'm' face ca ^ și $ să se potrivească cu începutul/sfârșitul fiecărei linii, nu doar al șirului

7

Testează cazurile limită: șiruri goale, caractere speciale și intrări foarte lungi

Calculator de ore gratuit sau instrumentul nostru de testare regex gratuit îți permite să construiești, testezi și depanezi expresii regulate cu evidențiere în timp real. Vezi potrivirile, grupurile capturate și rezultatele înlocuirii instantaneu pe măsură ce tastezi. Funcționează cu sintaxa regex JavaScript.

Testator Regex Online cu previzualizare în timp real

Tastează modelul tău regex și vezi potrivirile evidențiate în timp real. Testatorul nostru de calculator ore lucrate acceptă toate fanioanele JavaScript, inclusiv:

  • global
  • fără distincție între majuscule și minuscule
  • multi-linie
  • dotAll

Fiecare potrivire este evidențiată, iar grupurile capturate sunt afișate separat pentru o depanare ușoară.

Constructor și depanator de modele Regex

Construiește modele regex complexe cu ajutorul instrumentului nostru interactiv. Vezi exact ce potrivește modelul tău și de ce.

Grupurile capturate sunt numerotate și afișate, facilitând crearea de modele pentru:

  • extracția de date
  • validare
  • procesarea textului

Ghid rapid și referință pentru Regex

Referință rapidă pentru sintaxa regex comună:

  • clase de caractere (\d, \w, \s)
  • cuantificatori (+, *, ?, {n})
  • ancore (^, $, \b)
  • grupuri și alternare
  • lookahead și lookbehind

Tot ce ai nevoie pentru a construi modele regex direct lângă tester.

Ce este o expresie regulată și cum funcționează?

O expresie regulată (regex) este o secvență de caractere care definește un șablon de căutare pentru potrivirea textului. Motorul regex citește șirul și scanează șirul de intrare de la stânga la dreapta, încercând o potrivire la fiecare poziție până reușește sau epuizează șirul.

Conform MDN Web Docs, expresiile regulate din JavaScript sunt obiecte create fie cu un literal (/șablon/fanioane), fie cu constructorul RegExp. Sintaxa formală și semantica de potrivire sunt definite în specificația limbajului ECMAScript menținută de TC39, în timp ce teoria mai largă provine din limbajele regulate din teoria limbajelor formale.

Majoritatea motoarelor moderne, inclusiv cele din Chrome (V8), Node.js și .NET, implementează dispozitive de potrivire cu backtracking care acceptă caracteristici precum referințe inverse și lookaround dincolo de automatele finite pure.

Cum se folosesc clasele de caractere și cuantificatorii în Regex

Clasele de caractere și cuantificatorii sunt elementele fundamentale ale oricărui model regex. O clasă de caractere precum [a-z] se potrivește cu orice caracter unic din set, în timp ce clasele abreviate precum \d (cifre), \w (caracter cuvânt) și \s (spațiu alb) sunt definite în specificația ECMAScript și documentate pe MDN Web Docs.

Cuantificatorii controlează repetiția:

  • * înseamnă zero sau mai multe
  • + înseamnă una sau mai multe
  • ? înseamnă zero sau una
  • {n,m} se potrivește de între n și m ori

Combină-le pentru a construi modele precise, de exemplu \d{3}-\d{4} pentru un fragment de telefon. Clasele negate cum ar fi [^0-9] se potrivesc cu orice altceva în afară de caracterele listate, oferindu-ți un control fin exact asupra textului pe care îl acceptă modelul tău.

Ce sunt ancorele, limitele și lookaround în Regex?

Ancorele și limitele se potrivesc cu pozițiile mai degrabă decât cu caracterele, permițându-ți să afirmi unde trebuie să apară o potrivire fără a consuma text. Circumflexul ^ se ancorează la începutul șirului (sau liniei cu fanionul multiline), $ se ancorează la sfârșit, iar \b marchează o limită de cuvânt între un caracter de cuvânt și un altul care nu este cuvânt, așa cum este documentat de MDN Web Docs și specificația ECMAScript.

Afirmațiile lookaround extind această idee: lookahead (?=...) și negative lookahead (?!...) verifică ce urmează, în timp ce lookbehind (?<=...) și (?

Aceste afirmații cu lățime zero sunt esențiale pentru regulile de parole, validare și potrivirea tokenilor doar în contexte specifice.

Cum se utilizează grupurile de captură denumite și referințele inverse

Grupurile de captură denumite îți permit să etichetezi un subșir capturat pentru modele mai clare și mai ușor de întreținut. Introduse în JavaScript în ECMAScript 2018 și documentate pe MDN Web Docs, sintaxa (?\d{4}) atribuie numele 'year' unui grup, accesibil prin match.groups.year.

Referințele inverse reutilizează o valoare capturată anterior mai târziu în același model: \1 se referă la primul grup numerotat, iar \k se referă la un grup denumit. De exemplu, (?['\"]).*?\k se potrivește cu un șir între ghilimele care se închide cu același caracter de ghilimele cu care a început.

Grupurile denumite îmbunătățesc lizibilitatea față de indicii poziționali, în special în modele complexe pentru analizarea datelor, adreselor URL sau liniilor de jurnal structurate.

Cum să testezi și să depanezi Regex pentru validarea e-mailurilor și a adreselor URL

Regex este utilizat pe scară largă pentru a valida și extrage e-mailuri și adrese URL, deși conformitatea completă cu RFC este înșelător de dificilă. Formatul de e-mail este definit în RFC 5322, iar gramatica sa de adresare este suficient de complexă încât niciun regex scurt să nu o captureze perfect; MDN Web Docs și specificația HTML WHATWG recomandă un șablon pragmatic pentru câmpul input type=email în loc de un analizor strict RFC 5322.

Adresele URL urmează sintaxa generică din RFC 3986. Pentru majoritatea aplicațiilor, un model indulgent care detectează erorile evidente plus verificarea reală a livrării sau a cererii este mai robust decât o expresie exhaustivă.

Folosește acest tester pentru a-ți verifica modelul în raport cu eșantioane valide și nevalide înainte de a-l lansa, prinzând fals-negativele care ar putea respinge introducerile legitime ale utilizatorilor.

Este Regex sigur? Înțelegerea ReDoS și a capcanelor de securitate

Regex este sigur pentru potrivire, dar poate crea riscul de refuz al serviciului dacă modelele sunt scrise neglijent. Refuzul serviciului prin expresii regulate (ReDoS), documentat de OWASP, apare atunci când un motor de backtracking lovește un backtracking catastrofal pe o intrare creată special, provocând un timp exponențial și blocând procesul. Declanșatorul clasic este reprezentat de cuantificatori imbricați sau suprapuși pe modele ambigue, cum ar fi (a+)+$ împotriva unui șir lung de 'a' urmat de un caracter care nu se potrivește.

OWASP recomandă:

  • evitarea cuantificatorilor imbricați
  • utilizarea grupurilor atomice sau a cuantificatorilor posesivi acolo unde sunt acceptați
  • setarea limitelor de timp pentru execuție
  • neconstruirea niciodată a modelelor din inputul neverifiact al utilizatorilor fără validare

Când rulezi regex pe un text controlat de un atacator, preferă modele de biblioteci bine testate și testează intrările cele mai nefavorabile în această unealtă înainte de implementare.

Cum diferă fanioanele Regex între JavaScript, Python și PCRE?

Fanioanele Regex partajează concepte între limbi, dar difera ca sintaxă și caracteristici disponibile. În JavaScript, fanioanele se adaugă la literal (/șablon/gi) sau se transmit ca al doilea argument al constructorului RegExp, cu g, i, m, s, u și y definite în specificația ECMAScript și explicate pe MDN Web Docs.

Modulul re din Python folosește fanioane inline cum ar fi re.IGNORECASE sau prefixe (?i) și nu are fanionul sticky. PCRE și motoarele compatibile cu Perl utilizate de PHP și multe instrumente acceptă modificatori similari plus caracteristici extinse.

Acest tester folosește motorul JavaScript, astfel încât modelele se comportă exact așa cum o vor face în browsere și Node.js. Când portezi un model într-un alt limbaj, re-verifică comportamentul cuantificatorilor, gestionarea Unicode și suportul pentru lookbehind, deoarece acestea variază între implementări.

Greșeli comune în Regex și cum să le eviți

Cele mai comune greșeli regex implică caractere speciale neescapate, cuantificatori lacomi și fanioane uitate. Metacaracterele precum . ( ) [ ] { } + * ? ^ $ | \ poartă o semnificație specială și trebuie escapate cu o bară inversă pentru a se potrivi literal, conform specificației ECMAScript și MDN Web Docs; un punct simplu . se potrivește cu orice caracter, nu cu un punct propriu-zis.

Cuantificatorii lacomi precum .+ depășesc măsura și înghit mai mult decât era intenționat, așa că folosește versiunile leneșe .+? atunci când te potrivești între delimitatori. Uitarea fanionului g returnează doar prima potrivire, iar omiterea ancorelor permite modelelor să se potrivească cu subșiruri neintenționate.

Alte capcane includ ignorarea Unicode cu fanionul u și presupunerea că lookbehind funcționează peste tot. Testează cazurile limită cum ar fi șirurile goale, liniile noi și intrările ostile în această unealtă înainte de a te baza pe orice model.

Frequently Asked Questions

sell

Tags