Estrarre gruppi di cattura con nome da un pattern regex
Incolli un pattern come (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2}) e ottenga i suoi gruppi con nome in ordine: year, month e day. Il pattern viene verificato ma mai eseguito, pronto per la documentazione o per modelli di sostituzione. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Schema
- (?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})
- Gruppi con nome
- year, month, day
- Quantità
- 3
<name>...) rispetto ai soli gruppi numerati. Questa capacità accetta un unico corpo regex ECMAScript, verifica che il pattern compili e restituisce l'elenco ordinato degli identificatori di gruppi di cattura con nome che dichiara.
A cosa servono i gruppi di cattura con nome
Un gruppo di cattura con nome si scrive con una parentesi aperta, un punto interrogativo, un nome tra i segni di minore e maggiore, poi il sotto-pattern e una parentesi chiusa, come in (?<year>\d{4}). Quando c'è una corrispondenza, quei nomi diventano etichette leggibili: il codice legge l'anno per nome invece di indovinare quale gruppo numerato lo contiene. Per questo i pattern lunghi delle librerie condivise, dei lettori di moduli e dei validatori tendono a dare un nome ai gruppi: chi eredita il pattern vede cosa cattura ogni parte.
Elencare i nomi senza cercare corrispondenze
Prima di scrivere modelli di sostituzione, generare tipi per un validatore o offrire segnaposto come $<name> in una schermata di modifica, le serve l'elenco esatto dei nomi che il pattern definisce. Lo strumento verifica che il pattern sia valido e legge i nomi da sinistra a destra, nell'ordine di dichiarazione. I gruppi senza nome e quelli non catturanti restano fuori, le asserzioni lookbehind non vengono scambiate per nomi e il contenuto delle parentesi quadre non genera mai voci false. Un pattern senza gruppi con nome restituisce semplicemente un elenco vuoto.
Cosa sono i gruppi di cattura con nome e perché elencarli aiuta
Nelle espressioni regolari ECMAScript, un gruppo di cattura con nome si scrive come parentesi aperta, punto interrogativo, minore, un identificatore, maggiore, il sottopattern e la parentesi chiusa: ad esempio open-paren question-mark less-than year greater-than backslash-d open-brace four close-brace close-paren. Quando una corrispondenza ha successo, il motore espone quei nomi sull'oggetto groups così il chiamante legge match.groups.year invece di match[1].
Elencare i nomi senza eseguire una corrispondenza è utile ogni volta che documenta un pattern, genera tipi TypeScript per un validatore o costruisce un'interfaccia che offre token di sostituzione come dollar-less-than name greater-than. I gruppi catturanti senza nome e i non catturanti vengono ignorati per l'elenco dei nomi. Le asserzioni lookbehind che iniziano con question-mark less-than equals o question-mark less-than exclamation non sono trattate come gruppi con nome.
Classi di caratteri e parentesi con escape non producono mai falsi positivi, così una stringa letterale con i caratteri di un apri-gruppo con nome tra parentesi quadre non compare nel risultato.
Casi d'uso
Autodocumentare librerie regex
Generi una tabella di identificatori di gruppi di cattura con nome per ogni pattern di una libreria condivisa così la documentazione resta allineata al codice sorgente.
Domande frequenti
I lookbehind sono trattati come gruppi con nome?
No. Le asserzioni scritte come (? <=...) o (? <!...) vengono saltate. Solo i gruppi di cattura (? <name>...) compaiono nell'elenco.
Che cosa succede se il pattern non ha gruppi con nome?
Riceve un elenco vuoto e un conteggio pari a zero, non un errore. Viene rifiutato solo un pattern che il motore delle espressioni regolari non accetta, per esempio uno con la sintassi errata.
Lo strumento prova il pattern su un testo?
No. Verifica soltanto che il pattern sia valido e legge i nomi da sinistra a destra, nell'ordine in cui sono dichiarati. Non cerca corrispondenze, quindi non serve alcun testo di esempio.
Due gruppi possono avere lo stesso nome?
No. I motori attuali rifiutano i nomi duplicati quando compilano il pattern, quindi lo strumento la avvisa con un messaggio chiaro invece di restituire un elenco con lo stesso nome due volte.
I gruppi senza nome o le parentesi quadre vengono contati?
No. I gruppi numerati normali e quelli non catturanti restano fuori dall'elenco, e i caratteri tra parentesi quadre o le parentesi con escape non producono mai un nome falso, anche se somigliano all'apertura di un gruppo.
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/dev/regex-named-group-extract \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"pattern":"(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})"}'const res = await fetch("https://api.kit.forhosting.com/dev/regex-named-group-extract", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"pattern": "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})"
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/dev/regex-named-group-extract",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"pattern": "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})"
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/dev/regex-named-group-extract", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"pattern":"(?<year>\\\\d{4})-(?<month>\\\\d{2})-(?<day>\\\\d{2})"}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"pattern":"(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})"}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/dev/regex-named-group-extract", 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": "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})"
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "dev.regex_named_group_extract",
"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.
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
I gruppi di cattura con nome trasformano indici di corrispondenza opachi in nomi di campo leggibili come year, month e email_local; per questo le librerie regex moderne e i validatori API preferiscono (? Quando eredita un pattern lungo, genera documentazione o collega un analizzatore di moduli, spesso le serve l'elenco dei nomi che il pattern definisce davvero prima di scrivere modelli di sostituzione o mappare i gruppi in JSON. I pattern senza gruppi con nome hanno successo con un elenco vuoto anziché un errore; solo la sintassi che il motore rifiuta fallisce con invalid_input.
Cosa sono i gruppi di cattura con nome e perché elencarli aiuta
Questo endpoint non esegue la regex su testo di esempio; valida solo il pattern ed estrae i nomi nell'ordine di definizione da sinistra a destra. Nomi duplicati falliscono in compilazione sui motori ECMAScript attuali e emergono come invalid_input con un messaggio chiaro.
Contratto di input, forma della risposta e comportamento di errore
Il valore deve essere una stringa non vuota di al massimo diecimila caratteri. Pattern vuoto, pattern assente o un tipo non stringa falliscono la validazione prima della compilazione. Invii con POST un corpo JSON con un campo stringa obbligatorio: pattern, il corpo dell'espressione regolare senza barre circostanti. In caso di successo il corpo ripete pattern, restituisce named_groups come array di stringhe in ordine di definizione, count come lunghezza dell'array e has_named_groups come flag booleano di comodo. Esempio: il pattern di data con tre gruppi con nome per year, month e day produce count tre e has_named_groups true. Un semplice matching di parole come backslash-w plus senza gruppi con nome produce un array named_groups vuoto, count zero e has_named_groups false—resta comunque una chiamata riuscita perché il pattern è valido. Usi lo strumento gratuito del browser per un'ispezione rapida; usi l'API quando pipeline CI o plugin CMS necessitano di un elenco stabile e leggibile da macchina dei nomi di gruppo per ogni pattern in un file di configurazione.
Dove estrarre i gruppi con nome porta valore concreto
I siti di documentazione e le guide di stile che pubblicano librerie regex possono generare automaticamente una tabella di nomi di gruppo per ogni pattern senza mantenere a mano un elenco parallelo che va fuori sincronia. Costruttori di moduli e parser di log che accettano pattern forniti dall'utente possono rifiutare modelli che riferiscono token dollar-less-than name greater-than assenti dal pattern, riducendo sorprese a runtime. La validazione fallita non consuma saldo. Le checklist di revisione della sicurezza chiedono spesso quali campi cattura una regex di validazione; restituire l'elenco dei nomi da una piccola API di parse costa meno che montare un debugger regex completo per ogni pull request.
Casi di integrazione
Validare modelli di sostituzione
Prima di salvare una regola di replace che usa token $<name>, confermi che ogni nome esista nell'elenco named_groups del pattern.
Controlli CI per form e log
Faccia fallire una pipeline quando una regex di configurazione afferma di catturare email o order_id ma non definisce il gruppo con nome corrispondente.
Domande tecniche
Come estraggo i gruppi di cattura con nome da una regex?
Invii un corpo JSON con pattern impostato sul corpo regex ECMAScript (senza barre). L'API restituisce named_groups in ordine di definizione, più count e has_named_groups.
Cosa succede se il pattern non è valido?
L'attività fallisce con invalid_input e un messaggio che include l'errore del motore. I pattern non validi non vengono addebitati.
Un pattern senza gruppi con nome restituisce un errore?
No. I pattern validi con soli gruppi numerati o non catturanti hanno successo con un array named_groups vuoto e count zero.
Quanto costa estrarre i gruppi con nome da una regex?
Lo strumento del browser è gratuito. Le richieste API usano il saldo prepagato KIT a $0.002 per chiamata riuscita; l'input non valido non viene addebitato.