c regex tutorial what is c regular expression
Questo tutorial C # Regex spiega cos'è un'espressione regolare in C #, la sua sintassi, i metodi della classe Regex e come utilizzare questi metodi con l'aiuto di esempi:
L'espressione regolare in C # viene utilizzata per la corrispondenza di un particolare modello di carattere. Le espressioni regolari vengono utilizzate ogni volta che un utente ha bisogno di trovare un pattern ripetuto o eseguire una convalida dei dati o anche per controllare la formattazione dei dati.
Un RegEx viene utilizzato per scoprire se una stringa contiene o corrisponde a un determinato modello di carattere. Una regex è principalmente una sequenza di caratteri che denota uno schema.
Uno schema può essere qualsiasi cosa, da numeri, caratteri o una combinazione di tutti. Regex è ampiamente utilizzato per la convalida. Analisi o corrispondenza di stringhe, per esempio, trovare se una stringa corrisponde al formato della valuta, al numero di telefono o al formato della data.
=> Leggere la serie di corsi di formazione Easy C #.
java come creare un elenco
Cosa imparerai:
Classe Regex in C #
La classe Regex viene utilizzata in C # per eseguire operazioni regex. Contiene diversi metodi che possono essere utilizzati per eseguire diverse operazioni relative a regex.
Può essere utilizzato per analizzare testo di grandi dimensioni per trovare una particolare sequenza di caratteri utilizzando metodi che possono essere utilizzati per eseguire una corrispondenza, per sostituire o possono essere utilizzati per dividere la sequenza di caratteri.
La classe regex è presente all'interno dello spazio dei nomi; System.Text.RegularExpression. La classe accetta come parametro una stringa sotto forma di sequenza di caratteri.
Metodi Regex C #
IsMatch
Il metodo più semplice e più utile nella classe Regex è il metodo IsMatch. Questo metodo ha diversi overload per eseguire la corrispondenza dei caratteri in base a parametri diversi.
Il più semplice è IsMatch (stringa di testo) , questo metodo consente all'utente di fornire una sequenza di caratteri per la corrispondenza di una stringa.
Il secondo sovraccarico IsMatch (stringa di testo, posizione int). Questo metodo restituisce un valore booleano e accetta due parametri (stringa e intero). Il testo della stringa specificato nel parametro è fondamentalmente un costruttore di espressioni regolari che corrisponderà alla sequenza di caratteri dalla posizione iniziale specificata dal parametro intero.
Pertanto, questo metodo proverà a far corrispondere la stringa immessa nella posizione fornita da un parametro intero in una determinata stringa.
Il terzo sovraccarico, IsMatch (testo stringa, modello stringa) accetta due parametri e restituisce un valore booleano. Il primo parametro è il testo in cui l'utente deve trovare un modello e il parametro successivo fornisce il modello che l'utente sta cercando nel testo dato.
Lettura consigliata = >> Pattern matching in MySQL
Sostituisci (testo stringa, testo sostitutivo stringa)
Il metodo di sostituzione accetta due parametri e restituisce un valore stringa. Il primo parametro è la sequenza di caratteri o regex che si desidera utilizzare per la corrispondenza e il secondo è la sostituzione della regex.
Il metodo funziona trovando una corrispondenza del testo dato e quindi la sostituisce con il testo sostitutivo fornito dall'utente. La firma del metodo è sostituzione stringa pubblica (testo stringa, testo sostituzione stringa)
Stringa pubblica () Split (stringa di testo)
Il metodo split della classe regex accetta l'input di stringhe come parametro e restituisce un array contenente sottostringhe. Il parametro passato nel metodo è la stringa che deve essere divisa.
Il metodo trova il modello di input corrispondente nella stringa e una volta identificato qualsiasi modello corrispondente, divide la stringa in quel punto in una sottostringa più piccola con ogni modello corrispondente che è il punto di rottura. Il metodo restituisce quindi un array contenente tutte le sottostringhe.
Utilizzo dei metodi C # Regex
Diamo uno sguardo all'uso di questi metodi scrivendo un semplice programma.
public static void Main(string() args) { string patternText = 'Hello'; Regex reg = new Regex(patternText); //IsMatch(string input) Console.WriteLine(reg.IsMatch('Hello World')); //IsMatch(string input, int index) Console.WriteLine(reg.IsMatch('Hello', 0)); //IsMatch(string input, string pattern) Console.WriteLine(Regex.IsMatch('Hello World', patternText)); //Replace(string input, string replacement) Console.WriteLine(reg.Replace('Hello World', 'Replace')); //Split(string input, string pattern) string() arr = Regex.Split('Hello_World_Today', '_'); foreach(string subStr in arr) { Console.WriteLine('{0}', subStr); } }L'output del programma sopra
Vero
Vero
Vero
Sostituisci il mondo
Ciao
Mondo
Oggi
La spiegazione per il codice sopra:
All'inizio del programma, abbiamo creato un oggetto e per il pattern che useremo per la corrispondenza del codice nel successivo input di stringa, abbiamo usato la formattazione del testo per mantenere le cose semplici all'inizio ma se ti senti a tuo agio puoi farlo iniziare a utilizzare modelli di espressioni regolari (Discuteremo in dettaglio il modello di espressione regolare mentre andiamo avanti in questo tutorial)
Quindi, useremo la stringa di corrispondenza per inserire il fattore che abbiamo dichiarato come oggetto specificato con la stringa di input e se corrisponde, restituirà false.
Il prossimo metodo che abbiamo usato è IsMethod (string input, int index). Questo metodo accetta due parametri e qui forniamo la stringa di input e l'indice da cui deve iniziare la corrispondenza. Per esempio, qui abbiamo voluto far partire la corrispondenza dall'inizio della stringa di input.
Quindi abbiamo dimostrato l'uso di IsMatch (input di stringa, modello di stringa). Qui abbiamo fornito la stringa di input, quindi volevamo scoprire se il testo del modello è presente o meno nell'input. Se è presente, restituirà vero (come nel nostro caso) altrimenti restituirà falso.
Un altro metodo di cui abbiamo discusso viene sostituito. Questo metodo è molto utile nei programmi in cui si desidera apportare modifiche ai dati di input o modificare il formato dei dati esistenti.
Qui forniamo due parametri, il primo è la stringa di input e il secondo è la stringa che può essere utilizzata per sostituire la stringa precedente. Questo metodo utilizza anche il modello definito nell'oggetto regex che abbiamo definito in precedenza.
Un altro metodo importante che abbiamo utilizzato è lo split. Questo metodo viene utilizzato per dividere la stringa data in base ad alcuni modelli ricorrenti. Qui abbiamo fornito una stringa 'Hello_World_Today'.
Supponiamo di voler rimuovere il carattere di sottolineatura dalla stringa data e ottenere le sottostringhe. Per questo, specifichiamo il parametro di input e quindi diamo il modello che dobbiamo usare come punto di divisione. Il metodo restituisce un array e possiamo usare un semplice ciclo come foreach per recuperare tutte le stringhe.
Sintassi delle espressioni regolari
Esistono diverse sintassi diverse come caratteri speciali, quantificatori, classi di caratteri, ecc. Che possono essere utilizzate per abbinare un determinato modello da un dato input.
In questa parte del tutorial, ci immergeremo in profondità nella sintassi offerta dalle espressioni regolari e proveremo a risolvere alcuni scenari di vita reale utilizzandole. Prima di procedere, assicurati di aver acquisito l'idea di base della regex e dei diversi metodi disponibili all'interno della classe regex.
Personaggi speciali
I caratteri speciali in una regex vengono utilizzati per assegnare diversi significati a un pattern. Vedremo ora alcuni dei caratteri speciali ampiamente utilizzati e il loro significato in Regex
| Personaggi speciali | Significato |
|---|---|
| w e W | La 'w' minuscola viene utilizzata per abbinare caratteri alfanumerici / trattino basso e la 'W' maiuscola viene utilizzata per trovare caratteri non alfanumerici. |
| ^ | Questa è una delle sintassi più utilizzate. Denota l'inizio, la parola o il modello dopo che inizia la corrispondenza dall'inizio del testo di input. |
| $ | Questo segno viene utilizzato per la corrispondenza delle parole dalla fine della stringa. Le parole / schemi indicati prima di questo simbolo corrisponderanno alle parole presenti alla fine della stringa. |
| . (punto) | Il punto viene utilizzato per abbinare un singolo carattere nella stringa data che ricorre una volta. |
| n | Viene utilizzato per una nuova riga. |
| d e D | La 'd' minuscola viene utilizzata per abbinare un carattere numerico e la 'D' maiuscola viene utilizzata per abbinare caratteri non numerici. |
| se S | La 's' minuscola viene utilizzata per abbinare gli spazi bianchi e la 'S' maiuscola viene utilizzata per abbinare gli spazi non bianchi. |
Quantifier Syntax
La sintassi Quantifier viene utilizzata per contare o quantificare i criteri di corrispondenza. Per esempio, se vuoi controllare se una particolare stringa contiene un alfabeto una o più volte. Diamo un'occhiata ad alcuni dei quantificatori comunemente usati in Espressione regolare.
| Quantifier Syntax | Significato |
|---|---|
| * | Questo simbolo viene utilizzato per abbinare il carattere precedente. |
| + | Questo simbolo viene utilizzato per abbinare uno o più caratteri in una riga. |
| {n} | La cifra numerica all'interno delle parentesi graffe viene utilizzata per abbinare il numero del carattere precedente definito dalle parentesi graffe numeriche all'interno. |
| {n,} | Il numero all'interno delle parentesi graffe e questo simbolo viene utilizzato per assicurarsi che corrisponda almeno a n (ovvero il valore numerico all'interno delle parentesi graffe). |
| {n, m} | Questo simbolo viene utilizzato per la corrispondenza dal carattere precedente da n numero di volte a m numero di volte. |
| ? | Questo simbolo rende la corrispondenza dei caratteri precedenti come facoltativa. |
Classe di carattere
La classe di caratteri è anche nota come set di caratteri e viene utilizzata per indicare al motore di regex di cercare una singola corrispondenza tra diversi caratteri. Una classe di caratteri corrisponderà a un solo carattere e l'ordine dei caratteri racchiusi all'interno del set di caratteri non ha importanza.
| Classe di carattere | Significato |
|---|---|
| ( gamma ) | Il simbolo della parentesi quadra viene utilizzato per trovare una corrispondenza per un intervallo di caratteri. Ad esempio, possiamo usarlo per definire qualsiasi carattere nell'intervallo dall'alfabeto 'a' alla 'z' racchiudendo l'intervallo all'interno della parentesi come (a-z) In alternativa, possiamo anche abbinare il valore numerico da '1' a '9' indicando (1-9) |
| (^ intervallo) | Questo denota la classe di caratteri negativa. È usato per abbinare qualsiasi cosa, non nell'intervallo indicato all'interno della parentesi. |
| Viene utilizzato per abbinare caratteri speciali che possono avere i propri simboli regex. La barra viene utilizzata per abbinare i caratteri speciali nella loro forma letterale. |
Raggruppamento
È possibile utilizzare parentesi tonde o parentesi per raggruppare una parte dell'espressione regolare. Ciò consente all'utente di aggiungere un quantificatore con l'espressione.
| Raggruppamento | Significato |
|---|---|
| (espressione di gruppo) | Le parentesi tonde vengono utilizzate per raggruppare un'espressione. |
| | | Il | L'operatore viene utilizzato all'interno della parentesi tonda per utilizzare un'alternativa, ad esempio (a | b). |
Esempi di espressioni regolari C #
Nella sezione precedente, abbiamo imparato a conoscere i simboli delle espressioni regolari, in questa sezione esamineremo in dettaglio l'uso di simboli diversi nelle espressioni regolari e la combinazione in cui possono essere utilizzati per abbinare espressioni diverse.
In questo tutorial, discuteremo alcuni degli scenari di vita reale più ampiamente riscontrati che potresti dover affrontare come sviluppatore mentre lavori su alcune applicazioni o in un semplice programma per ottenere l'input dell'utente.
Esempio di espressione regolare con scenari di vita reale
Impariamo di più sulle espressioni regolari utilizzando alcuni esempi in tempo reale.
Scenario 1: verificare se la stringa di input è composta da caratteri alfabetici a 6 cifre senza distinzione tra maiuscole e minuscole.
Uno scenario più comune per l'espressione regolare è trovare e abbinare una determinata parola. Per esempio, diciamo che voglio una stringa alfabetica casuale dall'utente e che l'input deve essere lungo esattamente 6 cifre.
Per convalidarlo possiamo usare una semplice espressione regolare. Scriviamo un programma per comprendere meglio la scrittura e l'utilizzo delle espressioni regolari.
public static void Main(string() args) { string patternText = @'^(a-zA-Z){6}$'; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch('Helios')); //When pattern doesnt match Console.WriteLine(reg.IsMatch('Helo')); }Produzione
Vero
Falso
Spiegazione
In questo esempio, stiamo cercando di convalidare una stringa di input, per verificare se contiene caratteri alfabetici a sei cifre. I caratteri possono essere sia minuscoli che maiuscoli, quindi dobbiamo tenerne conto.
Quindi, qui abbiamo definito un modello di espressione regolare nella variabile 'patternText' e poi lo abbiamo passato nell'oggetto regex. Ora, le righe di codice successive sono piuttosto semplici, abbiamo utilizzato il metodo IsMatch per confrontare l'espressione regolare e la stringa di input.
Diamo ora uno sguardo all'espressione regolare che abbiamo ideato. L'espressione (^ (a-zA-Z) {6} $) è composta da 4 parti differenti. '^', '(A-zA-Z)', '{6}' e '$'. La seconda parte indica i caratteri corrispondenti, utilizzati per eseguire la corrispondenza delle espressioni, 'a-z' per le lettere minuscole e 'A-Z' per le lettere maiuscole.
Il carattere della prima parte '^' assicura che la stringa inizi con un modello definito nella seconda parte, cioè lettere minuscole e maiuscole.
Le parentesi graffe nella terza parte determinano il numero di caratteri nella stringa che possono essere identificati dal pattern definito, in questo caso 6 e il simbolo “$” fanno in modo che termini con il pattern definito nella seconda parte.
^ (a-zA-Z) {6} $
Scenario 2: utilizzare l'espressione regolare per confermare che una parola che inizia con 'Super' e ha uno spazio bianco dopo, cioè per convalidare se 'Super' è presente all'inizio di una frase.
Supponiamo di leggere l'input dell'utente e dobbiamo assicurarci che l'utente inizi sempre la frase con una parola, un numero o un alfabeto particolare. Ciò può essere ottenuto abbastanza facilmente utilizzando una semplice espressione regolare.
Diamo un'occhiata a un programma di esempio e poi discutiamo in dettaglio su come scrivere questa espressione.
public static void Main(string() args) { string patternText = @'^Supers'; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch('Super man')); //When pattern doesnt match Console.WriteLine(reg.IsMatch('Superhero')); }Produzione
Vero
Falso
Spiegazione
Anche in questo esempio, abbiamo utilizzato una configurazione del codice simile a quella del primo. Il modello di espressione regolare in questo scenario richiede la corrispondenza con una combinazione di parole o frasi che iniziano con 'Super'.
^ Super
Quindi, poiché vogliamo trovare una corrispondenza dall'inizio della parola serie, inizieremo inserendo il simbolo '^', quindi daremo il modello che vogliamo abbinare, in questo caso, 'Super'. Ora lo schema che abbiamo creato '^ Super' può corrispondere a tutti i valori di super, anche superman o soprannaturale, ma non vogliamo solo la parola 'Super'.
Ciò significa che dovrebbe esserci uno spazio bianco dopo la parola per contrassegnare la fine della parola e l'inizio di un'altra parola. Per fare ciò aggiungeremo il simbolo ' s' al modello e quindi renderemo il nostro modello finale come
^ Super s
Scenario 3: utilizzare l'espressione regolare per trovare nomi di file validi con un'estensione del tipo di file immagine.
Un altro importante scenario in tempo reale che gli sviluppatori devono spesso affrontare è la convalida dei tipi di file. Supponiamo di avere un pulsante di caricamento nell'interfaccia utente, che può accettare solo estensioni di file immagine.
Dobbiamo convalidare il file di caricamento dell'utente e informarlo nel caso in cui abbia caricato il formato di file sbagliato. Ciò può essere facilmente ottenuto utilizzando l'espressione regolare.
Di seguito è riportato un semplice programma per verificarlo.
public static void Main(string() args) jpegProduzione
Vero
Vero
Vero
Falso
Falso
Spiegazione
Qui abbiamo bisogno di abbinare un nome di file. Un nome file valido è composto da tre parti ( nome del file +. + estensione del file ). Dobbiamo creare un'espressione regolare che corrisponda a tutte e tre le parti. Cominciamo facendo corrispondere la prima parte, cioè il nome del file. Un nome file può contenere caratteri alfanumerici e speciali.
Come discusso in precedenza, il simbolo per denotare che è ' w'. Inoltre, il nome del file può essere di uno o più caratteri, quindi utilizzerà il simbolo '+'. Combinali e otteniamo il simbolo per la prima parte.
algoritmo c ++ bubble sort
(w+)La parentesi ha separato questo in parti. La parte successiva è il simbolo del punto. Poiché il simbolo del punto ha il suo significato in una regex, useremo un backslash prima di esso per dargli un significato letterale. Combina entrambi e avremo coperto le prime due parti della regex.
(w+).Ora, per la terza e ultima parte, possiamo definire direttamente le estensioni di file richieste separate da '|' Simbolo OR. Questo può quindi essere separato racchiudendo all'interno di una staffa circolare. Un segno '$' alla fine assicura che le estensioni definite siano alla fine della stringa. Ora combiniamoli per ottenere l'espressione regolare finale.
(w+).(jpg|png|jpeg|gif)$Ora, se lo usiamo nel programma, possiamo vedere che corrisponde al formato corretto e restituisce true ma con formati non validi restituisce false.
Scenario 4: utilizzare l'espressione regolare per convalidare il formato dell'indirizzo di un sito Web
Supponiamo di avere un modulo web che accetta un indirizzo web o un indirizzo di dominio. Vogliamo che l'utente inserisca l'indirizzo web / dominio corretto durante la compilazione del modulo. Per determinare se l'utente ha inserito un indirizzo web corretto, un'espressione regolare può essere molto utile.
public static void Main(string() args) { string patternText = @'^www.(a-zA-Z0-9){3,20}.(com|in|org|co.in|net|dev)$'; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch('www.selenium.dev')); //When pattern doesnt match Console.WriteLine(reg.IsMatch('ww.alsjk9874561230.movie.dont')); }Produzione
Vero
Falso
Spiegazione
Qui, vogliamo abbinare un nome di dominio valido utilizzando un'espressione regolare. Un nome di dominio valido inizia con l'abbreviazione 'www' seguita da un punto (.), Quindi dal nome del sito Web, quindi da un punto (.) E alla fine da un'estensione di dominio.
Quindi, in modo simile allo scenario precedente, proveremo ad abbinarlo parte per parte. Iniziamo innanzitutto facendo corrispondere 'www'. Parte. Quindi iniziamo con il simbolo iniziale, poi come 'www'. È qualcosa che è fisso, quindi usiamo il simbolo iniziale seguito dalle parole esatte da abbinare.
“^www.”Quindi inizieremo a lavorare sulla seconda parte. La seconda parte dell'indirizzo web può essere qualsiasi nome alfanumerico. Quindi, qui useremo le parentesi quadre presenti nella classe di caratteri per definire l'intervallo che deve essere abbinato. Dopo aver aggiunto la seconda parte con la seconda parte ci darà.
“^www.(a-zA-Z0-9){3,20}”Qui abbiamo anche aggiunto parentesi graffe per definire la lunghezza minima e massima dei caratteri per il nome del sito web. Abbiamo dato un minimo di 3 e un massimo di 20. Puoi dare qualsiasi lunghezza minima o massima che desideri.
Ora, dopo aver coperto la prima e la seconda parte dell'indirizzo web, ci resta solo l'ultima parte, ovvero l'estensione del dominio. È abbastanza simile a quello che abbiamo fatto nell'ultimo scenario, faremo corrispondere direttamente le estensioni di dominio utilizzando OR e racchiudendo ogni estensione di dominio valida all'interno della parentesi circolare.
Quindi se aggiungiamo tutti questi insieme avremo un'espressione regolare completa per abbinare qualsiasi indirizzo web valido.
www.(a-zA-Z0-9){3,20}.(com|in|org|co.in|net|dev)$Scenario 5: utilizzare l'espressione regolare per convalidare un formato di ID di posta elettronica
Supponiamo di avere un modulo di accesso sulla nostra pagina web che chiede agli utenti di inserire il proprio indirizzo email. Per ovvie ragioni, non vorremo che il nostro modulo proceda ulteriormente con indirizzi email non validi. Per convalidare se l'indirizzo email inserito dall'utente è corretto o meno possiamo utilizzare un'espressione regolare.
Di seguito è riportato un semplice programma per convalidare un indirizzo e-mail.
public static void Main(string() args) { string patternText = @'^(a-zA-Z0-9._-){5,25}.@.(a-z){2,12}.(com|org|co.in|net)'; Regex reg = new Regex(patternText); //When pattern matches Console.WriteLine(reg.IsMatch('software_test123@gmail.com')); Console.WriteLine(reg.IsMatch('Special.Char@yahoo.co.in')); //When pattern doesnt match Console.WriteLine(reg.IsMatch('ww.alsjk9874561230.mo@vie.dont')); }Produzione
Vero
Vero
Falso
Spiegazione
Un indirizzo e-mail valido contiene alfabeti, numeri e alcuni caratteri speciali come punto (.), Trattino (-) e trattini bassi (_) seguiti dal simbolo '@' seguito dal nome del dominio e dall'estensione del dominio.
Pertanto, possiamo dividere l'indirizzo e-mail in quattro parti, ovvero l'identificatore e-mail, il simbolo '@', il nome del dominio e l'ultima è l'estensione del dominio.
Cominciamo scrivendo un'espressione regolare per la prima parte. Può essere alfanumerico con alcuni caratteri speciali. Supponiamo di avere una dimensione dell'espressione compresa tra 5 e 25 caratteri. Simile a come l'abbiamo scritto in precedenza (nello scenario di posta elettronica), possiamo trovare la seguente espressione.
^(a-zA-Z0-9._-){5,25}Ora, passiamo alla seconda parte. È relativamente facile in quanto dobbiamo abbinare solo un simbolo, ad esempio '@'. Aggiungendolo all'espressione sopra ci dà.
^(a-zA-Z0-9._-){5,25}.@Passando alla terza parte cioè il nome di dominio sarà sempre una serie di caratteri alfabetici minuscoli. Se vuoi puoi anche includere caratteri alfabetici numerici o maiuscoli, ma per questo scenario, andremo con alfabeti minuscoli.
Se aggiungiamo l'espressione per alfabeti minuscoli con lunghezza compresa tra 2 e 12 caratteri, avremo la seguente espressione.
^(a-zA-Z0-9._-){5,25}.@.(a-z){2,12}Ora, ci rimane solo l'espressione per l'estensione del dominio, simile al quarto scenario, gestiremo alcune estensioni di dominio specifiche. Se vuoi puoi aggiungerne altri racchiudendoli all'interno di una parentesi circolare e separandoli con un '|' simbolo.
Il consolidamento di questa espressione con l'espressione precedente ci fornirà il valore dell'espressione finale per la convalida dell'email.
^(a-zA-Z0-9._-){5,25}.@.(a-z){2,12}.(com|org|co.in|net)Conclusione
In questo tutorial, abbiamo appreso cos'è l'espressione regolare insieme alla sintassi / simboli utilizzati per denotare, costruire un'espressione regolare. L'espressione regolare consente all'utente di abbinare una stringa con un determinato modello.
Questo è molto utile in situazioni che richiedono una rapida convalida dell'input come quando un utente inserisce il suo indirizzo e-mail o numero di telefono, regex può essere utilizzato per convalidare rapidamente il formato e informare l'utente del problema se l'utente ha inserito il formato sbagliato.
Abbiamo anche imparato ad affrontare diversi scenari che possono essere utilizzati per una varietà di applicazioni diverse. Abbiamo esaminato il processo passo passo per scrivere espressioni per la corrispondenza di parole, alfabeti, indirizzi di siti Web, ID e-mail e persino tipi di file ed estensioni.
Questi scenari sono molto utili nella convalida in tempo reale degli input dell'utente senza scrivere numerose righe di codice e quindi aiutano a risparmiare tempo e ridurre la complessità. Questi esempi sono stati utilizzati per guidare l'utente a creare il proprio set di espressioni regolari e quindi aiutarlo a gestire molti altri scenari diversi.
L'espressione regolare può essere semplice come utilizzare l'alfabeto o i numeri per abbinare una data serie di caratteri o complessa utilizzando una combinazione di caratteri speciali, quantificatori, classi di caratteri, ecc. Per convalidare formati complessi o per cercare un modello specifico nella serie di caratteri.
In poche parole, un'espressione regolare è uno strumento abbastanza potente per un programmatore e aiuta a ridurre la quantità di codice necessaria per eseguire una corrispondenza dei dati o un'attività di convalida.
=> Controlla TUTTI i tutorial di C # qui.
Lettura consigliata
- Esercitazione sulle stringhe in C # - Metodi sulle stringhe con esempi di codice
- Generatore di numeri casuali C # e stringhe casuali C # con esempi di codice
- Esercitazione sulle espressioni regolari C ++: espressioni regolari in C ++ con esempi
- MongoDB Regular Expression $ regex con Example
- Tutorial Java Regex con esempi di espressioni regolari
- Come usare le espressioni regolari Unix
- Utilizzo del post processore in JMeter (Regular Expression Extractor)
- Tutorial Java String | Metodi Java String con esempi