FAQ DelphiConsultez toutes les FAQ

Nombre d'auteurs : 123, nombre de questions : 919, dernière mise à jour : 14 juin 2019  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums Delphi et Delphi et bases de données de www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose soient correctes. Les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous souhaitez y apporter des corrections ou la compléter, contactez un responsable (lien au bas de cette page).

Nous espérons que cette FAQ saura répondre à vos attentes. Nous vous en souhaitons une bonne lecture.

L'équipe Delphi de Developpez.com.

Commentez


SommaireExpressions régulières (9)
précédent sommaire suivant
 

Il y a plusieurs façons d'utiliser les expressions régulières avec Delphi.

Si vous possédez Delphi XE ou une version postérieure, le plus simple est d'utiliser l'unité System.RegularExpressions.

Si vous possédez une version antérieure à Delphi XE, plusieurs possibilités s'offrent à vous. Le choix peut-être le plus recommandable est d'utiliser la classe TPerlRegEx de l'unité PerlRegEx. L'avantage de cette unité est d'être identique à l'unité System.RegularExpressionsCore livrée avec les versions récentes de Delphi (à partir de Delphi XE). Votre code sera donc réutilisable en cas de migration vers une version plus récente.

Une autre possibilité est d'utiliser la classe TRegExpr de l'unité RegExpr. L'avantage de cette unité est d'être identique à l'unité du même nom livrée avec Free Pascal. Toutefois cette unité n'est pas compatible avec les versions récentes de Delphi.

Une autre possibilité encore est d'utiliser la classe IRegex de l'unité PCRE. Il s'agit d'une unité pour Delphi 7, qui peut également être compilée avec Free Pascal.

Une autre possibilité enfin est d'utiliser la classe TFLRE de l'unité FLRE. L'avantage de cette bibliothèque est, outre sa rapidité, le fait qu'elle soit compatible aussi bien avec Delphi ancienne et nouvelle génération qu'avec Free Pascal.

Mis à jour le 9 décembre 2015 Roland Chastain

La fonction MatchesMask de l'unité System.Masks indique si un nom de fichier est conforme au format spécifié par une chaîne filtre.

Code : Sélectionner tout
function MatchesMask(const Filename, Mask: string): Boolean;
Appelez MatchesMask pour vérifier un nom de fichier. Le paramètre Mask sert à décrire les valeurs valides. Un masque valide est composé de caractères littéraux, d'ensembles de caractères et de métacaractères (wildcards).

Un caractère littéral correspond à un et un seul caractère de la chaîne examinée. La comparaison des caractères littéraux est insensible à la casse.

Un ensemble commence par un crochet ouvrant ([) et se termine par un crochet fermant (]). Entre les crochets se trouvent les éléments de l'ensemble. Chaque élément est un caractère littéral ou un intervalle. Les intervalles sont spécifiés par une valeur initiale, un trait d'union (-) et une valeur finale. N'utilisez ni espaces ni virgules pour séparer les éléments de l'ensemble. Un intervalle correspond à un et un seul caractère de la chaîne examinée. Un caractère appartient à un ensemble s'il est identique à l'un des caractères littéraux de l'ensemble ou s'il est compris dans l'un des intervalles de l'ensemble. Un caractère est compris dans un intervalle s'il est identique à la valeur initiale, ou à la valeur finale, ou à une valeur intermédiaire. Les comparaisons sont insensibles à la casse. Si le premier caractère après le crochet ouvrant est un point d'exclamation (!), l'ensemble représente tous les caractères n'appartenant pas à l'ensemble.

Les métacaractères sont l'astérisque (*) et le point d'interrogation (?). Un astérisque représente un nombre quelconque de caractères quelconques. Le point d'interrogation représente un et un seul caractère quelconque.

MatchesMask renvoie true si la chaîne examinée est conforme au masque, false dans le cas contraire. MatchesMask déclenche une exception si le masque lui-même n'est pas valide d'un point de vue syntaxique.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
program MatchesMask1; 
 
{$APPTYPE CONSOLE} 
 
uses 
  SysUtils, Masks; 
 
const 
  NAME = 'fichier1.ext'; 
 
begin 
  WriteLn(MatchesMask(NAME, 'FICHIER1.EXT'));          { Pas de différence entre majuscules et minuscules. } 
  WriteLn(MatchesMask(NAME, 'fichier[12].ext'));       { Ensemble contenant '1' et '2'.                    } 
  WriteLn(MatchesMask(NAME, 'fichier[0-3].ext'));      { Ensemble contenant les caractères de '0' à '3'.   } 
  WriteLn(MatchesMask(NAME, '*.ext'));                 { Un nombre indéfini de caractères quelconques.     } 
  WriteLn(MatchesMask(NAME, 'fichier?.ext'));          { Un caractère quelconque.                          } 
  WriteLn(MatchesMask(NAME, 'fichier1*.ext'));         { Un nombre indéfini, y compris zéro.               } 
  WriteLn(MatchesMask(NAME, 'fichier1?.ext') = FALSE); { Un et un seul caractère.                          } 
  WriteLn(MatchesMask(NAME, 'fichier[!0].ext'));       { Un caractère qui n'est pas '0'.                   } 
  ReadLn; 
end.
Il est à noter que le paramètre FileName n'est pas nécessairement un nom de fichier. MatchesMask peut être utilisée pour vérifier la conformité d'une chaîne quelconque avec un masque correctement formé.

Mis à jour le 7 octobre 2015 Roland Chastain

La fonction IsMatch de la classe TRegEx indique si une chaîne de caractère donnée (ou l'une de ses parties) appartient à l'ensemble défini par une expression régulière.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
program RegularExpressions1; 
 
{$APPTYPE CONSOLE} 
 
uses 
  System.RegularExpressions; 
 
begin 
  WriteLn(TRegEx.IsMatch('bonjour', '\w'));         { un caractère alphanumérique                } 
  WriteLn(TRegEx.IsMatch('bonjour', '\w+'));        { un ou plusieurs caractères alphanumériques } 
  WriteLn(TRegEx.IsMatch('bonjour', '\w*'));        { zéro ou plus                               } 
  WriteLn(TRegEx.IsMatch('bonjour', '\w{7}'));      { sept                                       } 
  WriteLn(TRegEx.IsMatch('bonjour', '[a-z]{7}'));   { sept minuscules                            } 
  WriteLn(TRegEx.IsMatch('bonjour', '\d') = FALSE); { un chiffre                                 } 
  WriteLn(TRegEx.IsMatch('bonjour', '\s') = FALSE); { un espace au sens large                    } 
  WriteLn(TRegEx.IsMatch('bonjour', '\D'));         { un caractère qui n'est pas un chiffre      } 
  ReadLn; 
end.
Pour s'assurer que la chaîne entière (et non pas seulement l'une de ses parties) appartient à l'ensemble, on utilise les métacaractères représentant le début et la fin de la chaîne, à savoir l'accent circonflexe (^) et le dollar ($).

Code : Sélectionner tout
1
2
  WriteLn(TRegEx.IsMatch('bonjour', '^\w$') = FALSE); 
  { Il y a plus d'un caractère alphanumérique entre le début et la fin de la chaîne. }

Mis à jour le 10 décembre 2015 Roland Chastain

Pour extraire les multiples occurrences d'un motif dans une chaîne, on utilise une variable de type TMatch, en combinaison avec les fonctions Match et NextMatch de la classe TRegEx.

L'exemple suivant extrait les nombres d'une chaîne donnée.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
program RegularExpressions2; 
 
{$APPTYPE CONSOLE} 
 
uses 
  System.SysUtils, System.RegularExpressions; 
 
var 
  match: TMatch; 
 
begin 
  match := TRegEx.Match('10 +10 0.5 .5', '\s*[-+]?[0-9]*\.?[0-9]+\s*'); 
 
  while match.Success do 
  begin 
    WriteLn(match.Value); 
 
    match := match.NextMatch; 
  end; 
 
  ReadLn; 
end.

Mis à jour le 10 décembre 2015 Roland Chastain

L'unité PerlRegEx est identique à l'unité RegularExpressionsCore livrée avec Delphi à partir de la version XE. Le même code peut donc être compilé avec l'une ou l'autre de ces unités.

Voici un programme qui indique si un motif donné (en l'occurrence une date) se trouve dans une chaîne.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
program PerlRegEx1; 
{$APPTYPE CONSOLE} 
 
uses 
  SysUtils, 
{$IF CompilerVersion >= 22.0} 
  RegularExpressionsCore; 
{$ELSE} 
  PerlRegEx; (* http://www.regular-expressions.info/download/TPerlRegEx.zip *) 
{$IFEND} 
 
var 
  expr: TPerlRegEx; 
 
begin 
  expr := TPerlRegEx.Create; 
  expr.Subject := '10/12/2015'; 
  expr.RegEx := '\d{2}/\d{2}/\d{4}'; 
  if expr.Match then 
    WriteLn(expr.MatchedText); 
  expr.Free; 
  ReadLn; 
end.
Si votre version de Delphi est antérieure à la version XE, vous devez télécharger l'unité PerlRegEx et ajouter le chemin de l'unité dans les options du projet.

Mis à jour le 10 décembre 2015 Roland Chastain

Pour extraire les multiples occurrences d'un motif dans une chaîne, on utilise les fonctions Match et MatchAgain.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
program PerlRegEx2; 
{$APPTYPE CONSOLE} 
 
uses 
  SysUtils, Classes, 
{$IF CompilerVersion >= 22.0} 
  RegularExpressionsCore; 
{$ELSE} 
  PerlRegEx; (* http://www.regular-expressions.info/download/TPerlRegEx.zip *) 
{$IFEND} 
 
var 
  expr: TPerlRegEx; 
 
begin 
  expr := TPerlRegEx.Create; 
  expr.RegEx := '\d{2}/\d{2}/\d{4}'; 
  expr.Subject := '10/12/2015 11/12/2015'; 
 
  if expr.Match then 
    repeat 
      WriteLn(expr.MatchedText); 
    until not expr.MatchAgain; 
 
  expr.Free; 
  ReadLn; 
end.

Mis à jour le 10 décembre 2015 Roland Chastain

Pour chercher un motif dans une chaîne de caractères sans extraire la sous-chaîne correspondante, on utilise la méthode IsMatch() de la classe IRegex.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
uses 
  pcre; { http://renatomancuso.com/software/dpcre/dpcre.htm } 
 
var 
  regex: IRegex; 
   
begin 
  regex := RegexCreate('^\d{4}$'); 
  WriteLn(regex.IsMatch('2016')); // TRUE 
end.

Mis à jour le 28 septembre 2016 Roland Chastain

Pour extraire d'une chaîne les multiples occurrences d'un motif, la première solution est de relancer la recherche autant de fois que nécessaire, en passant à la méthode Match(), comme second paramètre, la position à partir de laquelle la recherche doit commencer.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
uses 
  pcre; 
 
var 
  aiguille, meule_de_foin: ansistring; 
  regex: IRegex; 
  resultat: IMatch; 
  position: longint; 
 
begin 
  aiguille := '\d'; 
  meule_de_foin := '_2_0_1_6_'; 
   
  regex := RegexCreate(aiguille); 
   
  position := 0; 
  resultat := regex.Match(meule_de_foin, position); 
   
  while resultat.Success do 
  begin 
    WriteLn(resultat.Value); 
    position := resultat.Groups[0].Index + resultat.Groups[0].Length; 
    resultat := regex.Match(meule_de_foin, position); 
  end; 
end.
La deuxième solution est de déclarer un objet de la classe IMatchCollection, qui sera créé en faisant appel à la méthode Matches() de la classe IRegex.

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
procedure TForm1.Button1Click(Sender: TObject); 
var 
  re: IRegex; 
  mc: IMatchCollection; 
  iMatch: Integer; 
  resultat: string; 
begin 
  re := RegexCreate('([^\.]*)\.pas'); 
  mc := re.Matches('qsdsdq.pas; aeze.pas'); 
  for iMatch := 0 to mc.Count - 1 do 
  begin 
    Memo1.Lines.Add(mc.Items[iMatch].Value); 
  end; 
end;

Mis à jour le 28 septembre 2016 Laurent Dardenne Roland Chastain

Bonjour,

je propose une nouvelle FAQ :

Dans la catégorie : Expressions régulières

Titre : Test de validité d'une adresse e-mail

Pour tester la validité d'une adresse mail, on peut utiliser les expressions régulière.
Cette fonction renvoie True si l'adresse est valide :

Code : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
Uses
  {$IF CompilerVersion >= 22.0}
  RegularExpressionsCore ;    //  pour Delphi XE et supérieur
  {$ELSE}
  PerlRegex ;                 //  sur http://www.regular-expressions.info/download/TPerlRegEx.zip 
  {$IFEND}
  ...
Function IsValidMail(const s: string): boolean;
//  Test de la validité d'une adresse e-mail
Const
  RegEmail = '[_a-zA-Z\d\-\.]+@([_a-zA-Z\d\-]+(\.[_a-zA-Z\d\-]+)+)';
Var
  Expr: TPerlRegex;
Begin
  Result := False ;
  Expr := TPerlRegex.Create;
  Try
    Expr.Subject := utf8string(s);
    Expr.RegEx := RegEmail ;
    Result := Expr.Match;
  Finally
    Expr.Free;
  End;
End;

Mis à jour le 9 février 2019 Charly910

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2019 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsables bénévoles de la rubrique Delphi : Gilles Vasseur - Alcatîz -

Partenaire : Hébergement Web