Spieghi una regex in linguaggio semplice
Veda che cosa fa ogni pezzo di un’espressione regolare: l’espressione per indirizzi email dell’esempio si divide in 16 parti spiegate con 3 gruppi di cattura, il primo chiamato user, ognuna con la sua posizione e una descrizione chiara. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Flag
- i
- Gusto
- ECMAScript
- Gruppi di cattura
- 3
Un’espressione regolare può stare in una sola riga e nascondere comunque molte regole indipendenti. Questo strumento convalida un pattern ECMAScript, lo esamina da sinistra a destra e identifica gruppi, quantificatori, classi di caratteri, ancore, escape, alternative, caratteri jolly e testo letterale. Ogni componente riporta posizione, profondità di annidamento e una spiegazione chiara, così Lei può esaminare, imparare, documentare e correggere il pattern senza modificarlo né eseguirlo su dati privati.
Legga la spiegazione nell’ordine del pattern
Parta dall’array dei componenti, che segue l’esatto ordine del sorgente da sinistra a destra. Ogni voce identifica un tipo, conserva il token originale e indica un indice a base zero e la lunghezza del token. Queste posizioni collegano la spiegazione ai caratteri precisi di un’espressione lunga, senza dover indovinare a quale parentesi o punto interrogativo si riferisca.
Il valore di profondità mostra dove si trova il token nei gruppi annidati. Le voci di apertura e chiusura rendono esplicita la struttura, mentre i gruppi di cattura ricevono un numero secondo l’ordine di apertura. Le catture denominate conservano anche il proprio nome.
Quando possibile, le sequenze letterali restano unite, così il testo comune rimane leggibile. Legga prima le voci in sequenza, poi usi i conteggi per individuare costrutti da esaminare meglio, come numerosi gruppi annidati o molte alternative.
Comprenda gruppi, classi e ripetizioni
I gruppi definiscono la struttura e talvolta catturano testo da riutilizzare. Una parentesi semplice apre una cattura numerata; la sequenza punto interrogativo e due punti apre un gruppo non catturante; le catture denominate mostrano il nome dichiarato. Lookahead e lookbehind sono distinti perché verificano il testo circostante senza consumarlo.
Le classi di caratteri sono descritte come corrispondenza con un carattere dell’elenco; le classi negate vengono segnalate e gli intervalli semplici, come da A a Z, sono riassunti. Gli escape comuni spiegano cifre, caratteri di parola, spazi, confini, riferimenti all’indietro, proprietà Unicode e caratteri codificati. I quantificatori si applicano concettualmente all’elemento precedente: l’asterisco indica zero o più occorrenze, il segno più una o più, il punto interrogativo rende l’elemento facoltativo e le parentesi graffe indicano una ripetizione esatta, minima o limitata.
Un punto interrogativo finale rende la ripetizione pigra e la spiegazione precisa che preferisce meno ripetizioni.
Convalidi la sintassi e riconosca il dialetto
Il pattern viene convalidato dal motore di espressioni regolari ECMAScript prima che sia restituita qualsiasi spiegazione. È importante perché i dialetti differiscono: una sintassi copiata da PCRE, Python, Java o . NET può avere un significato diverso in JavaScript e alcuni costrutti possono essere rifiutati.
Invii il corpo dell’espressione senza barre delimitatrici e inserisca i flag JavaScript facoltativi nel campo flags. La convalida dimostra che l’espressione viene compilata, ma non che riconosca i dati aziendali desiderati, sia efficiente su ogni input o eviti un backtracking eccessivo. Usi la spiegazione per controllare la struttura, poi provi esempi rappresentativi che debbano corrispondere o meno.
Poiché l’algoritmo è deterministico, non usa la rete e non esamina un testo di prova, lo stesso pattern con gli stessi flag genera sempre la medesima spiegazione strutturata.
Casi d'uso
Esamini un’espressione ereditata
Trasformi un pattern complesso di codice preesistente in un elenco ordinato di costrutti comprensibili prima di modificarlo.
Documenti le regole di convalida
Generi note strutturate su gruppi, caratteri ammessi, ancore e ripetizioni usati da un modulo o servizio.
Impari la sintassi delle regex
Confronti i token originali con spiegazioni concise e posizioni nel sorgente mentre studia i pattern ECMAScript.
Domande frequenti
Quale dialetto di espressioni regolari viene spiegato?
Lo strumento convalida e spiega le espressioni regolari ECMAScript, cioè la sintassi RegExp di JavaScript.
Lo strumento prova il pattern sul mio testo?
No. Spiega soltanto la sintassi e non richiede testo di prova. Per le corrispondenze usi separatamente un tester regex.
Riconosce gruppi di cattura denominati e numerati?
Sì. Le catture sono numerate in ordine di apertura e i gruppi denominati includono anche il nome dichiarato.
Devo includere le barre attorno all’espressione?
No. Inserisca solo il corpo dell’espressione, senza le barre, e indichi le opzioni a parte, per esempio i per ignorare maiuscole e minuscole. Le opzioni non valide o ripetute vengono rifiutate con un messaggio chiaro.
Che cosa significa un punto interrogativo dopo una ripetizione?
Rende la ripetizione pigra, cioè preferisce il minor numero di ripetizioni, e la spiegazione lo dice in modo esplicito. Da solo, subito dopo un elemento, il punto interrogativo rende quell’elemento facoltativo.
Strumenti correlati
Per sviluppatori — accesso via API
Tutto quello che vedi in questa pagina è disponibile anche via API. Questa sezione è per i team che vogliono integrarlo nei propri sistemi; chi non ne ha bisogno può semplicemente usare lo strumento qui sopra.
Endpoint
Autenticazione con Bearer token: un POST mette in coda l'attività e il risultato arriva via webhook o link firmato.
Chiamala dal tuo stack
curl -X POST https://api.kit.forhosting.com/dev2/regex-explain \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"pattern":"^(?<user>[A-Za-z0-9._%+-]+)@([A-Za-z0-9.-]+)\\.([A-Za-z]{2,})$"}'const res = await fetch("https://api.kit.forhosting.com/dev2/regex-explain", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"pattern": "^(?<user>[A-Za-z0-9._%+-]+)@([A-Za-z0-9.-]+)\\.([A-Za-z]{2,})$"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev2/regex-explain",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"pattern": "^(?<user>[A-Za-z0-9._%+-]+)@([A-Za-z0-9.-]+)\\.([A-Za-z]{2,})$"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev2/regex-explain", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"pattern":"^(?<user>[A-Za-z0-9._%+-]+)@([A-Za-z0-9.-]+)\\\\.([A-Za-z]{2,})$"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"pattern":"^(?<user>[A-Za-z0-9._%+-]+)@([A-Za-z0-9.-]+)\\.([A-Za-z]{2,})$"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev2/regex-explain", body)
req.Header.Set("Authorization", "Bearer "+os.Getenv("KIT_KEY"))
req.Header.Set("Content-Type", "application/json")
res, _ := http.DefaultClient.Do(req)Esempio di richiesta
{
"pattern": "^(?<user>[A-Za-z0-9._%+-]+)@([A-Za-z0-9.-]+)\\.([A-Za-z]{2,})$"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev2.regex_explain",
"status": "queued",
"_links": {
"result": "/tasks/tsk_…/result"
}
}L'API è asincrona: ricevi subito un task_id e puoi fare polling fino a 1 richiesta al secondo.
Prezzi
Prezzo pubblicato, senza token né crediti. Se l'attività fallisce, non paghi.
Limiti
max_pattern_chars | 2000 |
Errori
| HTTP | Codice | Significato |
|---|---|---|
401 | unauthorized | Chiave API mancante o non valida: controlla l'header Authorization. |
402 | insufficient_balance | Credito esaurito: ricarica per continuare a eseguire attività. |
404 | unknown_type | Tipo di attività sconosciuto: controlla il campo type della richiesta. |
429 | rate_limited | Troppe richieste in poco tempo: rallenta e riprova tra qualche secondo. |
Note tecniche
Legga la spiegazione nell’ordine del pattern
Il riepilogo offre un conteggio immediato e component_counts è utile per documentazione automatica o rapporti di controllo.
Convalidi la sintassi e riconosca il dialetto
Sintassi non valida, flag non supportati e flag duplicati producono un errore tipizzato invalid_input anziché una spiegazione parziale o fuorviante.
Domande tecniche
Devo includere le barre delimitatrici?
No. Invii solo il corpo in pattern e inserisca flag come i o m nel campo separato flags.
Che cosa accade se la regex non è valida?
La richiesta restituisce un errore invalid_input con il problema di compilazione, senza fornire spiegazioni parziali.
Quanto costa una richiesta API?
Il prezzo base dell’API è $0.002 per richiesta. La stessa logica deterministica funziona anche nel browser.