Reguljära uttryck
Skriv ett uttryck och en text att pröva det på, så markeras varje träff medan du skriver.
Exempel
Använd $1 eller $<namn> för grupper, $& för hela träffen och $$ för ett dollartecken.
Vanliga tecken och uttryck
- .
- vilket tecken som helst utom radbrytning
- \d
- en siffra 0–9
- \w
- en bokstav a–z, siffra eller understreck
- \s
- blanksteg, tabb eller radbrytning
- \D \W \S
- motsatsen till \d, \w och \s
- \b
- gräns mellan ord och icke-ord
- ^
- början av texten, eller av raden med m
- $
- slutet av texten, eller av raden med m
- [abc] [a-z]
- ett av tecknen, eller ett tecken i intervallet
- [^abc]
- inget av tecknen
- a|b
- a eller b
- (…)
- fångande grupp
- (?:…)
- grupp som inte fångar
- (?<name>…)
- namngiven grupp
- \1 \k<name>
- samma text som grupp 1 eller gruppen name
- *
- noll eller fler gånger
- +
- en eller fler gånger
- ?
- noll eller en gång
- {3} {2,5} {2,}
- exakt 3, 2–5 eller minst 2 gånger
- *? +? ??
- så få gånger som möjligt
- (?=…)
- följs av
- (?!…)
- följs inte av
- (?<=…) (?<!…)
- föregås av, föregås inte av
- \p{L}
- en bokstav i vilket alfabet som helst (kräver u eller v)
Så fungerar det
Ett reguljärt uttryck är ett mönster som beskriver text. \d+ betyder en eller flera siffror, [a-z] en bokstav mellan a och z och ^ början av texten. Mönstret prövas mot texten från vänster till höger, och varje ställe där det passar är en träff.
Verktyget använder webbläsarens egen motor, alltså den variant av reguljära uttryck som beskrivs i ECMAScript-standarden för JavaScript. Den skiljer sig på några punkter från PCRE, Python och .NET: det finns t.ex. inga possessiva kvantifierare eller atomära grupper, och lookbehind får vara hur lång som helst.
Flaggorna ändrar hur mönstret läses. g hittar alla träffar i stället för bara den första, i bortser från skillnaden mellan versaler och gemener, m låter ^ och $ gälla varje rad och s låter punkten matcha radbrytningar. u läser texten som Unicodetecken i stället för UTF-16-enheter, och v är en skärpt variant av u från ECMAScript 2024 med mängdoperationer i teckenklasser. y kräver att varje träff börjar exakt där den förra slutade, och d ger gruppernas positioner.
Parenteser fångar det som matchade och numreras efter den öppnande parentesen, från vänster. (?<namn>…) ger gruppen ett namn, och (?:…) grupperar utan att fånga. I ersättningen står $1 för grupp 1, $<namn> för en namngiven grupp, $& för hela träffen och $$ för ett dollartecken. Utan flaggan g ersätts bara den första träffen.
Vissa mönster tar extremt lång tid, t.ex. (a+)+$ mot en lång rad a som slutar med ett annat tecken. Motorn prövar då kombinationer vars antal växer exponentiellt med textens längd, så kallad katastrofal backtracking. Här körs sökningen i en egen tråd som avbryts efter två sekunder, så att sidan inte låser sig. I ett program på en server kan samma mönster bli en säkerhetsrisk (ReDoS).
Positionerna räknas i UTF-16-enheter, som i JavaScript, så en emoji räknas som två. En tom träff, som ^ eller \b, markeras med ett smalt streck. Texten lämnar aldrig din webbläsare.