Verifichi una regex su esempi e controlli i gruppi acquisiti
Applichi un'espressione regolare a un elenco di esempi e veda quali corrispondono e che cosa ha catturato ogni gruppo: su tre esempi ne corrispondono due, e Gadget: 7 restituisce Gadget e 7. Ogni riga viene provata da sola, quindi un risultato non altera il successivo. Gratis nel suo browser.
- Gratis
- Funziona nel suo browser
- Senza registrazione
- I suoi dati restano sul dispositivo
Esegui gratis nel browser
Esempio risolto
- Schema
- ^(?<name>[A-Za-z]+):\s*(\d+)$
- Flag
- i
- Campioni
- Widget: 42, not a record, Gadget: 7
- Numero di campioni
- 3
- Corrispondenze
- 2
Provare un’espressione regolare su una sola stringa scelta con cura raramente ne rivela tutti i problemi. Gli input reali includono record validi, casi simili da rifiutare, differenze tra maiuscole e minuscole, campi facoltativi e valori ripetuti. Questo strumento applica separatamente un pattern regex ECMAScript e i relativi flag a un elenco di stringhe di esempio. Indica quali campioni corrispondono, tutte le occorrenze quando è attiva la ricerca globale e i gruppi numerati e denominati che hanno partecipato. Un pattern non valido o un flag non supportato genera un errore chiaro prima che venga restituito qualsiasi risultato.
Crei campioni che mettano davvero alla prova il pattern
Inserisca il corpo dell’espressione regolare esattamente come lo riceverebbe JavaScript, senza barre delimitatrici. Aggiunga i flag separatamente, così una barra letterale non verrà confusa con un delimitatore. Fornisca quindi esempi che rappresentino sia corrispondenze attese sia errori intenzionali.
Un insieme utile comprende un valore valido comune, un caso limite, varianti tra maiuscole e minuscole quando è rilevante il flag che le ignora, un valore vuoto o incompleto e una stringa con testo simile che non dovrebbe essere accettata. Le ancore di inizio e fine sono particolarmente importanti quando desidera convalidare l’intero campione anziché trovare una sottostringa. Ogni campione viene valutato separatamente con una nuova espressione regolare, quindi lo stato di una ricerca globale o sticky non passa alla stringa successiva.
Il risultato conserva il campione originale e fornisce un booleano di corrispondenza, semplice da leggere o verificare automaticamente. Questa struttura trasforma una fiducia generica nel pattern in esempi ripetibili che ne documentano i confini previsti.
Legga correttamente corrispondenze e gruppi acquisiti
Per ogni campione positivo, l’array delle corrispondenze contiene il testo esatto trovato e il relativo indice UTF-16 a base zero, coerente con l’indicizzazione delle stringhe JavaScript. I gruppi numerati appaiono nell’ordine di apertura delle parentesi come oggetti con numero e valore. I gruppi facoltativi assenti vengono omessi, evitando campi nulli ambigui e conservando il numero originale di ogni gruppo presente.
Senza flag globale, ECMAScript restituisce la prima corrispondenza del campione. Con tale flag, lo strumento continua tra le occorrenze che non si sovrappongono. Le corrispondenze di lunghezza zero avanzano in sicurezza per impedire cicli infiniti.
La ricerca sticky mantiene il comportamento JavaScript nativo: deve riuscire esattamente nella posizione corrente. Esamini sia il testo trovato sia le acquisizioni, perché un esito positivo può comunque nascondere un confine troppo ampio, troppo stretto o collegato all’alternativa sbagliata.
Utilizzi errori e limiti nei controlli automatici
Il pattern e i flag vengono compilati prima di valutare i campioni. I flag devono appartenere all’insieme ECMAScript supportato e non possono essere duplicati. Questo comportamento immediato impedisce a un’espressione malformata di produrre un elenco ingannevole di mancate corrispondenze.
La capacità è deterministica e non usa rete, inferenza di modelli, selezione casuale o orologio, quindi input identici generano output strutturati identici. Limiti pratici controllano la lunghezza del pattern, il numero e la dimensione dei campioni e le occorrenze per campione. Dopo una modifica potrà vedere se i casi validi continuano a passare e quelli esclusi restano tali.
Casi d'uso
Convalidi pattern di estrazione
Verifichi pattern per log, file, identificatori o record su esempi realistici ed esamini ogni campo estratto.
Esegua il debug dei gruppi
Confronti acquisizioni numerate e denominate su diversi input prima di integrare l’espressione nell’applicazione.
Domande frequenti
Il pattern deve includere le barre delimitatrici?
No. Invii soltanto il corpo dell’espressione e inserisca flag come g, i o m nell’apposito campo.
Perché un campione mostra una sola corrispondenza?
Senza il flag globale, ECMAScript restituisce solo la prima. Aggiunga g per ottenere tutte le occorrenze non sovrapposte.
Quali esempi conviene includere in una prova?
Inserisca un valore valido comune, un caso limite, lo stesso valore con maiuscole diverse se contano, un valore vuoto o incompleto e un testo simile che non deve corrispondere. Così vede sia ciò che l'espressione accetta sia ciò che rifiuta.
A cosa servono l'accento circonflesso e il simbolo del dollaro per validare un valore intero?
Obbligano la corrispondenza a partire dall'inizio dell'esempio e a finire proprio alla fine. Senza di essi una riga passa solo perché contiene il testo cercato da qualche parte, anche se il resto è sbagliato.
Che cosa succede se l'espressione regolare contiene un errore?
L'espressione e le sue opzioni vengono controllate prima di provare qualsiasi esempio, e l'errore viene segnalato con chiarezza. Non riceve mai un elenco ingannevole di esempi senza corrispondenza dovuto a un'espressione sbagliata.
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/web/regex-test \
-H "Authorization: Bearer $KIT_KEY" \
-H "Content-Type: application/json" \
-d '{"pattern":"^(?<name>[A-Za-z]+):\\s*(\\d+)$","samples":["Widget: 42","not a record","Gadget: 7"]}'const res = await fetch("https://api.kit.forhosting.com/web/regex-test", {
method: "POST",
headers: {
"Authorization": `Bearer ${process.env.KIT_KEY}`,
"Content-Type": "application/json"
},
body: JSON.stringify({
"pattern": "^(?<name>[A-Za-z]+):\\s*(\\d+)$",
"samples": [
"Widget: 42",
"not a record",
"Gadget: 7"
]
})
});
const { task_id } = await res.json();import os, requests
res = requests.post(
"https://api.kit.forhosting.com/web/regex-test",
headers={"Authorization": f"Bearer {os.environ['KIT_KEY']}"},
json={
"pattern": "^(?<name>[A-Za-z]+):\\s*(\\d+)$",
"samples": [
"Widget: 42",
"not a record",
"Gadget: 7"
]
},
)
task_id = res.json()["task_id"]<?php
$res = file_get_contents("https://api.kit.forhosting.com/web/regex-test", false, stream_context_create([
"http" => [
"method" => "POST",
"header" => "Authorization: Bearer " . getenv("KIT_KEY") . "\r\nContent-Type: application/json",
"content" => '{"pattern":"^(?<name>[A-Za-z]+):\\\\s*(\\\\d+)$","samples":["Widget: 42","not a record","Gadget: 7"]}',
],
]));
$task = json_decode($res, true);body := bytes.NewBufferString(`{"pattern":"^(?<name>[A-Za-z]+):\\s*(\\d+)$","samples":["Widget: 42","not a record","Gadget: 7"]}`)
req, _ := http.NewRequest("POST", "https://api.kit.forhosting.com/web/regex-test", 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": "^(?<name>[A-Za-z]+):\\s*(\\d+)$",
"samples": [
"Widget: 42",
"not a record",
"Gadget: 7"
]
}Esempio di risposta
{
"task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
"type": "web.regex_test",
"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 |
max_samples | 500 |
max_sample_chars | 100000 |
max_matches_per_sample | 10000 |
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 correttamente corrispondenze e gruppi acquisiti
Le acquisizioni denominate compaiono anche in named_groups quando partecipano.
Utilizzi errori e limiti nei controlli automatici
Se ECMAScript rifiuta il pattern, la richiesta termina con un errore invalid_input il cui messaggio identifica l’espressione regolare non valida e include il dettaglio utile del motore. In una pipeline di integrazione continua, conservi esempi rappresentativi accanto al codice che usa il pattern, invochi questa capacità e verifichi matched_count e i valori acquisiti importanti. L’esecutore nel browser aiuta durante la creazione; l’API costa $0.002 per richiesta quando occorre automatizzare lo stesso test.
Casi di integrazione
Protegga un refactoring della regex
Conservi campioni positivi e negativi in un test di regressione per rilevare variazioni indesiderate.
Domande tecniche
Cosa accade se il pattern regex non è valido?
La richiesta termina con un errore invalid_input prima che venga valutato qualsiasi campione.
Sono inclusi i gruppi di acquisizione denominati?
Sì. Le acquisizioni denominate presenti appaiono in named_groups, mentre quelle numerate riportano il proprio numero.
Quanto costa?
Il prezzo dell’API è $0.002 per richiesta. L’esecutore nella pagina è gratuito nel browser.