Tester Regex

Testa espressioni regolari su una stringa e visualizza tutte le corrispondenze evidenziate

Prova un esempio

Pattern

//g

Stringa di test

Esegue in locale · Sicuro per incollare segreti

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.

Evidenziazione in tempo reale
Ogni tasto aggiorna istantaneamente i risultati. Vedi quali parti del testo corrispondono, quali gruppi di cattura sono popolati e dove inizia e finisce ogni corrispondenza. Nessun ciclo compila-esegui-debug.
🔒
Elaborazione privacy-first
La corrispondenza dei pattern viene eseguita nel browser tramite il motore JavaScript RegExp. Nessun testo o pattern viene inviato a un server. Questo è importante quando si testano file di log, dati cliente o risposte API contenenti informazioni sensibili.
🔍
Ispezione visiva delle corrispondenze
Le corrispondenze sono evidenziate inline con le loro posizioni e i valori dei gruppi di cattura visualizzati. Vedere le corrispondenze visivamente rende più facile individuare errori off-by-one nei quantificatori o ancore mancanti.
🌐
Nessun login o installazione richiesti
Funziona su qualsiasi dispositivo con un browser moderno. Nessun account, nessuna estensione, nessun plugin IDE. Apri la pagina, incolla il pattern e il testo, e inizia a testare.

Casi d'uso del tester regex

Validazione input frontend
Costruisci e verifica pattern per campi email, numero di telefono o carta di credito prima di incorporarli negli attributi pattern di HTML5 o nella logica di validazione JavaScript.
Parsing di log backend
Scrivi pattern regex che estraggono timestamp, codici di errore o indirizzi IP dai log applicativi. Testali su campioni di log reali per confermare che il pattern catturi i gruppi giusti.
DevOps e infrastruttura
Esegui il debug di regex usati nei blocchi location di Nginx, nelle regole di riscrittura di Apache o nelle regole di alerting di Prometheus. Un pattern errato nella configurazione del server può rompere il routing o far perdere gli alert.
QA e automazione dei test
Verifica che i body delle risposte o l'output HTML corrispondano ai pattern attesi nelle asserzioni dei test end-to-end. Pre-testa la regex qui prima di inserirla nella tua suite di test.
Pipeline di estrazione dati
Prototipa pattern per estrarre campi strutturati da testo non strutturato: scraping di prezzi di prodotti, parsing di casi limite CSV o estrazione di metadati dalle intestazioni email.
Imparare le espressioni regolari
Sperimenta con metacaratteri, quantificatori e gruppi su stringhe di esempio. Il feedback visivo immediato rende la sintassi regex più facile da imparare rispetto alla sola lettura della documentazione.

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.

PatternNomeDescrizione
.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

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.

FlagNomeComportamento
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

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.

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

Domande frequenti

Qual è la differenza tra pattern regex e glob?
I pattern glob (come *.txt o src/**/*.js) sono una sintassi wildcard semplificata usata per la corrispondenza di percorsi file nelle shell e negli strumenti di build. Supportano * (qualsiasi carattere), ? (un carattere) e [] (classi di caratteri) ma mancano di quantificatori, gruppi, lookahead e alternanza. La regex è molto più espressiva e opera su testo arbitrario, non solo sui percorsi file. Un pattern glob *.json è approssimativamente equivalente alla regex ^.*\.json$.
Come si cerca un punto o una parentesi quadra letterali in regex?
Aggiungi un backslash prima del carattere: \. trova un punto letterale, \[ trova una parentesi quadra letterale. All'interno di una classe di caratteri [], un punto è già letterale e non richiede escape. Un errore comune è scrivere 192.168.1.1 senza fare l'escape dei punti, che trova anche 192x168y1z1 perché . significa "qualsiasi carattere."
I miei dati di test vengono inviati a un server?
No. Questo strumento esegue la corrispondenza regex interamente nel browser usando il motore JavaScript RegExp. Non vengono effettuate richieste di rete con il tuo testo o pattern. Puoi verificarlo aprendo la scheda Network degli strumenti per sviluppatori del browser mentre usi lo strumento.
Perché la mia regex funziona in JavaScript ma non in Python?
JavaScript e Python usano motori regex diversi con set di funzionalità leggermente differenti. JavaScript supporta \d, lookahead (?=) e lookbehind (?<=) dal ES2018, ma non supporta pattern condizionali, gruppi atomici o quantificatori possessivi. Il modulo re di Python non supporta le classi di proprietà Unicode \p{} (usa il modulo regex di terze parti). Testa sempre nel motore del linguaggio di destinazione o consulta la documentazione regex del linguaggio.
Cosa causa il backtracking catastrofico in regex?
Il backtracking catastrofico si verifica quando un pattern ha quantificatori annidati che creano un numero esponenziale di percorsi di corrispondenza. L'esempio classico è (a+)+ applicato a una stringa di a seguite da un carattere non corrispondente. Il motore prova ogni modo possibile di dividere le a tra i gruppi interno ed esterno prima di fallire. Risolvi usando gruppi atomici (?>), quantificatori possessivi a++, o riscrivendo il pattern per evitare la ripetizione ambigua.
Posso usare regex per fare il parsing di HTML?
La regex può estrarre valori semplici da frammenti HTML, come estrarre l'href da un singolo tag <a>. Per il parsing completo di HTML, usa un parser apposito (DOMParser in JavaScript, BeautifulSoup in Python, o html/template in Go). HTML è una grammatica context-free, e la regex gestisce grammatiche regolari. I tag annidati, gli attributi opzionali e gli elementi self-closing creano pattern che la regex non riesce a gestire in modo affidabile.
Qual è la differenza tra quantificatori greedy e lazy?
Un quantificatore greedy (* o +) trova quanti più caratteri possibile, poi torna indietro se il resto del pattern fallisce. Un quantificatore lazy (*? o +?) trova quanti meno caratteri possibile, espandendosi solo se necessario. Per l'input <b>uno</b><b>due</b>, il pattern greedy <b>.*</b> trova l'intera stringa dal primo <b> all'ultimo </b>, mentre il pattern lazy <b>.*?</b> trova <b>uno</b> e <b>due</b> separatamente.