Menu

Tutoriel C # Regex: Qu'est-ce qu'une expression régulière C #

  • Principal
  • Autre
  • Tutoriel C # Regex: Qu'est-ce qu'une expression régulière C #

c regex tutorial what is c regular expression

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel C # Regex explique ce qu'est une expression régulière en C #, sa syntaxe, les méthodes de classe Regex et comment utiliser ces méthodes à l'aide d'exemples:

L'expression régulière dans le C # est utilisée pour faire correspondre un modèle de caractère particulier. Les expressions régulières sont utilisées chaque fois qu'un utilisateur a besoin de trouver un modèle répétitif ou de faire une validation de données ou même de vérifier le formatage des données.

Un RegEx est utilisé pour déterminer si une chaîne contient ou correspond à un modèle de caractère donné. Une expression régulière est principalement une séquence de caractères qui désigne un modèle.

Un modèle peut être n'importe quoi allant des nombres, des caractères ou une combinaison de tous. Regex est largement utilisé pour la validation. Analyse ou correspondance de chaînes, par exemple, trouver si une chaîne correspond au format de devise, de numéro de téléphone ou de format de date.

=> Lisez la série de formations Easy C #.

qa manager entretien questions réponses pdf

C # Regex

Ce que vous apprendrez:

Classe Regex en C #

La classe Regex est utilisée en C # pour effectuer des opérations regex. Il contient plusieurs méthodes différentes qui peuvent être utilisées pour effectuer différentes opérations liées à regex.

Il peut être utilisé pour analyser du texte volumineux pour trouver une séquence de caractères particulière en utilisant des méthodes qui peuvent être utilisées pour effectuer une correspondance, pour remplacer ou pour diviser la séquence de caractères.

La classe regex est présente dans l'espace de noms; System.Text.RegularExpression. La classe accepte une chaîne sous la forme d'une séquence de caractères comme paramètre.

Méthodes C # Regex

IsMatch

La méthode la plus simple et la plus utile de la classe Regex est la méthode IsMatch. Cette méthode a différentes surcharges pour effectuer la correspondance des caractères en fonction de différents paramètres.

Le plus simple est IsMatch (texte de chaîne) , cette méthode permet à l'utilisateur de fournir une séquence de caractères pour faire correspondre une chaîne.

La deuxième surcharge IsMatch (texte de chaîne, position int). Cette méthode renvoie une valeur booléenne et prend deux paramètres (chaîne et entier). Le texte de chaîne spécifié dans le paramètre est essentiellement un constructeur d'expression régulière qui correspondra à la séquence de caractères à partir de la position de départ spécifiée par le paramètre entier.

Ainsi, cette méthode essaiera de faire correspondre la chaîne d'entrée à la position fournie par un paramètre entier dans une chaîne donnée.

La troisième surcharge, IsMatch (texte de chaîne, modèle de chaîne) accepte deux paramètres et renvoie une valeur booléenne. Le premier paramètre est un texte dans lequel l'utilisateur a besoin de trouver un modèle et le paramètre suivant fournit le modèle que l'utilisateur recherche dans le texte donné.

Lecture recommandée = >> Correspondance de modèles dans MySQL

Remplacer (texte de chaîne, texte de remplacement de chaîne)

La méthode replace accepte deux paramètres et renvoie une valeur de chaîne. Le premier paramètre est la séquence de caractères ou l'expression régulière que vous souhaitez utiliser pour la correspondance et le second est le remplacement de l'expression régulière.

La méthode fonctionne en trouvant une correspondance du texte donné, puis la remplace par le texte de remplacement fourni par l'utilisateur. La signature de la méthode est public string Replace (chaîne de texte, string replacementText)

Chaîne publique () Split (chaîne de texte)

La méthode split de la classe regex accepte une entrée de chaîne en tant que paramètre et retourne un tableau contenant des sous-chaînes. Le paramètre passé dans la méthode est la chaîne qui doit être fractionnée.

La méthode trouve le modèle d'entrée correspondant dans la chaîne et une fois qu'elle identifie un modèle correspondant, elle divise la chaîne à cet endroit en une sous-chaîne plus petite, chaque modèle correspondant étant le point de rupture. La méthode retourne ensuite un tableau contenant toutes les sous-chaînes.

Utilisation des méthodes Regex C #

Jetons un œil à l’utilisation de ces méthodes en écrivant un programme simple.

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); } }

La sortie du programme ci-dessus

Vrai
Vrai
Vrai
Remplacer le monde
Bonjour
Monde
Aujourd'hui

L'explication du code ci-dessus:

Au début du programme, nous avons créé un objet et pour le modèle que nous allons utiliser pour la correspondance de code dans l'entrée de chaîne suivante, nous avons utilisé le formatage du texte pour garder les choses simples au début, mais si vous êtes à l'aise, vous pouvez commencez à utiliser des modèles d'expressions régulières. (Nous discuterons en détail du modèle d'expression régulière au fur et à mesure que nous avancerons dans ce didacticiel)

Ensuite, nous utiliserons la chaîne de correspondance pour entrer le facteur que nous avons déclaré comme objet spécifié avec la chaîne d'entrée et s'il correspond, il retournera pour retourner false.

La méthode suivante que nous avons utilisée est IsMethod (entrée de chaîne, index int). Cette méthode accepte deux paramètres, et ici nous fournissons la chaîne d'entrée et l'index à partir duquel la correspondance doit commencer. Par exemple, ici, nous voulions démarrer la correspondance depuis le début de la chaîne d'entrée.

Ensuite, nous avons démontré l'utilisation d'IsMatch (entrée de chaîne, modèle de chaîne). Ici, nous avons fourni la chaîne d'entrée, nous voulions trouver que si le texte du modèle est présent ou non dans l'entrée. Si c'est présent, alors il retournera true (comme dans notre cas) sinon il retournera false.

Une autre méthode dont nous avons discuté est remplacée. Cette méthode est très utile dans les programmes où vous souhaitez apporter des modifications aux données d'entrée ou changer le format des données existantes.

Ici, nous fournissons deux paramètres, le premier est la chaîne d'entrée et le second est la chaîne qui peut être utilisée pour remplacer la chaîne précédente. Cette méthode utilise également le modèle défini dans l'objet regex que nous avons défini précédemment.

Une autre méthode importante que nous avons utilisée est la division. Cette méthode est utilisée pour diviser la chaîne donnée en fonction de certains modèles récurrents. Ici, nous avons fourni une chaîne «Hello_World_Today».

Disons que nous voulons supprimer le trait de soulignement de la chaîne donnée et obtenir les sous-chaînes. Pour cela, nous spécifions le paramètre d'entrée, puis nous donnons le modèle que nous devons utiliser comme point de fractionnement. La méthode retourne un tableau et nous pouvons utiliser une simple boucle comme foreach pour récupérer toutes les chaînes.

Syntaxe des expressions régulières

Il existe plusieurs syntaxes différentes telles que des caractères spéciaux, des quantificateurs, des classes de caractères, etc. qui peuvent être utilisées pour faire correspondre un certain modèle à partir d'une entrée donnée.

Dans cette partie du didacticiel, nous allons plonger profondément dans la syntaxe offerte par regex et essayer de résoudre certains scénarios réels en les utilisant. Avant de continuer, assurez-vous que vous avez acquis l'idée de base de l'expression régulière et des différentes méthodes disponibles dans la classe regex.

Caractères spéciaux

Les caractères spéciaux dans une expression régulière sont utilisés pour attribuer plusieurs significations différentes à un modèle. Nous allons maintenant examiner certains des caractères spéciaux largement utilisés et leur signification dans Regex.

Caractères spéciauxSens
w et W«W» minuscule est utilisé pour faire correspondre les caractères alphanumériques / soulignés et «W» majuscule est utilisé pour faire correspondre les caractères autres que des mots.
^C'est l'une des syntaxes les plus utilisées. Il indique le début, le mot ou le modèle après que cela commence à correspondre au début du texte d'entrée.
$Ce signe est utilisé pour faire correspondre les mots de la fin de la chaîne. Les mots / motifs indiqués avant ce symbole correspondent aux mots présents à la fin de la chaîne.
. (point)Le point est utilisé pour faire correspondre un seul caractère dans la chaîne donnée une seule fois.
nCeci est utilisé pour une nouvelle ligne.
d et D«D» minuscule est utilisé pour faire correspondre un caractère numérique et «D» majuscule est utilisé pour faire correspondre les caractères non numériques.
s et S«S» minuscule est utilisé pour faire correspondre les espaces blancs et «S» majuscule est utilisé pour faire correspondre les espaces non blancs.

Syntaxe du quantificateur

La syntaxe du quantificateur est utilisée pour compter ou quantifier les critères de correspondance. Par exemple, si vous souhaitez vérifier si une chaîne particulière contient un alphabet une ou plusieurs fois. Jetons un coup d'œil à certains des quantificateurs couramment utilisés dans l'expression régulière.

Syntaxe du quantificateurSens
*Ce symbole est utilisé pour correspondre au caractère précédent.
+Ce symbole est utilisé pour faire correspondre un ou plusieurs caractères dans une ligne.
{n}Le chiffre numérique à l'intérieur des accolades est utilisé pour faire correspondre le numéro du caractère précédent défini par des chiffres entre accolades.
{n,}Le chiffre entre accolades et ce symbole est utilisé pour s'assurer qu'il correspond au moins à n (c'est-à-dire valeur numérique entre accolades).
{n, m}Ce symbole est utilisé pour faire correspondre le caractère précédent de n nombre de fois à m nombre de fois.
?Ce symbole fait correspondre les caractères précédents comme facultatifs.

Classe de personnage

La classe de caractères est également connue sous le nom de jeux de caractères, et elle est utilisée pour indiquer au moteur d'expression régulière de rechercher une seule correspondance parmi plusieurs caractères. Une classe de caractères correspond à un seul caractère et l’ordre des caractères inclus dans le jeu de caractères n’a pas d’importance.

Classe de personnageSens
( gamme )Le symbole entre crochets est utilisé pour correspondre à une plage de caractères. Par exemple, nous pouvons l'utiliser pour définir n'importe quel caractère dans la plage de l'alphabet «a» à «z» en enfermant la plage à l'intérieur du crochet comme (a-z)
Ou, nous pouvons également faire correspondre les chiffres «1» à «9» en indiquant (1-9)
(^ range)Cela dénote une classe de caractère de négation. Il est utilisé pour correspondre à n'importe quoi, pas dans la plage indiquée à l'intérieur du crochet.
Ceci est utilisé pour faire correspondre les caractères spéciaux qui peuvent avoir leurs propres symboles regex. La barre oblique est utilisée pour faire correspondre les caractères spéciaux dans leur forme littérale.

Regroupement

Des crochets ou des parenthèses peuvent être utilisés pour regrouper une partie de l'expression régulière. Cela permet à l'utilisateur d'ajouter un quantificateur avec l'expression.

RegroupementSens
(expression de groupe)Les crochets sont utilisés pour regrouper une expression.
|Le | L'opérateur est utilisé à l'intérieur du crochet rond pour utiliser une alternative par exemple (a | b).

Exemples d'expressions régulières C #

Dans la section précédente, nous avons appris les symboles des expressions régulières, dans cette section, nous examinerons en détail l'utilisation de différents symboles dans l'expression régulière et la combinaison dans laquelle ils peuvent être utilisés pour correspondre à différentes expressions.

Dans ce didacticiel, nous discuterons de certains des scénarios réels les plus courants auxquels vous pouvez être confronté en tant que développeur lorsque vous travaillez sur une application ou dans un programme simple pour obtenir les commentaires de l'utilisateur.

Exemple d'expression régulière avec des scénarios réels

Apprenons-en plus sur les expressions régulières à l'aide d'exemples en temps réel.

Scénario 1: Validez si la chaîne d'entrée est composée de 6 caractères alphabétiques insensibles à la casse.

Un scénario d'expression régulière le plus courant consiste à rechercher et à faire correspondre un mot donné. Par exemple, disons que je veux une chaîne alphabétique aléatoire de l'utilisateur et que cette entrée doit contenir exactement 6 chiffres.

Pour valider que nous pouvons utiliser une simple expression régulière. Écrivons un programme pour mieux comprendre l'écriture et l'utilisation des expressions régulières.

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')); }

Production

Vrai
Faux

Explication

Dans cet exemple, nous essayons de valider une chaîne d'entrée, pour vérifier si elle contient des caractères alphabétiques à six chiffres. Les caractères peuvent être à la fois en minuscules et en majuscules, nous devons donc en tenir compte également.

Donc, ici, nous avons défini un modèle d'expression régulière dans la variable «patternText», puis l'avons passé dans l'objet regex. Maintenant, les lignes de code suivantes sont assez simples, nous avons utilisé la méthode IsMatch pour comparer l'expression régulière et la chaîne d'entrée.

Jetons maintenant un œil à l'expression régulière que nous avons conçue. L'expression (^ (a-zA-Z) {6} $) est composée de 4 parties différentes. «^», «(A-zA-Z)», «{6}» et «$». La deuxième partie indique les caractères correspondants, qui sont utilisés pour effectuer la correspondance d'expression, «a-z» pour les minuscules et «A-Z» pour les lettres majuscules.

Le caractère de première partie «^» garantit que la chaîne commence par un modèle défini dans la deuxième partie, c'est-à-dire des alphabets minuscules et majuscules.

Les accolades dans la troisième partie déterminent le nombre de caractères dans la chaîne qui peuvent être identifiés par le modèle défini, c'est-à-dire 6 dans ce cas et le symbole «$» s'assurent qu'il se termine par le modèle défini dans la deuxième partie.

^ (a-zA-Z) {6} $

Scénario 2: Utilisez une expression régulière pour valider qu'un mot qui commence par «Super» et qui a un espace blanc après cela, c'est-à-dire pour valider si «Super» est présent au début d'une phrase.

Supposons que nous lisions certaines entrées de l'utilisateur et que nous devions nous assurer que l'utilisateur commence toujours sa phrase par un mot, un nombre ou un alphabet particulier. Cela peut être réalisé assez facilement en utilisant une simple expression régulière.

Examinons un exemple de programme, puis discutons en détail de la manière d’écrire cette expression.

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')); }

Production

Vrai
Faux

Explication

Dans cet exemple également, nous avons utilisé une configuration de code similaire à celle du premier. Le modèle d'expression régulière dans ce scénario nécessite une correspondance avec une combinaison de mots ou de phrases commençant par «Super».

^ Super

Donc, comme nous voulons faire correspondre depuis le début de la série de mots, nous allons commencer par mettre le symbole «^», puis nous donnerons le motif que nous voulons faire correspondre, dans ce cas, «Super». Maintenant, le modèle que nous avons créé «^ Super» peut correspondre à toutes les valeurs de super, même superman ou surnaturel, mais nous ne voulons pas seulement le mot «Super».

Cela signifie qu'il devrait y avoir un espace blanc après le mot pour marquer la fin du mot et le début d'un autre mot. Pour ce faire, nous allons ajouter le symbole « s» au motif et ainsi faire de notre motif final comme

^ Super s

Scénario 3: utilisez une expression régulière pour rechercher des noms de fichiers valides avec une extension de type de fichier image.

Un autre scénario en temps réel important auquel les développeurs sont souvent confrontés est la validation des types de fichiers. Supposons que nous ayons un bouton d'importation dans l'interface utilisateur, qui ne peut accepter que les extensions de type de fichier image.

Nous devons valider le fichier de téléchargement de l'utilisateur et l'informer au cas où il aurait téléchargé le mauvais format de fichier. Cela peut être facilement réalisé en utilisant l'expression régulière.

Ci-dessous est un programme simple pour vérifier cela.

public static void Main(string() args) jpeg

Production

Vrai
Vrai
Vrai
Faux
Faux

Explication

Ici, nous devons faire correspondre un nom de fichier. Un nom de fichier valide est composé de trois parties ( nom du fichier +. + extension de fichier ). Nous devons créer une expression régulière pour correspondre aux trois parties. Commençons par faire correspondre la première partie, c'est-à-dire le nom du fichier. Un nom de fichier peut contenir des caractères alphanumériques et spéciaux.

Comme indiqué précédemment, le symbole pour désigner cela est « w». De plus, le nom de fichier peut être composé d'un ou plusieurs caractères et utilisera donc le symbole «+». Combinez-les et nous obtenons le symbole de la première partie.

(w+)

Le support a séparé cela en plusieurs parties. La partie suivante est le symbole du point. Comme le symbole de point a sa signification dans une expression régulière, nous utiliserons une barre oblique inverse devant lui pour lui donner une signification littérale. Combinez les deux et nous couvrons les deux premières parties de l'expression régulière.

(w+).

Maintenant, pour la troisième et dernière partie, nous pouvons définir directement les extensions de fichier requises séparées par «|» Symbole OU. Cela peut ensuite être séparé en enfermant à l'intérieur d'un support circulaire. Un signe «$» à la fin s'assure que les extensions définies sont à la fin de la chaîne. Maintenant, combinons-les pour obtenir l'expression régulière finale.

(w+).(jpg|png|jpeg|gif)$

Maintenant, si nous l'utilisons dans le programme, nous pouvons voir qu'il correspond au format correct et renvoie vrai mais avec des formats invalides, il renvoie faux.

Scénario 4: utiliser une expression régulière pour valider un format d'adresse de site Web

Supposons que nous ayons un formulaire Web qui accepte une adresse Web ou une adresse de domaine. Nous voulons que l'utilisateur entre la bonne adresse Web / domaine lors du remplissage du formulaire. Pour déterminer si l'utilisateur a saisi une adresse Web correcte, une expression régulière peut être très 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')); }

Production

Vrai
Faux

Explication

Ici, nous voulons faire correspondre un nom de domaine valide à l'aide d'une expression régulière. Un nom de domaine valide commence par l'abréviation «www» suivi d'un point (.) Puis le nom du site Web après un point (.) Et à la fin une extension de domaine.

Donc, comme dans le scénario précédent, nous allons essayer de le faire correspondre partie par partie. Commençons par faire correspondre 'www.' Partie. Nous commençons donc par le symbole de départ, puis par «www». C'est quelque chose qui est fixe, nous utilisons donc le symbole de départ suivi des mots exacts à faire correspondre.

“^www.”

Ensuite, nous commencerons à travailler sur la deuxième partie. La deuxième partie de l'adresse Web peut être n'importe quel nom alphanumérique. Donc, ici, nous utiliserons les crochets présents dans la classe de caractères pour définir la plage qui doit être mise en correspondance. Après avoir ajouté la deuxième partie avec la deuxième partie nous donnera.

“^www.(a-zA-Z0-9){3,20}”

Ici, nous avons également ajouté des accolades pour définir la longueur de caractère minimale et maximale pour le nom du site Web. Nous avons donné un minimum de 3 et un maximum de 20. Vous pouvez donner la longueur minimum ou maximum que vous voulez.

Maintenant, après avoir couvert les première et deuxième parties de l'adresse Web, il ne nous reste plus que la dernière partie, c'est-à-dire l'extension de domaine. C'est assez similaire à ce que nous avons fait dans le dernier scénario, nous allons directement faire correspondre les extensions de domaine en utilisant OR et en plaçant chaque extension de domaine valide dans le crochet circulaire.

Ainsi, si nous ajoutons tous ces éléments ensemble, nous aurons une expression régulière complète correspondant à toute adresse Web valide.

www.(a-zA-Z0-9){3,20}.(com|in|org|co.in|net|dev)$

Scénario 5: utiliser une expression régulière pour valider un format d'ID de messagerie

Supposons que nous ayons un formulaire de connexion sur notre page Web qui demande aux utilisateurs de saisir leur adresse e-mail. Pour des raisons évidentes, nous ne souhaitons pas que notre formulaire continue avec des adresses e-mail invalides. Pour valider si l'adresse e-mail saisie par l'utilisateur est correcte ou non, nous pouvons utiliser une expression régulière.

Vous trouverez ci-dessous un programme simple pour valider une adresse 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')); }

Production

Vrai
Vrai
Faux

Explication

Une adresse e-mail valide contient des alphabets, des chiffres et des caractères spéciaux tels que le point (.), Le tiret (-) et les traits de soulignement (_) suivis du symbole «@» qui est ensuite suivi du nom de domaine et de l'extension de domaine.

Ainsi, nous pouvons diviser l'adresse e-mail en quatre parties, à savoir l'identifiant de l'e-mail, le symbole «@», le nom de domaine et le dernier étant l'extension de domaine.

Commençons par écrire une expression régulière pour la première partie. Il peut être alphanumérique avec quelques caractères spéciaux. Supposons que nous ayons une taille d'expression comprise entre 5 et 25 caractères. Semblable à la façon dont nous l'avons écrit plus tôt (dans le scénario de courrier électronique), nous pouvons trouver l'expression suivante.

^(a-zA-Z0-9._-){5,25}

Passons maintenant à la deuxième partie. C'est relativement simple car nous n'avons qu'à faire correspondre un seul symbole, à savoir '@'. L'ajouter à l'expression ci-dessus nous donne.

^(a-zA-Z0-9._-){5,25}.@

Passer à la troisième partie, c'est-à-dire que le nom de domaine sera toujours une série de caractères alphabétiques minuscules. Si vous le souhaitez, vous pouvez également inclure des caractères alphabétiques numériques ou majuscules, mais pour ce scénario, nous utiliserons des alphabets minuscules.

Si nous ajoutons l'expression pour les alphabets minuscules d'une longueur allant de 2 à 12 caractères, alors nous aurons l'expression suivante.

^(a-zA-Z0-9._-){5,25}.@.(a-z){2,12}

Maintenant, il ne nous reste plus que l'expression pour l'extension de domaine, similaire au quatrième scénario, nous allons gérer certaines extensions de domaine spécifiques. Si vous le souhaitez, vous pouvez en ajouter d'autres en les plaçant dans un crochet circulaire et en les séparant par un '|' symbole.

La consolidation de cette expression avec l'expression précédente nous donnera notre valeur d'expression finale pour la validation des e-mails.

^(a-zA-Z0-9._-){5,25}.@.(a-z){2,12}.(com|org|co.in|net)

Conclusion

Dans ce didacticiel, nous avons appris ce qu'est une expression régulière ainsi que la syntaxe / les symboles utilisés pour désigner, construire une expression régulière. L'expression régulière permet à l'utilisateur de faire correspondre une chaîne avec un modèle donné.

Ceci est très utile dans les situations qui nécessitent une validation rapide de l'entrée, comme lorsqu'un utilisateur entre son adresse e-mail ou son numéro de téléphone, l'expression régulière peut être utilisée pour valider rapidement le format et informer l'utilisateur du problème si l'utilisateur a entré le mauvais format.

Nous avons également appris à aborder différents scénarios pouvant être utilisés pour une variété d'applications différentes. Nous avons examiné le processus étape par étape pour écrire des expressions pour les mots correspondants, les alphabets, les adresses de sites Web, les identifiants de messagerie et même les types de fichiers et les extensions.

Ces scénarios sont très utiles pour la validation en temps réel des entrées utilisateur sans écrire de nombreuses lignes de code et permettent ainsi de gagner du temps et de réduire la complexité. Ces exemples ont été utilisés pour guider l'utilisateur dans la création de son propre ensemble d'expressions régulières et ainsi l'aider à gérer plusieurs autres scénarios différents.

quoi utiliser à la place de ccleaner

Les expressions régulières peuvent être simples comme l'utilisation de l'alphabet ou des chiffres pour correspondre à une série donnée de caractères ou complexes en utilisant une combinaison de caractères spéciaux, de quantificateurs, de classes de caractères, etc. pour valider des formats complexes ou pour rechercher un modèle spécifique dans la série de caractères.

En un mot, une expression régulière est un outil assez puissant pour un programmeur et aide à réduire la quantité de code nécessaire pour effectuer une correspondance de données ou une tâche de validation.

=> Consultez TOUS les didacticiels C # ici.

lecture recommandée

^