CDRN

Testa ett reguljärt uttryck

  • Panel
  • Dokumentation
  • API
testar ett reguljärt uttryck (regex) mot en text och visar matchningar och fångade grupper

Vad används en testare för reguljära uttryck till?

En regex tester låter dig verifiera att ett mönster för reguljärt uttryck (regex) verkligen matchar den förväntade texten, utan att behöva köra applikationskoden. Du klistrar in mönstret, du klistrar in indatatexten, du kryssar i alternativen (flags) och verktyget visar omedelbart listan över träffar som hittats samt de fångade grupperna. Det är onlinemotsvarigheten till preg_match_all() i PHP, String.matchAll() i JavaScript eller re.findall() i Python.

Regex är både kraftfulla och förrädiska. Ett kommatecken, en felplacerad parentes, en grådig kvantifierare som suger i sig för många tecken: och den extraherade strängen är inte längre den man förväntade sig. Testaren undviker rundresan mellan en editor, en terminal och en testfil: man itererar mönstret tills man ser rätt resultat.

Hur skriver man mönstret?

Ange regex utan avgränsare. Ingen /.../, ingen #...#. Till exempel, för att fånga e-postadresser i en text, ange bara [\w.+-]+@[\w-]+\.[\w.-]+. Alternativen (flags) styrs av kryssrutorna.

Alternativet u (Unicode) är ikryssat som standard. Det är nästan alltid önskat: utan det känner \w inte igen accenter, och vissa mönster returnerar ett tyst PCRE-fel på UTF-8- strängar.

PCRE-alternativen

  • i (case-insensitive): [a-z] känner också igen versaler.
  • m (multiline): ^ och $ matchar början och slutet av varje rad, inte bara början och slutet av den globala strängen.
  • s (dotall): . känner också igen radbrytningar. Användbart för mönster som ska korsa stycken.
  • u (unicode): tolkar mönstret och subjektet som UTF-8. Oumbärligt så snart texten innehåller icke-ASCII-tecken (accenter, emoji, ideogram).

Exempel på vanliga regex

  • E-postadress: [\w.+-]+@[\w-]+\.[\w.-]+ (förenklad form, tillräcklig för de flesta praktiska fall; den strikta RFC 5322 är mycket komplex).
  • HTTP/HTTPS-URL: https?://[\w.-]+(?:/[\w./?%&=-]*)?
  • Franskt telefonnummer: (?:\+33|0)\s?[1-9](?:[\s.-]?\d{2}){4}
  • Franskt postnummer: \b\d{5}\b
  • ISO-datum (YYYY-MM-DD): \b\d{4}-\d{2}-\d{2}\b
  • IPv4-adress: \b(?:\d{1,3}\.){3}\d{1,3}\b
  • Helt ord: \bfoo\b (word boundaries undviker att matcha football).
  • Hashtag: #\w+
  • Semantiskt versionsnummer: \d+\.\d+\.\d+(?:-[\w.-]+)?
  • Twitter / X-identifierare: @\w{1,15}

Fångade grupper

En regex kan innehålla grupper inom parenteser, som isolerar en del av matchningen för återanvändning. Till exempel fångar mönstret (\w+)@(\w+\.\w+) tillämpat på alice@example.com två grupper: alice och example.com. Verktyget visar dessa grupper i en dedikerad kolumn bredvid varje träff. Namngivna grupper ((?P<name>...)) listas också, indexerade efter sitt namn.

För att gruppera utan att fånga (användbart för att tillämpa en kvantifierare utan att förorena gruplistan), använd (?:...).

Skydd mot ReDoS

PHP:s PCRE-motor kan hamna i catastrophic backtracking på vissa patologiska mönster: ett mönster som (a+)+$ tillämpat på en lång sträng av a som inte avslutas korrekt kan låsa servern i flera sekunder. För att undvika denna denial of service via reguljärt uttryck (ReDoS) tillämpar verktyget två gränser:

  • en set_time_limit(2) på worker-sidan (behandlingen avbryts efter 2 sekunder);
  • en sänkning av pcre.backtrack_limit till 100 000, vilket gör att mönster som utforskar för många kombinationer misslyckas snabbt.

Vid alltför kostsamt mönster visar verktyget PCRE-felmeddelandet (preg_last_error_msg()), typiskt Backtrack limit was exhausted. Formulera om ditt mönster med possessiva kvantifierare (a++) eller atomära grupper ((?>...)) för att undvika backtracking.

Vanliga frågor

Varför matchar min regex inte fast den fungerar i JavaScript?

Motorn i detta verktyg är PCRE (PHP), nära Perl. Syntaxen är mycket lik JavaScript men vissa funktioner skiljer sig: lookbehinds med variabel längd, vissa Unicode-aliasar, eller standardhanteringen av skiftlägeskänslighet. Om du planerar att köra mönstret på klientsidan i webbläsaren, testa även i en JS-miljö.

Varför fångar mitt \w inte accenter?

Utan flaggan u känner \w bara igen [A-Za-z0-9_]. Med u (Unicode) känner den igen alla bokstäver enligt UCD, inklusive accenterade tecken. För att gå längre, använd Unicode-klasser: \p{L} (bokstav), \p{N} (siffra), \p{P} (interpunktion).

Sparar verktyget min text?

Nej. Mönstret och subjektet behandlas i RAM av PHP-workern, utan persistens. Ingen inskickad data loggas.

Vad gör jag om jag får meddelandet "Backtrack limit was exhausted"?

Ditt mönster gör för många backtracking-försök. Leta efter nested quantifiers av typen (a+)+ eller (\w+)*, som är typiska ReDoS-fall. Ersätt dem med en otvetydig form: till exempel \w+ istället för (\w+)*.

Kan jag testa ett flerradsmönster?

Ja. Kryssa i alternativet m så att ^ och $ känner igen början och slut på varje rad. Kryssa dessutom i s om du vill att . ska traversera radbrytningar.

Exempelförfrågan

curl -X POST https://cdrn.fr/api/v1/tools/regex-tester/execute \
  -H "Content-Type: application/json" \
  -d '{"pattern":"...","subject":"...","flag_i":false,"flag_m":false,"flag_s":false,"flag_u":true}'

Indatasschema

Fält Typ Obligatorisk Standard
pattern string ✓ –
subject text ✓ –
flag_i boolean ✓ false
flag_m boolean ✓ false
flag_s boolean ✓ false
flag_u boolean ✓ true

Slutpunkter

  • GET https://cdrn.fr/api/v1/tools - listar alla tillgängliga verktyg
  • GET https://cdrn.fr/api/v1/tools/regex-tester - hämtar schemat för detta verktyg
  • POST https://cdrn.fr/api/v1/tools/regex-tester/execute - kör detta verktyg med en JSON-payload