LazowskiAnton · Extensions

RegexSmith

Espressioni regolari spiegate e testate proprio dove vengono scritte. Passa il mouse su un pattern in C# per vedere una riga per ogni parte in parole semplici, i gruppi a colori e stringhe che corrispondono; vedi sottolineati i pattern che possono bloccarsi; prova i tuoi esempi nel Tester RegexSmith e riscrivi il pattern nel codice con un clic.

Gratuito · Visual Studio 2022 e 2026 · 14 lingue dell’interfaccia · nessuna telemetria

Perché RegexSmith

Una scheda al passaggio del mouse su un pattern [GeneratedRegex]: il pattern con i gruppi colorati, una riga per ogni parte in parole semplici, esempi che corrispondono e uno che non corrisponde, e lo stato ✓ sicuro

Parole semplici, non una lezione di sintassi

^(?<year>\d{4})-(?<id>\d{1,5})$ diventa «Inizio del testo», «Esattamente 4 cifre», «Da 1 a 5 cifre» — una riga per ogni parte, annidata sotto il suo gruppo, ogni gruppo con il proprio colore.

Verificato dal vero motore

Gli esempi nella scheda e ogni risultato nel tester provengono dal motore regex di .NET stesso, con le opzioni della chiamata. Quello che vedi è quello che farà la tua app.

Pattern che possono bloccarsi

([a-z0-9]+\.?)+ sembra innocuo e può bloccare una richiesta su una stringa lunga che quasi corrisponde. RegexSmith sottolinea queste ripetizioni e le corregge con Ctrl+.

Gratuito, senza vincoli

Nessun abbonamento, nessuna versione «pro», nessuna raccolta di dati, nessun messaggio nella finestra Output o all’avvio. Pattern ed esempi restano sul tuo computer. L’unica cosa che ti chiederemo — dopo che l’avrai usata per un po’ — è una valutazione sul Marketplace. Funziona con Visual Studio 2022 e 2026, x64 e ARM64.

Funzionalità

La scheda al passaggio del mouse

Passa il mouse sulla stringa di un pattern e la normale descrizione comando di Visual Studio riceve una scheda di RegexSmith: cosa significa il pattern, cosa trova e se è sicuro.

La scheda al passaggio del mouse: l’intestazione con il tipo e le opzioni, il pattern con i gruppi colorati, una riga per ogni parte annidata sotto i gruppi, gli esempi e il pulsante Testa il modello

Dove funziona

Nei file C#, sul pattern di:

Le stringhe normali, verbatim (@"…") e raw ("""…""") vengono lette come le legge il compilatore, quindi "\\d" e @"\d" sono lo stesso pattern.

Cosa mostra la scheda

Sullo schermoSignificato
RegexSmith · Espressione regolare .NET · IgnoreCaseIl tipo di pattern e le opzioni lette dalla chiamata, e lo stato a destra.
Il patternLe parentesi di ogni gruppo di cattura nel suo colore, il contenuto sottolineato in quel colore; il testo mantiene il colore del tema, così resta leggibile.
Esattamente 4 cifreUna riga per ogni parte in parole semplici — «Inizio del testo», «Uno dei testi: “jpg”, “png”», «Da 1 a 5 cifre» — annidata sotto il suo gruppo. Un pattern molto lungo termina con … altre N.
Etichette dei gruppiIl nome o il numero di ogni gruppo su un’etichetta nel suo colore — gli stessi colori del pattern e del codice.
✓ Corrisponde: … ✗ Non corrisponde: …Due stringhe che corrispondono e una che non corrisponde, ricavate dal pattern e verificate dal vero motore di .NET. Gli spazi appaiono come puntini tenui.
▶ Testa il modello…Apre il pattern nel Tester RegexSmith.

Lo stato

Sullo schermoSignificato
✓ sicuro.NET accetta il pattern e nulla al suo interno può causare un backtracking catastrofico.
⚠ può bloccarsiUna ripetizione può richiedere un tempo esponenziale su un input lungo che quasi corrisponde; la scheda indica di che tipo (RX001) e che Ctrl+. offre delle correzioni.
✕ non validoIl motore rifiuta il pattern; la scheda mostra il suo messaggio: .NET non accetta questo modello: …

«Sicuro» significa solo questo: .NET accetta il pattern e non può bloccarsi. Non significa che trovi ciò che intendi — a questo servono gli esempi e il tester.

Sottolineature dei gruppi

Ogni gruppo di cattura di un pattern riceve una linea sottile del suo colore direttamente nel codice — lo stesso colore della scheda. Un pattern lungo con cinque gruppi si legge a colpo d’occhio: quale parte è l’anno, quale l’id.

Un gruppo dentro un altro sta un po’ più in basso, così entrambe le linee restano visibili. I colori seguono quest’ordine: salmone, verde, blu, viola, ambra, verde acqua — e di nuovo.

Le sottolineature si possono disattivare nelle impostazioni: Sottolinea i gruppi di acquisizione.

Pattern che possono bloccarsi

Alcuni pattern richiedono un tempo esponenziale su una stringa lunga che quasi corrisponde — il classico modo in cui una regex blocca una richiesta web. RegexSmith li riconosce dalla loro forma e mette una sottolineatura ondulata di avviso sotto la ripetizione; passaci sopra con il mouse per conoscerne il motivo.

Una sottolineatura ondulata RX001 sotto ([a-z0-9]+\.?)+ con il menu Ctrl+. aperto e un’anteprima della correzione: il vecchio pattern barrato, il nuovo con un gruppo atomico

Cosa viene sottolineato (RX001)

Non all’interno di gruppi atomici o lookaround, e mai con RegexOptions.NonBacktracking — lì non può succedere.

Correzioni in Ctrl+.

Metti il cursore sulla sottolineatura ondulata e premi Ctrl+. — ogni correzione mostra un’anteprima: il pattern prima (barrato) e dopo.

CorrezioneCosa fa
Rendi atomica la ripetizione interna: (?>…)Racchiude la ripetizione interna in (?>…). Corrispondono le stesse stringhe; la ripetizione non può più essere suddivisa in molti modi.
Usa RegexOptions.NonBacktracking (.NET 7+)Aggiunge l’opzione alla chiamata. Tempo lineare con qualsiasi input; richiede .NET 7 o versione successiva. Offerta solo quando il pattern lo consente — niente backreference, lookaround, gruppi atomici o di bilanciamento, condizionali.
Testa questo modello in RegexSmithApre il pattern nel tester — offerta su qualsiasi pattern, non solo su quelli a rischio.

RX001 si può disattivare nelle impostazioni (Suggerimenti nell’editor) o con Non mostrare questo tipo di suggerimento nella sua descrizione comando; le correzioni in Ctrl+. restano.

Il tester

Il Tester RegexSmith si apre ancorato accanto a Risultati ricerca. Il pattern proviene dal codice e resta collegato a esso: provalo sui tuoi esempi, modificalo e riscrivilo nel codice.

Il Tester RegexSmith: il collegamento all’origine, il pattern, la riga di stato, i chip delle opzioni, gli esempi con aspettative e gruppi evidenziati, una riga errata in rosso, la tabella dei gruppi e i pulsanti

Come aprirlo

Il pattern e le sue opzioni

In alto, il file e la riga del pattern — fai clic per andarci. Sotto, la casella del pattern, la riga di stato (✓ sicuro, ⚠ può bloccarsi o l’errore del motore, poi N su M come previsto · ms) e i chip delle opzioni: IgnoreCase, Multiline, Singleline, IgnorePatternWhitespace, ExplicitCapture, RightToLeft, CultureInvariant. Ogni modifica viene eseguita di nuovo all’istante.

Esempi e aspettative

La prima volta ci sono gli esempi della scheda: due che dovrebbero corrispondere e uno che non dovrebbe. Digitane uno nuovo in Aggiungi un esempio e premi INVIO…; fai clic su un esempio per modificarlo, ✕ lo rimuove. Il segno prima di ogni esempio dice cosa dovrebbe fare — fai clic per cambiarlo:

Sullo schermoSignificato
✓deve corrispondere
✗non deve corrispondere
–nessuna aspettativa, solo mostra

Un esempio che fa il contrario diventa rosso — ✗ corrisponde o ✗ nessuna corrispondenza — così gli esempi diventano una piccola specifica del pattern. Le corrispondenze sono evidenziate, i gruppi sottolineati nei loro colori, gli spazi mostrati come puntini. Un’esecuzione che dura più di 1 secondo si interrompe con ⏱ troppo lento.

Gruppi dell'esempio selezionato elenca ogni corrispondenza dell’esempio selezionato: la corrispondenza intera, poi ogni gruppo con il suo valore e la sua posizione (non acquisito quando non ha partecipato).

Sostituisci

La scheda Sostituisci aggiunge una casella di sostituzione — $1, ${name}, $$ per un $ — e mostra il risultato per ogni esempio, come farebbe Regex.Replace.

Copiare, ripristinare, applicare

Copia come unit test mette negli Appunti un test con i tuoi esempi, per xUnit, NUnit o MSTest — la specifica passa nel progetto di test.

Ripristina torna al pattern e alle opzioni del codice; gli esempi restano.

Applica al codice riscrive il pattern nello stesso tipo di letterale che era (normale, verbatim o raw) insieme alle opzioni — un solo Annulla lo riporta indietro. Se quel codice è cambiato dopo che il tester lo ha aperto, non viene scritto nulla: apri di nuovo il tester dal pattern.

Gli esempi vengono ricordati per pattern e per soluzione in %LocalAppData%\RegexSmith\samples, così la volta successiva sono già lì. Nulla finisce nel repository.

Impostazioni

Strumenti › Opzioni › SmithWorks › RegexSmith. Ogni opzione ha una breve descrizione di cosa fa.

OpzionePredefinito
Spiega i modelli al passaggio del mouseattivo
Sottolinea i gruppi di acquisizioneattivo
RX001 Backtracking catastroficoattivo
Chiedi una valutazione sul Marketplaceattivo

In basso: Ripristina predefiniti, Documentazione, Valuta nel Marketplace e Invia feedback.

Le impostazioni sono salvate in %LocalAppData%\RegexSmith.

La pagina delle opzioni di RegexSmith
La pagina delle opzioni.

FAQ

RegexSmith invia dei dati?

No. I pattern vengono letti dal documento aperto ed eseguiti sul tuo computer; gli esempi sono conservati in %LocalAppData%\RegexSmith. Nessuna richiesta di rete, nessuna telemetria.

La scheda dice «✓ sicuro». Il pattern è corretto?

Non necessariamente. «Sicuro» significa che .NET accetta il pattern e che nessuna ripetizione al suo interno può causare un backtracking catastrofico. Se trova ciò che intendi lo devono mostrare gli esempi: contrassegnali con ✓ o ✗ nel tester.

Perché sul mio pattern non compare la scheda?

La scheda compare su una stringa letterale che RegexSmith sa essere un pattern: l’argomento di new Regex, di un metodo statico di Regex, di [GeneratedRegex] o di [RegularExpression], oppure una costante dello stesso file usata lì. Un pattern costruito in fase di esecuzione (concatenato, letto dalle impostazioni) non può essere letto. Verifica anche Spiega i modelli al passaggio del mouse nelle impostazioni.

Quale motore regex viene usato?

Il motore regex di .NET su cui gira Visual Studio stesso, con le opzioni della chiamata. Anche RegexOptions.NonBacktracking (.NET 7+) viene letto dalla chiamata; gli esempi vengono allora eseguiti sul motore abituale, e le stringhe che corrispondono sono le stesse in entrambi i casi.

Applica al codice non ha fatto nulla.

Il codice del pattern è cambiato dopo che il tester lo ha aperto, quindi RegexSmith non scrive in un punto che potrebbe non contenere più il pattern — il tester lo segnala sotto i pulsanti. Apri di nuovo il tester dal pattern. Dove il codice non ha posto per le opzioni ([RegularExpression] non ne accetta), il pattern viene scritto e le opzioni no.

Funziona in VB.NET, JavaScript o TypeScript?

Non nella 1.0: solo C#. Altri linguaggi usano altri motori; chiedi nel repository Feedback se te ne serve uno.

Dove posso segnalare un problema o suggerire una funzionalità?

Apri una issue nel repository Feedback su GitHub: ci sono moduli per bug e idee (cambia i nomi privati). Puoi anche usare la scheda Q&A nel Marketplace.

Registro modifiche

1.0.1

1.0.0