^
Inizio riga/stringa
Esempio pratico
^Hello # match "Hello world" ma non "say Hello"
developer reference
Reference pratica per usare Regex tutti i giorni con ricerca, copia comando e stampa PDF. Finalmente un sito che non ti obbliga a scavare in dieci tab aperti.
Il tester usa JavaScript RegExp con ricerca globale (g). Per i gruppi nominati usa (?<name>...). La sintassi e i flag Python re mostrati sotto funzionano in Python, non in questo tester. Limiti: 100.000 caratteri di testo, 4.000 nel pattern, 1.000 match; i pattern lenti vengono interrotti.
35 comandi visibili
^
Inizio riga/stringa
^Hello # match "Hello world" ma non "say Hello"
$
Fine riga/stringa
world$ # match "Hello world" ma non "world class"
\b
Word boundary: confine parola/non-parola
\bcat\b # "cat" ma non "catch" o "concat"
\B
Non-word boundary
\Bcat\B # "concatenate" ma non " cat "
*
0 o più volte (greedy)
ab*c # "ac", "abc", "abbc", "abbbc"...
+
1 o più volte (greedy)
ab+c # "abc", "abbc" ma NON "ac"
?
0 o 1 volta (opzionale)
colou?r # "color" e "colour"
{n,m}
Tra n e m volte
\d{2,4} # 2, 3 o 4 cifre
\d{3} # esattamente 3 cifre
*? +? ??
Versioni lazy (non-greedy)
# input: "<b>bold</b>"
<.+> # greedy: "<b>bold</b>"
<.+?> # lazy: "<b>" poi "</b>"
[abc]
Character class: uno tra i caratteri elencati
[aeiou] # qualsiasi vocale
[a-z] # a-z minuscolo
[A-Za-z0-9]
[^abc]
Negazione: qualsiasi carattere esclusi quelli elencati
[^0-9] # non cifre
\d \w \s
Shorthand: \d cifra, \w parola, \s spazio
\d # [0-9]
\w # [a-zA-Z0-9_]
\s # [ \t\n\r]
\D \W \S
Negazioni degli shorthand
\D # non cifra
\W # non parola
\S # non spazio
.
Qualsiasi carattere tranne i terminatori di riga; il flag s (Python re.S) include i ritorni a capo
a.b # "aXb", "a b", "a1b"...
(...)
Gruppo catturante: cattura il match
(\d{4})-(\d{2})-(\d{2})
# match "2024-01-15", group(1)="2024"
(?:...)
Gruppo non catturante: raggruppa senza catturare
(?:Mr|Mrs|Ms)\.\s\w+
# raggruppa alternative senza catturarle
(?<name>...)
Named group: cattura con nome
JavaScript: (?<year>\d{4})-(?<month>\d{2})
match.groups.year
Python: (?P<year>\d{4})-(?P<month>\d{2})
m.group("year")
a|b
Alternativa: a oppure b
cat|dog # "cat" o "dog"
(https?|ftp)://
(?=...) (?!...)
Lookahead positivo e negativo
\d+(?= euro) # numero seguito da " euro" (non cattura " euro")
\d+(?! euro) # numero NON seguito da " euro"
(?<=...) (?<!...)
Lookbehind positivo e negativo
(?<=\$)\d+ # numero preceduto da "$"
re.search (pattern, string)
Trova prima occorrenza in qualunque posizione
import re
m = re.search(r"\d+", "abc 123 def")
if m:
print(m.group()) # "123"
re.match (pattern, string)
Match solo all'inizio della stringa
re.match(r"\d+", "123abc") # match
re.match(r"\d+", "abc123") # None
re.findall (pattern, string)
Restituisce lista di tutti i match
re.findall(r"\d+", "1 apple, 2 bananas, 3 pears")
# → ["1", "2", "3"]
re.sub (pattern, repl, string)
Sostituisce match con repl
re.sub(r"\s+", " ", "too many spaces")
# → "too many spaces"
re.sub(r"(\w+)", r"[\1]", "hello world")
# → "[hello] [world]" (backreference)
re.split (pattern, string)
Splitta stringa sui match del pattern
re.split(r"[,;\s]+", "a, b; c d")
# → ["a", "b", "c", "d"]
re.compile (pattern, flags)
Precompila pattern per uso ripetuto
EMAIL = re.compile(r"[\w.+-]+@[\w-]+\.[\w.]+")
for line in lines:
if EMAIL.search(line): ...
re.IGNORECASE
Case-insensitive matching
re.findall(r"hello", text, re.I)
re.compile(r"hello", re.IGNORECASE)
re.MULTILINE
^ e $ matchano inizio/fine di ogni riga
re.findall(r"^\w+", text, re.M)
re.DOTALL
Il punto (.) matcha anche newline
re.search(r"<div>.+?</div>", html, re.S)
re.VERBOSE
Permette commenti nel pattern (re.X)
pattern = re.compile(r"""
\d{4} # anno
-
\d{2} # mese
""", re.X)
[\w.+-]+@[\w-]+\.[a-zA-Z]{2,}
Pattern semplificato per email; non è un validatore completo
[\w.+-]+@[\w-]+\.[a-zA-Z]{2,}
https?://[\w/:%#$&?()~.=+\-]+
Pattern semplificato per URL HTTP/HTTPS; non è un parser completo
https?://[\w/:%#$&?()~.=+\-]+
\b(?:\d{1,3}\.){3}\d{1,3}\b
Pattern con forma IPv4; non verifica gli intervalli degli ottetti (0–255)
\b(?:\d{1,3}\.){3}\d{1,3}\b
\b\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])\b
Pattern con forma YYYY-MM-DD; non verifica la validità della data
\b\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\d|3[01])\b
(?:\+39)?[\s-]?(?:0\d{1,4}|3\d{2})[\s-]?\d{6,8}
Pattern semplificato per telefoni italiani; non conferma che il numero sia valido o assegnato
(?:\+39)?[\s-]?(?:0\d{1,4}|3\d{2})[\s-]?\d{6,8}
Il tester usa JavaScript RegExp. Sintassi Python come (?P<name>...) e re.VERBOSE vanno provate in Python. I pattern pronti illustrano formati, non una validazione completa.
Usa Stampa PDF. La versione stampabile include tutti i comandi e gli esempi pratici, anche nelle sezioni nascoste dalla ricerca.
Sì. Servi i file statici con un server HTTP locale. Ricerca, filtri e copia funzionano nel browser; il tester Regex richiede un contesto HTTP con worker abilitati.