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