Tester Regex
Testa espressioni regolari su una stringa e visualizza tutte le corrispondenze evidenziate
Pattern
Stringa di test
Che cos'è un'espressione regolare?
Un'espressione regolare (regex o regexp) è una sequenza di caratteri che definisce un pattern di ricerca. I tester regex ti permettono di scrivere un pattern, applicarlo a un testo di esempio e vedere tutte le corrispondenze evidenziate in tempo reale. Il concetto risale al lavoro del matematico Stephen Kleene sui linguaggi regolari negli anni '50, e Ken Thompson integrò il primo motore regex nell'editor di testo QED nel 1968.
Un motore regex legge il pattern da sinistra a destra, consumando i caratteri dell'input mentre cerca una corrispondenza. Usa il backtracking quando un'abbinamento parziale fallisce: il motore torna indietro e prova percorsi alternativi attraverso il pattern. Alcuni motori (come RE2 usato in Go) evitano il backtracking convertendo i pattern in automi a stati finiti deterministici (DFA), il che garantisce la corrispondenza in tempo lineare al costo di non supportare funzionalità come i back-reference.
La sintassi regex è standardizzata in modo approssimativo. PCRE (Perl Compatible Regular Expressions) è il dialetto più diffuso, supportato da PHP, dal modulo re di Python e da JavaScript con piccole differenze. POSIX definisce una sintassi più limitata usata da grep e sed. Le differenze contano quando si portano pattern tra linguaggi: un lookahead che funziona in JavaScript potrebbe non compilare affatto nel motore RE2 di Go.
Perché usare un tester regex online?
Scrivere regex in un file di codice significa salvare, eseguire e ispezionare l'output ogni volta che si modifica il pattern. Un tester regex basato su browser riduce quel ciclo di feedback a zero: digiti e vedi subito le corrispondenze.
Casi d'uso del tester regex
Guida rapida alla sintassi regex
La tabella seguente copre i token regex più usati. Funzionano con JavaScript, Python, Go, PHP e la maggior parte dei motori compatibili con PCRE. Le estensioni specifiche del linguaggio (come i pattern condizionali di Python o i gruppi con nome di JavaScript con la sintassi \k) sono indicate nella sezione degli esempi di codice.
| Pattern | Nome | Descrizione |
|---|---|---|
| . | 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 |
I flag regex spiegati
I flag (detti anche modificatori) cambiano il modo in cui il motore elabora il pattern. In JavaScript si aggiungono dopo la barra di chiusura: /pattern/gi. In Python si passano come secondo argomento: re.findall(pattern, text, re.IGNORECASE | re.MULTILINE). Non tutti i flag sono disponibili in ogni linguaggio.
| Flag | Nome | Comportamento |
|---|---|---|
| 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 |
Esempi di codice
Esempi di regex funzionanti in JavaScript, Python, Go e riga di comando. Ogni esempio mostra la costruzione del pattern, l'estrazione delle corrispondenze e l'output.
// 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