Regex Tester
Testa reguljära uttryck mot en sträng och markera alla träffar
Mönster
Teststräng
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.
Användningsfall för Regex Tester
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önster | Namn | Beskrivning |
|---|---|---|
| . | Any character | Matches any single character except newline (unless s flag is set) |
| \d | Digit | Matches [0-9] |
| \w | Word character | Matches [a-zA-Z0-9_] |
| \s | Whitespace | Matches space, tab, newline, carriage return, form feed |
| \b | Word boundary | Matches the position between a word character and a non-word character |
| ^ | Start of string/line | Matches the start of the input; with m flag, matches start of each line |
| $ | End of string/line | Matches the end of the input; with m flag, matches end of each line |
| * | Zero or more | Matches the preceding token 0 or more times (greedy) |
| + | One or more | Matches the preceding token 1 or more times (greedy) |
| ? | Optional | Matches the preceding token 0 or 1 time |
| {n,m} | Quantifier range | Matches the preceding token between n and m times |
| () | Capturing group | Groups tokens and captures the matched text for back-references |
| (?:) | Non-capturing group | Groups tokens without capturing the matched text |
| (?=) | Positive lookahead | Matches a position followed by the given pattern, without consuming it |
| (?<=) | Positive lookbehind | Matches a position preceded by the given pattern, without consuming it |
| [abc] | Character class | Matches any one of the characters inside the brackets |
| [^abc] | Negated class | Matches any character not inside the brackets |
| | | Alternation | Matches 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.
| Flagga | Namn | Beteende |
|---|---|---|
| g | Global | Find all matches, not just the first one |
| i | Case-insensitive | Letters match both uppercase and lowercase |
| m | Multiline | ^ and $ match start/end of each line, not just the whole string |
| s | Dot-all | . matches newline characters as well |
| u | Unicode | Treat the pattern and subject as a Unicode string; enables \u{FFFF} syntax |
| y | Sticky | Matches 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.
// 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"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']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]
}# 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