Regex-testare

/ /

Skriv ett reguljärt uttryck, klistra in texten att testa mot, så kör testaren mönstret och listar varje träff den hittar. Varje resultat visar var träffen börjar och innehållet i varje fångstgrupp, så att du ser exakt vad mönstret fångade. Slå på flaggorna skiftlägesokänslig, flerradig och dotall för att ändra hur mönstret beter sig.

Så testar du en regex

  1. 1

    Ange ditt mönster

    Skriv uttrycket utan avgränsare; testaren omsluter det i `/ /` åt dig. Ett ogiltigt mönster visar ett tydligt felmeddelande i stället för att misslyckas i tysthet.

  2. 2

    Välj flaggorna

    Slå på `i` (skiftlägesokänslig), `m` (flerradig) eller `s` (dotall) för att matcha som du behöver.

  3. 3

    Klistra in testtexten

    Lägg till texten du vill söka i. Testaren går igenom hela och hittar varje träff, inte bara den första.

  4. 4

    Inspektera träffarna

    Varje träff visar sin position (offset) i texten, hela träffen och varje numrerad fångstgrupp.

Vad testaren visar dig

Att köra ett mönster i huvudet, eller med en snabb grep, säger om något matchar. Testaren visar dessutom:

  • Varje träff, med dess position. Den söker alltid igenom hela texten och rapporterar varje träff med teckenoffseten där den börjar.
  • Vilken grupp som fångade vad. Varje träff bryts ned i sin hela träff och de numrerade fångstgrupperna, så att du kan bekräfta att en (...) fångade den del du förväntade dig.
  • Vad flaggorna ändrar. Slå på i, m eller s och kör testet igen för att se hur skiftlägesokänslig, flerradig eller dotall ändrar resultatet.

Flaggorna, i klartext

Flagga Namn Vad den ändrar
i Skiftlägesokänslig A matchar även a, och omvänt
m Flerradig ^ och $ matchar i början och slutet av varje rad, inte bara hela texten
s Dotall . matchar även radbrytningar

Matchningen är alltid global: testaren returnerar varje träff i texten, så det finns ingen separat “global”-flagga att ställa in. Mönster körs på PCRE-motorn med Unicode-stöd, så klasser som \w och \d beter sig konsekvent på internationell text.

Vanliga regex-problem som detta hjälper dig att upptäcka

Symptom Vanlig orsak
En enda gigantisk träff som täcker allt .* är girig; använd .*? eller en negerad klass som [^"]*
^ eller $ matchar bara en gång m-flaggan saknas på flerradig text
. stannar vid radbrytningar s-flaggan saknas
Fångstgrupper i oväntad ordning Nästlade ( förskjuter gruppnumren; räkna dem från vänster till höger
Ett mönster som kör långsamt Nästlade * eller + över överlappande alternativ orsakar mycket backtracking

Tips för snabbare, säkrare mönster

  • Förankra med ^ när träffen börjar i början, så att motorn inte söker igenom hela strängen.
  • Föredra en teckenklass ([abc]) framför alternering (a|b|c); klasser är snabbare i varje stor motor.
  • Byt ut en girig .* mot en negerad klass som [^"]* när du känner till avslutstecknet, så slipper du backtracking.

Vanliga frågor

Den kör ditt mönster med PCRE, motorn som är inbyggd i PHP, med Unicode-läget på. Syntax som är specifik för PCRE, som \d, \b och lookarounds, fungerar som väntat. Om du ska använda mönstret i JavaScript, Python eller ett annat språk, kontrollera de små syntaxskillnaderna innan du driftsätter.

Varje träff. Testaren söker alltid igenom hela texten, så det finns ingen separat “global”-flagga att ställa in. Varje träff listas med sin position i texten.

Ja. Varje träff bryts ned i hela träffen och varje numrerad fångstgrupp, så att du kan bekräfta vilken del av texten varje (...) fångade.

i gör matchningen skiftlägesokänslig, m gör att ^ och $ matchar vid varje radgräns, och s låter . matcha radbrytningar. Slå på eller av dem och kör testet igen för att jämföra resultaten.

Testaren visar ett tydligt felmeddelande som beskriver problemet, till exempel en oavslutad hakparentes eller en oavslutad grupp, i stället för att i tysthet returnera inga träffar.

Relaterade verktyg

Verktyget finns på andra språk