◯ Gratis: 5 utilizzi/giorno • Si azzera tra 16h 13m
Sviluppo e Tecnico

Generatore di Regex

Trasforma una descrizione in inglese semplice in una espressione regolare funzionante per JavaScript, Python, PCRE, Go, Java o .NET — con una spiegazione token per token, casi di test e i casi limite che il pattern corrisponde o non corrisponde intenzionalmente.

Scopri di più

Il Generatore di Regex scrive un'espressione regolare a partire da una descrizione di ciò che dovrebbe corrispondere, nel flavor che utilizzi — JavaScript, Python, PCRE, RE2 di Go, Java o .NET — e poi lo dimostra: ogni token è spiegato, i tuoi esempi di stringhe che devono e non devono corrispondere vengono verificati, e il pattern è fornito con casi di test aggiuntivi, un frammento di utilizzo nella tua lingua e una nota sui casi limite che esclude intenzionalmente. Inoltre ti avvisa quando un requisito non può essere soddisfatto nel tuo flavor, come il look‑behind in Go, invece di produrre silenziosamente un pattern che non compila.

0 / 3000
0 / 10000
0 / 10000

✓ Gratuito — senza registrazione, senza carta di credito.

Sviluppatori

Solo indirizzi email aziendali

Validazione di registrazione che rifiuta domini di webmail gratuiti

Mostra anteprima di input e output

Input

Cosa dovrebbe corrispondere il pattern?
Email addresses on the company domains acme.com and acme.co.uk, case-insensitive. Reject everything else, including gmail and addresses with nothing before the @.
Tipo di regex
JavaScript / TypeScript
Esempi che devono corrispondere (uno per riga)
[email protected] [email protected]
Esempi che non devono corrispondere (uno per riga)
[email protected] @acme.com
Rigore
Pratico (leggibile, copre casi comuni)

Output (estratto)

```javascript
/^[a-z0-9._%+-]+@acme\.(?:com|co\.uk)$/i
```

**Flags:** `i` — domini e parti locali sono confrontati senza distinzione tra maiuscole e minuscole.

| Token | Significato |
|---|---|
| `^` … `$` | l'intera stringa deve essere l'indirizzo |
| `[a-z0-9._%+-]+` | parte locale: una o più lettere, cifre o la punteggiatura comune |
| `@acme\.` | letterale @acme. — il punto è escapato |
| `(?:com\|co\.uk)` | esattamente uno dei due domini aziendali |

| Input | Atteso | Motivo |
|---|---|---|
| `[email protected]` | corrisponde | parte locale semplice, dominio consentito |
| `[email protected]` | corrisponde | punto nella parte locale, secondo dominio |
| `[email protected]` | non corrisponde | dominio non nella lista |
| `@acme.com` | non corrisponde | parte locale vuota |
| `[email protected]` | non corrisponde | ancorato, nulla può seguire |…
Tutti i pubblici

Date di calendario ISO 8601

Estrai le date dalle righe di log prima di analizzarle

Mostra anteprima di input e output

Input

Cosa dovrebbe corrispondere il pattern?
ISO calendar dates like 2026-09-20 anywhere inside a line of text. Month 01-12, day 01-31. Do not match 2026-13-01 or 26-09-20.
Tipo di regex
Python (re)
Esempi che devono corrispondere (uno per riga)
deployed 2026-09-20 at 05:01 2024-02-29
Esempi che non devono corrispondere (uno per riga)
2026-13-01 26-09-20
Rigore
Rigido (rifiuta tutto ciò che è non valido)

Output (estratto)

```python
r"(?<!\d)(\d{4})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])(?!\d)"
```

**Flags:** nessuna. Il pattern non è ancorato perché la data si trova all'interno di una riga.

| Token | Significato |
|---|---|
| `(?<!\d)` | non preceduto da una cifra — rifiuta `12026-09-20` |
| `(\d{4})` | anno a quattro cifre, catturato |
| `(0[1-9]\|1[0-2])` | mese 01-12 |
| `(0[1-9]\|[12]\d\|3[01])` | giorno 01-31 |
| `(?!\d)` | non seguito da una cifra |

**Edge cases:** il pattern non conosce la lunghezza dei mesi — `2026-02-31` corrisponde. Convalida con `datetime.date.fromisoformat()` dopo l'estrazione, come mostra lo snippet di utilizzo…

I risultati di Generatore di Regex appariranno qui

Aspettati blocchi di codice puliti con commenti, più una breve spiegazione delle modifiche.

Come usare Generatore di Regex

  1. Descrivi cosa dovrebbe corrispondere il pattern in linguaggio semplice, includendo ciò che deve rifiutare — 'indirizzi email aziendali, non webmail gratuiti' è meglio di 'email'.
  2. Scegli il flavor in cui lo eseguirai. Go, JavaScript, Python, Java, .NET e PCRE differiscono nel supporto dei look‑around, nella gestione Unicode e nell'escaping.
  3. Incolla alcune stringhe che devono corrispondere e alcune che non devono, una per riga. Il pattern viene verificato su ciascuna di esse.
  4. Scegli il livello di rigore: 'Pratico' per pattern leggibili che coprono input normali, 'Rigido' per la validazione, 'Permissivo' quando catturi in modo ampio e filtri successivamente.

Casi d'uso

1

Convalida l'input di moduli come codici postali, targhe o formati di ID interni

2

Estrai date, numeri di fattura o riferimenti d'ordine da righe di log e email

3

Crea una ricerca e sostituzione per una pulizia massiva in un editor o in uno script di migrazione

4

Spiega un pattern legacy lasciato da un collega nel codebase incollandolo come descrizione

5

Converti un pattern da un flavor all'altro quando sposti uno script da Python a Go

Consigli per i migliori risultati

  • Fornisci esempi di non-corrispondenza — fanno più per affinare un pattern rispetto agli esempi di corrispondenza.
  • Se ti serve all'interno di una stringa di linguaggio, chiedi quel flavor: l'escaping è parte della risposta.
  • Per la validazione rivolta all'utente, scegli 'Strict' e leggi la sezione dei casi limite prima di rilasciare.
  • Un pattern con ripetizioni annidate su input non attendibili può bloccare il server; l'output ti avvisa quando esiste tale rischio.

Domande frequenti

Quali flavor di regex sono supportati?

JavaScript e TypeScript, il modulo re di Python, PCRE (PHP, Ruby, Perl), il motore RE2 di Go, Java e .NET. Il pattern è scritto come letterale nel linguaggio scelto, con l'escaping richiesto da quel linguaggio.

Il pattern viene testato?

Ogni esempio fornito è elencato in una tabella di test con il risultato atteso e la motivazione. Lo strumento aggiunge anche casi limite — input vuoto, spazi, quasi corrispondenze — così puoi vedere cosa potrebbe passare inosservato.

Perché dice che il mio requisito è impossibile in Go?

Il motore RE2 di Go garantisce una corrispondenza in tempo lineare e quindi non supporta look-ahead, look-behind o back-references. Quando la descrizione richiede uno di questi, lo strumento lo segnala e propone il pattern più vicino che RE2 può compilare, solitamente con un piccolo controllo nel codice.

Qual è la differenza tra Practical, Strict e Lenient?

I pattern Practical sono leggibili e coprono gli input che vedi realmente. I pattern Strict rifiutano ogni stringa non valida, a scapito di lunghezza e leggibilità — usali per la validazione. I pattern Lenient catturano in modo ampio così puoi filtrare successivamente nel codice — usali per l'estrazione da testo disordinato.

Può spiegare una regex che ho già?

Sì. Incolla il pattern esistente nella descrizione con 'explain this' e l'output lo analizza token per token, elenca cosa corrisponde e segnala eventuali rischi di backtracking catastrofico.

🔒
La tua privacy è protetta

Conserviamo il tuo input e il risultato per un massimo di 90 giorni per far funzionare il servizio, prevenire gli abusi e, se hai effettuato l'accesso, mostrarti la cronologia. Vengono elaborati dai fornitori di IA elencati nella nostra Informativa sulla privacy. Non li vendiamo.

Strumenti correlati

Sviluppo e TecnicoGeneratore di Test UnitariGenera casi di test unitari con configurazione, asserzioni, casi limite e logica di teardown.…Sviluppo e TecnicoGeneratore di Query SQLDescrivi ciò di cui hai bisogno in inglese semplice e ottieni una query SQL…Sviluppo e TecnicoGeneratore di Storie UtenteGenera storie utente nel formato standard (Come un... Voglio... In modo che...) con criteri…

Prova questo agente

Ottimizzatore SEORicerca parole chiave, crea meta description, genera title tag e costruisci uno schema di contenuto —…Prova questo agente →

Workflow correlato

Migliora la qualità del codiceScrivi test migliori e codice più pulitoAvvia workflow →

Leggi di più