Regex Tester

Testa reguljära uttryck mot en sträng och markera alla träffar

Prova ett exempel

Mönster

//g

Teststräng

Körs lokalt · Säkert att klistra in hemligheter

Vad är ett reguljärt uttryck?

Ett reguljärt uttryck (regex eller regexp) är en teckensekvens som definierar ett sökmönster. Med en regex-testare kan du skriva ett mönster, köra det mot ett exempeltext och se alla träffar markerade i realtid. Konceptet härstammar från matematikern Stephen Kleenes arbete med reguljära språk på 1950-talet, och Ken Thompson byggde in den första regex-motorn i textredigeraren QED 1968.

En regex-motor läser ett mönster från vänster till höger och förbrukar tecken i indata när den försöker matcha. Den använder backtracking när en partiell matchning misslyckas: motorn backar och försöker alternativa vägar genom mönstret. Vissa motorer (som RE2 som används i Go) undviker backtracking helt genom att konvertera mönster till deterministiska ändliga automater (DFA), vilket garanterar linjär tidsmatchning men på bekostnad av att inte stödja funktioner som bakåtreferenser.

Regex-syntax är löst standardiserad. PCRE (Perl Compatible Regular Expressions) är den vanligaste varianten och stöds av PHP, Pythons re-modul och JavaScript med smärre skillnader. POSIX definierar en mer begränsad syntax som används av grep och sed. Skillnaderna spelar roll när mönster porteras mellan språk: en lookahead som fungerar i JavaScript kanske inte kompileras alls i Go:s RE2-motor.

Varför använda en online-regex-testare?

Att skriva regex i en kodfil innebär att du måste spara, köra och granska utdata varje gång du justerar mönstret. En webbläsarbaserad regex-testare eliminerar den feedbackcykeln: du skriver, du ser träffarna.

Träffmarkering i realtid
Varje tangenttryckning uppdaterar matchningsresultaten direkt. Du ser vilka delar av texten som matchar, vilka fångstgrupper som är fyllda och exakt var varje träff börjar och slutar. Ingen kompilera-kör-felsök-cykel.
🔒
Integritetsfokuserad bearbetning
Mönstermatchningen körs i din webbläsare med hjälp av JavaScript RegExp-motorn. Ingen text eller mönster skickas till en server. Det är viktigt när du testar mot loggfiler, kunddata eller API-svar som innehåller känslig information.
🔍
Visuell granskning av träffar
Träffar markeras inline med sina positioner och fångstgruppsvärden visade. Att se träffar visuellt gör det lättare att fånga off-by-one-fel i kvantifierare eller saknade ankare.
🌐
Ingen inloggning eller installation krävs
Fungerar på vilken enhet som helst med en modern webbläsare. Inget konto, ingen tillägg, ingen IDE-plugin. Öppna sidan, klistra in ditt mönster och din text och börja testa.

Användningsfall för Regex Tester

Validering av formulärinmatning i frontend
Bygg och verifiera mönster för e-post-, telefonnummer- eller kreditkortsfält innan de bäddas in i HTML5-mönsterattribut eller JavaScript-valideringslogik.
Parsning av backend-loggar
Skriv regex-mönster som extraherar tidsstämplar, felkoder eller IP-adresser från applikationsloggar. Testa mot riktiga loggexempel för att bekräfta att mönstret fångar rätt grupper.
DevOps och infrastruktur
Felsök regex som används i Nginx-platsblock, Apache-omskrivningsregler eller Prometheus-varningsregler. Ett felaktigt mönster i en serverkonfiguration kan bryta routing eller missa varningar helt.
QA och testautomatisering
Validera att svarskroppar eller HTML-utdata matchar förväntade mönster i end-to-end-testassertioner. Förtesta regex här innan du inkluderar det i din testsvit.
Datautvinnings-pipelines
Prototyptesta mönster för att extrahera strukturerade fält från ostrukturerad text: skrapning av produktpriser, parsning av CSV-kantfall eller hämtning av metadata från e-posthuvuden.
Lär dig reguljära uttryck
Experimentera med metatecken, kvantifierare och grupper mot exempelsträngar. Omedelbar visuell feedback gör regex-syntax lättare att lära sig än att enbart läsa dokumentation.

Snabbreferens för regex-syntax

Tabellen nedan täcker de mest använda regex-symbolerna. Dessa fungerar i JavaScript, Python, Go, PHP och de flesta PCRE-kompatibla motorer. Språkspecifika tillägg (som Pythons villkorliga mönster eller JavaScripts namngivna grupper med \k-syntax) noteras i kodexempelavsnittet.

MönsterNamnBeskrivning
.Any characterMatches any single character except newline (unless s flag is set)
\dDigitMatches [0-9]
\wWord characterMatches [a-zA-Z0-9_]
\sWhitespaceMatches space, tab, newline, carriage return, form feed
\bWord boundaryMatches the position between a word character and a non-word character
^Start of string/lineMatches the start of the input; with m flag, matches start of each line
$End of string/lineMatches the end of the input; with m flag, matches end of each line
*Zero or moreMatches the preceding token 0 or more times (greedy)
+One or moreMatches the preceding token 1 or more times (greedy)
?OptionalMatches the preceding token 0 or 1 time
{n,m}Quantifier rangeMatches the preceding token between n and m times
()Capturing groupGroups tokens and captures the matched text for back-references
(?:)Non-capturing groupGroups tokens without capturing the matched text
(?=)Positive lookaheadMatches a position followed by the given pattern, without consuming it
(?<=)Positive lookbehindMatches a position preceded by the given pattern, without consuming it
[abc]Character classMatches any one of the characters inside the brackets
[^abc]Negated classMatches any character not inside the brackets
|AlternationMatches the expression before or after the pipe

Regex-flaggor förklarade

Flaggor (kallas även modifierare) ändrar hur motorn behandlar mönstret. I JavaScript läggs de till efter det avslutande snedstrecket: /pattern/gi. I Python skickas de som ett andra argument: re.findall(pattern, text, re.IGNORECASE | re.MULTILINE). Alla flaggor finns inte tillgängliga i alla språk.

FlaggaNamnBeteende
gGlobalFind all matches, not just the first one
iCase-insensitiveLetters match both uppercase and lowercase
mMultiline^ and $ match start/end of each line, not just the whole string
sDot-all. matches newline characters as well
uUnicodeTreat the pattern and subject as a Unicode string; enables \u{FFFF} syntax
yStickyMatches only from the lastIndex position in the target string

Kodexempel

Fungerande regex-exempel i JavaScript, Python, Go och på kommandoraden. Varje exempel visar mönsterkonstruktion, extrahering av träffar och utdata.

JavaScript
// Match all email addresses in a string
const text = 'Contact us at support@example.com or sales@example.com'
const emailRegex = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g

const matches = text.matchAll(emailRegex)
for (const match of matches) {
  console.log(match[0], 'at index', match.index)
}
// → "support@example.com" at index 14
// → "sales@example.com" at index 37

// Named capture groups (ES2018+)
const dateRegex = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
const result = '2026-03-30'.match(dateRegex)
console.log(result.groups)
// → { year: "2026", month: "03", day: "30" }

// Replace with a callback
'hello world'.replace(/\b\w/g, c => c.toUpperCase())
// → "Hello World"
Python
import re

# Find all IPv4 addresses
text = 'Server 192.168.1.1 responded, fallback to 10.0.0.255'
pattern = r'\b(?:\d{1,3}\.){3}\d{1,3}\b'

matches = re.findall(pattern, text)
print(matches)  # → ['192.168.1.1', '10.0.0.255']

# Named groups and match objects
date_pattern = r'(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})'
m = re.search(date_pattern, 'Released on 2026-03-30')
if m:
    print(m.group('year'))   # → '2026'
    print(m.group('month'))  # → '03'

# Compile for repeated use (faster in loops)
compiled = re.compile(r'\b[A-Z][a-z]+\b')
words = compiled.findall('Hello World Foo bar')
print(words)  # → ['Hello', 'World', 'Foo']
Go
package main

import (
	"fmt"
	"regexp"
)

func main() {
	// Find all matches
	re := regexp.MustCompile(`\b[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}\b`)
	text := "Contact support@example.com or sales@example.com"
	matches := re.FindAllString(text, -1)
	fmt.Println(matches)
	// → [support@example.com sales@example.com]

	// Named capture groups
	dateRe := regexp.MustCompile(`(?P<year>\d{4})-(?P<month>\d{2})-(?P<day>\d{2})`)
	match := dateRe.FindStringSubmatch("2026-03-30")
	for i, name := range dateRe.SubexpNames() {
		if name != "" {
			fmt.Printf("%s: %s\n", name, match[i])
		}
	}
	// → year: 2026
	// → month: 03
	// → day: 30

	// Replace with a function
	result := re.ReplaceAllStringFunc(text, func(s string) string {
		return "[REDACTED]"
	})
	fmt.Println(result)
	// → Contact [REDACTED] or [REDACTED]
}
CLI (grep / sed)
# Find lines matching an IP address pattern
grep -E '\b([0-9]{1,3}\.){3}[0-9]{1,3}\b' access.log

# Extract email addresses from a file
grep -oE '[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}' contacts.txt

# Replace dates from YYYY-MM-DD to DD/MM/YYYY using sed
echo "2026-03-30" | sed -E 's/([0-9]{4})-([0-9]{2})-([0-9]{2})/\3\/\2\/\1/'
# → 30/03/2026

# Count matches per file in a directory
grep -rcE 'TODO|FIXME|HACK' src/
# → src/main.js:3
# → src/utils.js:1

Vanliga frågor

Vad är skillnaden mellan regex och glob-mönster?
Glob-mönster (som *.txt eller src/**/*.js) är en förenklad jokerteckensyntax som används för filsökvägsmatchning i skal och byggverktyg. De stöder * (valfria tecken), ? (ett tecken) och [] (teckensklasser) men saknar kvantifierare, grupper, lookaheads och alternering. Regex är mycket mer uttrycksfullt och opererar på godtycklig text, inte bara filsökvägar. Ett glob-mönster *.json motsvarar ungefär regex ^.*\.json$.
Hur matchar jag en literal punkt eller hakparentes i regex?
Lägg till ett omvänt snedstreck före tecknet: \. matchar en literal punkt, \[ matchar en literal hakparentes. Inuti en teckenklass [] är en punkt redan literal och behöver inte escapes. Ett vanligt misstag är att skriva 192.168.1.1 utan att escapa punkterna, vilket matchar 192x168y1z1 eftersom . betyder "valfritt tecken".
Skickas mina testdata till en server?
Nej. Det här verktyget kör regex-matchning helt i din webbläsare med JavaScript RegExp-motorn. Inga nätverksförfrågningar görs med din text eller ditt mönster. Du kan bekräfta detta genom att öppna webbläsarens DevTools Nätverksflik medan du använder verktyget.
Varför fungerar mitt regex i JavaScript men inte i Python?
JavaScript och Python använder olika regex-motorer med lite olika funktionsuppsättningar. JavaScript stöder \d, lookaheads (?=) och lookbehinds (?<=) sedan ES2018, men stöder inte villkorliga mönster, atomiska grupper eller possessiva kvantifierare. Pythons re-modul stöder inte \p{} Unicode-egenskapsklasser (använd tredjepartsmodulen regex istället). Testa alltid i målspråkets motor eller konsultera språkets regex-dokumentation.
Vad orsakar katastrofal backtracking i regex?
Katastrofal backtracking uppstår när ett mönster har nästlade kvantifierare som skapar ett exponentiellt antal matchningsvägar. Det klassiska exemplet är (a+)+ applicerat på en sträng med a:n följt av ett icke-matchande tecken. Motorn provar alla möjliga sätt att dela upp a:na mellan den inre och yttre gruppen innan den misslyckas. Åtgärda detta genom att använda atomiska grupper (?>), possessiva kvantifierare a++ eller skriva om mönstret för att undvika tvetydig upprepning.
Kan jag använda regex för att parsera HTML?
Regex kan extrahera enkla värden från HTML-fragment, som att hämta href från en enstaka <a>-tagg. För fullständig HTML-parsning, använd en riktig parser (DOMParser i JavaScript, BeautifulSoup i Python eller html/template i Go). HTML är en kontextfri grammatik och regex hanterar reguljära grammatiker. Nästlade taggar, valfria attribut och självstängande element skapar mönster som regex inte kan matcha tillförlitligt.
Vad är skillnaden mellan giriga och lata kvantifierare?
En girig kvantifierare (* eller +) matchar så många tecken som möjligt och backtrackar sedan om resten av mönstret misslyckas. En lat kvantifierare (*? eller +?) matchar så få tecken som möjligt och expanderar bara vid behov. För indata <b>one</b><b>two</b> matchar det giriga mönstret <b>.*</b> hela strängen från den första <b> till den sista </b>, medan det lata mönstret <b>.*?</b> matchar <b>one</b> och <b>two</b> separat.