Hvorfor matcher «greedy» mønsteret mitt for mye?

Kvantifiseringene `*`, `+` og `?` er som standard grådige, de tar med så mye som mulig. Legg til `?` etter (som `.*?`) for ikke-grådig matching som stopper ved første mulige treff.

Kan jeg parse HTML med regex?

Nei, i hvert fall ikke pålitelig. HTML er ikke et regulært språk, så en regex kan aldri korrekt håndtere nestede tagger, kommentarer og CDATA. Bruk en DOM-parser (`DOMParser` i nettleseren) i stedet. Regex er greit for enkle uttrekk fra kjent, kontrollert HTML.

Hva er forskjellen på `.` og `[.]`?

`.` matcher et hvilket som helst tegn (unntatt newline, med mindre `s`-flagget er satt). `[.]` er en tegnklasse som matcher bare et bokstavelig punktum. Bruk `[.]` (eller `\.`) når du faktisk mener «punktum».

Hva er «catastrophic backtracking»?

Når et mønster kan matche samme tekst på mange forskjellige måter (typisk `(a+)+`), kan motoren bruke eksponentielt lang tid på å utforske alle mulighetene. Dette kan låse nettleseren eller føre til DoS-angrep (ReDoS). Unngå nestede kvantifiseringer på overlappende mønstre.

/regex

Regex-tester: Test regulære uttrykk live

Test regulære uttrykk live med treff-markering, fangstgrupper og sanntidsforklaringer.

Mønster

/ /

g, global, finn alle treff, ikke bare det første
i, ignorer store/små bokstaver
m, flere linjer, ^ og $ matcher start/slutt på hver linje
s, dotall, . matcher også linjeskift
u, unicode, tolk mønsteret som unicode

Eksempler, klikk for å sette inn

Testtekst

Treff 0

Juksekart for regex

.	vilkårlig tegn (unntatt linjeskift)
\	escape, bokstavelig spesialtegn
a\|b	a eller b
^ / $	start / slutt på tekst (eller linje med m-flagg)
\w / \W	ordtegn (a-z, 0-9, _) / ikke-ordtegn
\d / \D	siffer / ikke-siffer
\s / \S	mellomrom / ikke-mellomrom
\b	ordgrense
*	gjenta forrige token 0 eller flere ganger
+	gjenta forrige token 1 eller flere ganger
?	forrige token er valgfritt (0 eller 1 gang)
{n} / {n,m}	nøyaktig n ganger / mellom n og m ganger
[abc]	tegnutvalg (hvilket som helst av disse)
(...)	fangstgruppe
(?:...)	gruppe uten fangst

Slik fungerer det

Et regulært uttrykk (regex) er et søkemønster som beskriver hvilke tekstbiter du leter etter. Skriv mønsteret i feltet øverst og teksten din i feltet under, treff markeres live etter hvert som du skriver, og antall treff vises.

Flagg

Flaggene til høyre for mønsteret endrer hvordan søket oppfører seg. «g» (global) er på som standard og trengs for å finne mer enn ett treff. «i» gjør søket ufølsomt for store/små bokstaver.

Grupper

Parenteser () lager fangstgrupper, delene av treffet du vil hente ut hver for seg. De vises i tabellen «Grupper i første treff» som $1, $2 osv. Bruk (?<navn>…) for navngitte grupper.

Tips: Trykk på et eksempel over for å komme raskt i gang, og åpne juksekartet for en oversikt over de vanligste tegnene. Alt kjøres lokalt i nettleseren din.

Om dette verktøyet

Regulære uttrykk (regex) er et lite mønsterspråk som lar deg søke, matche og erstatte tekst basert på strukturelle regler i stedet for eksakte strenger. Én linje regex kan gjøre jobben til hundrevis av `if`-setninger, men syntaksen er kompakt og feilene er ofte kryptiske. Dette verktøyet lar deg skrive et mønster, se treffene markert i teksten din i sanntid, prøve ulike flagg (`g`, `i`, `m`, `s`, `u`) og teste erstatningsmønstre med capture groups. Alt kjøres med JavaScripts innebygde regex-motor lokalt i nettleseren.

Slik bruker du det

Skriv regex-mønsteret ditt i mønster-feltet (uten skråstreker rundt).
Velg flagg, `g` for alle treff, `i` for case-insensitive, `m` for flerlinje-modus, `s` for at `.` matcher newline.
Lim inn teksten du vil søke i, og se treffene bli markert direkte.
For erstatning: skriv erstatningsstrengen med `$1`, `$2` osv. for capture groups.
Ved syntaksfeil vises feilmeldingen fra JavaScript-motoren under mønster-feltet.

Eksempler

Match e-postadresser

Inn[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}

Enkel og «god nok» e-post-regex. En 100 % korrekt en er faktisk over 6 000 tegn lang (se RFC 5322).

Erstatte med capture groups

Inn(\d{4})-(\d{2})-(\d{2})

Ut$3.$2.$1

Konverterer «2026-07-05» til «05.07.2026». Grupper med parenteser fanges opp og refereres i erstatningsstrengen som `$1`, `$2`, `$3`.

Ord som helhet

Inn\bcat\b

`\b` er en «word boundary», matcher «cat» men ikke «cats», «scat» eller «concatenation».

Vanlige bruksområder

Validere skjemainndata (postnummer, telefonnummer, e-post) på klientsiden.
Trekke ut alle URL-er, hashtags eller versjonsnummer fra et dokument.
Bulk-rename filer eller kolonner ved å matche mønster og bruke capture groups.
Rense loggfiler ved å fjerne timestamps eller IP-adresser.
Konvertere tekst mellom formater (Markdown-lenker, CSV-kolonner, dato-representasjoner).
Verifisere at strenger følger et bestemt format før du sender dem videre.

Ofte stilte spørsmål

Hvorfor matcher «greedy» mønsteret mitt for mye?: Kvantifiseringene `*`, `+` og `?` er som standard grådige, de tar med så mye som mulig. Legg til `?` etter (som `.*?`) for ikke-grådig matching som stopper ved første mulige treff.
Kan jeg parse HTML med regex?: Nei, i hvert fall ikke pålitelig. HTML er ikke et regulært språk, så en regex kan aldri korrekt håndtere nestede tagger, kommentarer og CDATA. Bruk en DOM-parser (`DOMParser` i nettleseren) i stedet. Regex er greit for enkle uttrekk fra kjent, kontrollert HTML.
Hva er forskjellen på `.` og `[.]`?: `.` matcher et hvilket som helst tegn (unntatt newline, med mindre `s`-flagget er satt). `[.]` er en tegnklasse som matcher bare et bokstavelig punktum. Bruk `[.]` (eller `\.`) når du faktisk mener «punktum».
Hva er «catastrophic backtracking»?: Når et mønster kan matche samme tekst på mange forskjellige måter (typisk `(a+)+`), kan motoren bruke eksponentielt lang tid på å utforske alle mulighetene. Dette kan låse nettleseren eller føre til DoS-angrep (ReDoS). Unngå nestede kvantifiseringer på overlappende mønstre.

Teknisk bakgrunn

JavaScript-regex (ECMAScript-standard) er implementert som en NFA-basert backtracking-motor. Den støtter Unicode-modus (`u`-flagg) og named capture groups (`(?<name>…)`). Fra ES2018 kom lookbehind (`(?<=…)`, `(?<!…)`) og `s`-flagget (dotAll). Nettleserens motor er svært rask for enkle mønstre, men kan ha eksponentiell worst case for patologiske mønstre (se ReDoS). For sikker validering av bruker-input i backend, vurder RE2-baserte motorer (Go, Rust) som garanterer lineær tid.