Delphi XE. Работа с регулярными выражениями.

Уже почти год назад я затрагивал тему о работе с регулярными выражениями VBScript в Delphi 2010. Сегодня наконец-то докачал iso-образ диска с RAD Studio XE, установил Delphi XE для более пристального ознакомления с новинками и обнаружил несколько новых модулей, цель которых — обеспечение работы с регулярными выражениями в Delphi. Я решил вспомнить прошлое и написать небольшую программку, демонстрирующую работы с регулярными выражениями с использованием «родных» модулей в Delphi XE.

Вначале немного о том, что за новые модули появились в версии XE и вкратце, что в них содержится.

RegularExpressionsAPI.pas -обёртка для библиотеки PCRE. PCRE — это библиотека содержащая ряд функций для работы с регулярными выражениями синтаксис которых максимально приближен к синтаксису регулярных выражений в Perl 5.

RegularExpressionsCore.pas — как становится понятным из названия — модуль представляет собой некое ядро вокруг которого и крутится вся работа с регулярными выражениями в Delphi. Так, например, в модуле RegularExpressionsCore содержатся такие «говорящие» классы как TPerlRegEx, TPerlRegExOptions и т.д. Соответственно этот модуль опирается в своей работе на функции из RegularExpressionsAPI.pas.

RegularExpressionsConsts.pas — содержит ресурсные строки, используемые при выводе сообщений об ошибках при работе с регулярными выражениями.

RegularExpressions.pas — модуль в котором содержаться всё необходимое для работы с регулярными выражениями в Delphi XE. Естественно модуль опирается на все три предыдущих.

Теперь приступим к более пристальному рассмотрению новинок.

Работа с TRegEx в Delphi XE

В TRegEx содержаться все необходимые методы и свойства для работы с регулярными выражениями. Практически все методы имеют «двойников» в виде классовых функций. Поэтому можно работать с регулярками или так:

...
var RegEx: TRegEx;
begin
 RegEx:=TRegEx.Create('Any regular expression');
 if RegEx.IsMatch('Any text')then
   ShowMessage('Есть совпадения')
...

А можно и без создания нового экземпляра TRegEx:

...
begin
 if RegEx.IsMatch('Any text','Any regular expression')then
   ShowMessage('Есть совпадения')
...

Как Вам будет удобнее в той или иной ситуации. Рассмотрим методы TRegEx.
Конструкторы:

constructor Create(const Pattern: string); overload;
constructor Create(const Pattern: string; Options: TRegExOptions); overload;

где Pattern — регулярное выражение, а Options — множество, содержащее опции, используемые при поиске совпадений.

function IsMatch(const Input: string): Boolean; overload;
function IsMatch(const Input: string; StartPos: Integer): Boolean; overload;
class function IsMatch(const Input, Pattern: string): Boolean;overload; static;
class function IsMatch(const Input, Pattern: string; Options: TRegExOptions): Boolean; overload; static;

IsMatch возвращает True, если в тексте Input найдено хотя бы одно совпадение. При этом парсинг можно начать не с начала строки, а с позиции StartPos.

function Match(const Input: string): TMatch; overload;
function Match(const Input: string; StartPos: Integer): TMatch; overload;
function Match(const Input: string; StartPos, Length: Integer): TMatch; overload;
class function Match(const Input, Pattern: string): TMatch; overload; static;
class function Match(const Input, Pattern: string; Options: TRegExOptions): TMatch; overload; static;

Match возвращает запись TMatch, которая содержит результаты одного совпадения с регулярным выражением.

function Matches(const Input: string): TMatchCollection; overload;
function Matches(const Input: string; StartPos: Integer): TMatchCollection; overload;
class function Matches(const Input, Pattern: string): TMatchCollection; overload; static;
class function Matches(const Input, Pattern: string; Options: TRegExOptions): TMatchCollection; overload; static;

Matches возвращает все совпадения с регулярным выражением. При этом TMatchCollection представляет собой запись, которая содержит список всех найденных совпадений TMatch.

function Replace(const Input, Replacement: string): string; overload;
function Replace(const Input: string; Evaluator: TMatchEvaluator): string; overload;
function Replace(const Input, Replacement: string; Count: Integer): string; overload;
function Replace(const Input: string; Evaluator: TMatchEvaluator; Count: Integer): string; overload;
class function Replace(const Input, Pattern, Replacement: string): string; overload; static;
class function Replace(const Input, Pattern: string; Evaluator: TMatchEvaluator): string; overload; static;
class function Replace(const Input, Pattern, Replacement: string; Options: TRegExOptions): string; overload; static;
class function Replace(const Input, Pattern: string; Evaluator: TMatchEvaluator; Options: TRegExOptions): string; overload; static;

Заменяет все вхождения строки Replacement в строке Input. Напоминает всем известный метод StrinReplace, но предоставляет более широкие возможности по замене. При этом замена текста в исходной строке может осуществляться с использованием регулярного выражения для этого необходимо определить метод:

TMatchEvaluator = function(const Match: TMatch): string of object;

возвращающий в результате строку, исходя из содержащихся в TMatch данных. Также, в параметре Count можно указать максимальное количество замен. Рассморим возможности этой функции немного по-подробнее. Напишем простую программку, которая будет искать в строке текста все латинские символы A и менять их на B. Ничего особенного — просто демонстрация возможностей метода. Внешний вид приложения следующий:

В Edit будем записывать регулярное выражение, в Memo — текст для парсинга, а в нижний ListBox — все найденные совпадения и результаты работы метода Replace. С помощью CheckBox’ов будем устанавливать необходимые опции (об опциях чиайте ниже).
Вначале определим метод TMatchEvaluator следующим образом:

function TForm8.Evaluator(const Match: TMatch): string;
begin
Result:='';
  if pos('A',Match.Value)>0 then
    Result:='B'
end;

То есть при использовании этого метода в Replase замена будет происходить следующим образом: если найдена заглавная буква, то она заменяется на заглавную B, иначе — на пустую строку.

Теперь пишем обработчик OnClick «Проверить»

procedure TForm8.Button1Click(Sender: TObject);
var RegEx: TRegEx;
    Options: TRegExOptions;
    M: TMatchCollection;
    i,j:integer;
begin
 //определяем необходимые опции
 Options:=[];
 if CheckBox1.Checked then
   Include(Options, roIgnoreCase);
 if CheckBox2.Checked then
   Include(Options, roMultiLine);
 if CheckBox3.Checked then
   Include(Options, roExplicitCapture);
 if CheckBox4.Checked then
   Include(Options, roCompiled);
 if CheckBox5.Checked then
   Include(Options, roSingleLine);
 if CheckBox6.Checked then
   Include(Options, roIgnorePatternSpace);
 
 ListBox1.Items.Clear;
 //создаем объект
 RegEx:=TRegEx.Create(Edit1.Text,Options);
 //Если найдено хотя бы одно совпадение продолжаем работу
 if RegEx.IsMatch(Memo1.Text)then
   begin
     M:=RegEx.Matches(Memo1.Text,Edit1.Text,Options);//получаем коллекцию совпадений
     for  i:=0 to M.Count-1 do
       begin
         ListBox1.Items.Add(M.Item[i].Value);//выводим совпадение
         for j:= 0 to M.Item[i].Groups.Count-1 do //если в регулярном выражении есть группы
           ListBox1.Items.Add('   Группа '+IntToStr(j)+' '+M.Item[i].Groups[j].Value)
       end;
      //Выводим результаты работы Replace
      ListBox1.Items.Add(RegEx.Replace(Memo1.Text,Evaluator));
      ListBox1.Items.Add(RegEx.Replace(Memo1.Text,'B'));
   end;
end;

Теперь проверим работу. Запустим приложение и запишем в Memo, например, такую строку:

Evaluator - это метод, который "заставляет" заменять в исходной строке все символы "A" на "B" с использованием особых правил замены

А регулярное выражение зададим, например так:

.?A.?

Вначале проверяем без дополнительных опций. Результат поиска совпадение:

1 совпадение
Replace с Evaluator: Evaluator — это метод, который «заставляет» заменять в исходной строке все символы B на «B» с использованием особых правил замены
Replace без Evaluator: Evaluator — это метод, который «заставляет» заменять в исходной строке все символы B на «B» с использованием особых правил замены

То есть оба раза метод сработал идентично. Теперь включим опцию IgnoreCase (поиск без учёта регистра) и повторим замену. Результат:

3 совпадеия («A», uat, val)
Replace с Evaluator: Eor — это метод, который «заставляет» заменять в исходной строке все символы B на «B» с использованием особых правил замены
Replace без Evaluator: EBBor — это метод, который «заставляет» заменять в исходной строке все символы B на «B» с использованием особых правил замены

То есть, как видно из замен в слове «Evaluator», мы не просто провели замену подстрок, но и, в первом случае (с использованием метода Evaluator) определили свои собственные правила замены подстрок. Соответственно, включив в параметры Replace третье значение (Count) мы помимо всего прочего можем определить количество замен в строке.

И, наконец, последний метод TRegEx:

function Split(const Input: string): TArray; overload; inline;
function Split(const Input: string; Count: Integer): TArray; overload; inline;
function Split(const Input: string; Count, StartPos: Integer): TArray; overload;
class function Split(const Input, Pattern: string): TArray; overload; static;
class function Split(const Input, Pattern: string; Options: TRegExOptions): TArray; overload; static;

Split делит строку на подстроки с использованием регулярного выражения и помещает эти подстроки в массив. При этом совпадения с регулярным выражением выступают в качестве разделителя и выбрасываются из результатов деления.
Чтоб далеко не ходить — применим этот метод с использованием рассмотренного выше регулярного выражения и строки для поиска. Допишем наш обработчик onClick следующим образом:

procedure TForm8.Button1Click(Sender: TObject);
var
    ...
    Mass: TArray;
begin
      ...
      ListBox1.Items.Add(RegEx.Replace(Memo1.Text,'B'));
      //делим строку
      Mass:=RegEx.Split(Memo1.Text);
      for i := 0 to length(Mass)-1 do
         ListBox1.Items.Add(Mass[i])
   end;
end;

Результат деления строки с использованием опции IgnoreCase получился следующим:

3 совпадеия (“A”, uat, val)
Части строки:
E
» (пустая строка)
or — это метод, который “заставляет” заменять в исходной строке все символы
на “B” с использованием особых правил замены

Пустая строка является в приведенном примере результатом того, что два совпадения в строке идут один за другим — соответственно split возвращает символы между ними, т.е. строку нулевого размера.
Вот собственно те методы, используя которые можно использовать регулярные выражения в Delphi XE с использованием TRegEx. Осталось только упомянуть про опции, используемые при поиске и замене текста.

Опции TRegEx

Всего можно использовать шесть различных опций:
roIgnoreCase — поиск без учёта регистра символов
roMultiLine — включает многострочный режим парсинга. Имеет смысл использовать, когда в тексте встречаются символы перевода на новую строку.
roExplicitCapture — указывает на то, что в результаты работы будут включаться только именованные группы вида (…)
roCompiled — использование этой опции даёт более быстрое выполнение операций парсинга, но вызов методов TRegEx будет выполняться медленнее.
roSingleLine — однострочный режим. Парсинг будет осуществляться в строке до символа перевода /n
roIgnorePatternSpace — устраняет из паттерна неэкранированные пробелы и делает возможным использование в регулярных выражениях комментариев.

Вот, в принципе, краткий обзор возможностей Delphi XE по работе с регулярными выражениями. И в конце статьи пара ссылок на информацию по регулярным выражениям в Perl:
1. Регулярные выражения в Perl
2. WDH: Perl — регулярные выражения