FAQ DelphiConsultez toutes les FAQ

function MatchesMask(const Filename, Mask: string): Boolean;

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.

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.

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. }

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.

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.

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.

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.

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.

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;

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;