Проверка начала или конца строки производится с помощью метасимволов ^ и $. Например, «^thing» соответствует строке, начинающейся с «thing». «thing$» соответствует строке, заканчивающейся на «thing». Эти символы работают только при включенной опции 's'. При выключенной опции 's' находятся только конец и начало текста. Но и в этом случае можно найти конец и начало строки, используя escape-последовательности \А и \Z.
Для задания границ слова используются метасимволы '\b'и '\В’
Regex re = new Regex("меня", "ms");
В данном случае образец в re соответствует не только «меня» в строке «найди меня», но и «меня» в строке «родители поменяли квартиру». Что бы избежать этого, можно предварить образец маркером границы слова:
Regex re - new Regex("\bменя", "ms");
Теперь будет найдено только «меня» в начале слова. Не стоит забывать, что ВНУТРИ класса символов '\b' обозначает символ backspace (стирания). Приведенные ниже в таблице метасимволы не заставляют машину регулярных выражений продвигаться по строке или захватывать символы. Они просто соответствуют определенному месту строки. Например, ^ определяет, что текущая позиция — начало строки. ‘^FTP' возвращает только те «FTP», что находятся в начале строки.
Символ | можно использовать для перебора нескольких вариантов. Употребление его вместе со скобками — '(•••|•••|•••)' — позволяет создать группы вариантов. Скобки используются для «захвата» подстрок для дальнейшего использования и сохранения их во встроенных переменных $1, $2,..., $9.
Regex re = new Regex("like (apples|pines|bananas)");
MatchCollection me = re.Matches("I like apples a lot");
Такой пример будет работать и найдет последовательность «like apples», поскольку «apples» — один из трех перечисленных вариантов. Скобки также поместят «apples» в $1 как обратную ссылку для дальнейшего использования. В основном это имеет смысл при замене.
Знакомство с классами пространства RegularExpressions
В данном пространстве расположено семейство из одного перечисления и восьми связанных между собой классов.
Это основной класс, всегда создаваемый при работе с регулярными выражениями. Объекты этого класса определяют регулярные выражения. Конструктор класса, как обычно, перегружен. В простейшем варианте ему передается в качестве параметра строка, задающая регулярное выражение. В других вариантах конструктора ему может быть передан объект, принадлежащий перечислению RegexOptions и задающий опции, которые действуют при работе с данным объектом. Среди опций отмечу одну: ту, что позволяет компилировать регулярное выражение. В этом случае создается программа, которая и будет выполняться при каждом поиске соответствия. При разборе больших текстов скорость работы в этом случае существенно повышается.
Рассмотрим четыре основных метода класса Regex.
Метод Match запускает поиск соответствия. В качестве параметра методу передается строка поиска, где разыскивается первая подстрока, которая удовлетворяет образцу, заданному регулярным выражением. В качестве результата метод возвращает объект класса Match, описывающий результат поиска. При успешном поиске свойства объекта будут содержать информацию о найденной подстроке.
Пример:
string FindMatch(string str, string strpat){
Regex pat = new Regex(strpat);
Match match =pat.Match(str);
string found = "";
if (match.Success) {
found =match.Value;
Console.WriteLine("Строка ={0}\tОбразец={1}\
tНайдено={2}", str,strpat,found);
}
return(found);
}
В качестве входных аргументов функции передается строка str, в которой ищется вхождение, и строка strpat, задающая образец - регулярное выражение. Функция возвращает найденную в результате поиска подстроку. Если соответствия нет, то возвращается пустая строка. Функция начинает свою работу с создания объекта pat класса Regex, конструктору которого передается образец поиска. Затем вызывается метод Match этого объекта, создающий объект match класса Match. Далее анализируются свойства этого объекта. Если соответствие обнаружено, то найденная подстрока возвращается в качестве результата, а соответствующая информация выводится на печать. (Чтобы работать с классами регулярных выражений, нужно добавить в начало проекта предложение: using System.Text.RegularExpressions.)
Поскольку запись регулярных выражений - вещь, не привычная приведем достаточно много примеров:
public void TestSinglePat(){
//поиск по образцу первого вхождения
string str,strpat,found;
Console.WriteLine("Поиск по образцу");
//образец задает подстроку, начинающуюся с символа a, далее идут буквы или цифры.
str ="start"; strpat =@"a\w+";
found = FindMatch(str,strpat); //art
str ="fab77cd efg";
found = FindMatch(str,strpat); //ab77cd
//образец задает подстроку, начинающуюся с символа a,
//заканчивающуюся f с возможными символами b и d в середине
strpat = "a(b|d)*f"; str = "fabadddbdf";
found = FindMatch(str,strpat); //adddbdf
//диапазоны и escape-символы
strpat = "[X-Z]+"; str = "aXYb";
found = FindMatch(str,strpat); //XY
strpat = @"\u0058Y\x5A"; str = "aXYZb";
found = FindMatch(str,strpat); //XYZ
}
Комментарии к этой процедуре. Регулярные выражения задаются @-константами. В первом образце используется последовательность символов \w+, обозначающая, как следует из таблицы 1, непустую последовательность латиницы и цифр. В совокупности образец задает подстроку, начинающуюся символом a, за которым следуют буквы или цифры (хотя бы одна). Этот образец применяется к двум различным строкам.
В следующем образце используется символ * для обозначения итерации. В целом регулярное выражениезадает строки, начинающиеся с символа a и заканчивающиеся символом f, между которыми находится возможно пустая последовательность символов из b и d.
Последующие два образца демонстрируют использование диапазонов и escape-последовательностей для представления символов, заданных кодами (в Unicode и шестнадцатиричной кодировке).
Метод Matches позволяет разыскать все вхождения, то есть все подстроки, удовлетворяющие образцу. У алгоритма поиска есть важная особенность - разыскиваются непересекающиеся вхождения подстрок. Можно считать, что метод Matches многократно запускает метод Match, каждый раз начиная поиск с того места, на котором закончился предыдущий поиск. В качестве результата возвращается объект MatchCollection, представляющий коллекцию объектов Match.
Пример "око и рококо"
Сколько раз строка "око" входит в строку "рококо" - один или два? Все зависит от того, как считать. С точки зрения метода Matches, - один раз, поскольку он разыскивает непересекающиеся вхождения, начиная очередной поиск вхождения подстроки с того места, где закончилось предыдущее вхождение. Еще один пример на эту же тему работает с числовыми строками.
Console.WriteLine("око и рококо");
strpat="око"; str = "рококо";
FindMatches(str, strpat); //Число совпадений 1
strpat="123";
str= "0123451236123781239";
FindMatches(str, strpat); // Число совпадений 4
Пример "кок и кук"
Распознать, где кок, а где кук. Наше регулярное выражение не распознает эти слова. Обратите внимание на точку в регулярном выражении, которая соответствует любому символу, за исключением символа конца строки. Все слова в строке поиска - кок, кук, кот и другие - будут удовлетворять шаблону, так что в результате поиска найдется множество соответствий.
Console.WriteLine("кок и кук");
strpat="(т|к).(т|к)";
str="кок тот кук тут как кот";
FindMatches(str, strpat); // Число совпадений 6
Метод NextMatch запускает новый поиск, начиная с того места, на котором остановился предыдущий поиск.
Метод Split является обобщением метода Split класса String. Он позволяет, используя образец, разделить искомую строку на элементы. Поскольку образец может быть устроен сложнее, чем простое множество разделителей, то метод Split класса Regex эффективнее, чем его аналог класса String.
Пример "Дом Джека"
Давайте вернемся к задаче разбора предложения на элементы. У метода класса string есть существенный недостаток, - он не справляется с идущими подряд разделителями и создает для таких пар пустые слова. Метод Split класса Regex лишен этих недостатков, в качестве разделителей можно задавать любую пару символов, произвольное число пробелов и другие комбинации символов. Повторим наш прежний пример:
public void TestParsing(){
string str,strpat;
//разбор предложения - создание массива слов
str = "А это пшеница, которая в темном чулане хранится, в доме, который построил Джек!";
strpat =" +|, "; //один или несколько пробелов или запятая и пробел
Regex pat = new Regex(strpat);
string[] words;
words = pat.Split(str);
int i=1;
foreach(string word in words)
Console.WriteLine("{0}: {1}",i++,word);
}
Регулярное выражение, заданное строкой strpat, определяет множество разделителей. Заметьте, в качестве разделителя задан пробел, повторенный сколь угодно много раз, либо пара символов - запятая и пробел. Разделители задаются регулярными выражениями. Метод Split применяется к объекту pat класса Regex. В качестве аргумента методу передается текст, подлежащий расщеплению. Вот как выглядит массив слов после применения метода Split.
В качестве образца используется выражение, объединенное оператором ИЛИ. Ищется либо знак пробела, либо запятая, либо идущие подряд запятая и пробел. Строка, задающая регулярное выражение, передается в качестве параметра конструктору объекта theRegex.
Метод Replace –позволяет делать замену найденного образца. Метод перегружен. При вызове метода передаются 2 строки - первая задает строку, в которой необходимо произвести замену, а вторая - на что нужно заменить найденную подстроку, причем во второй строке можно использовать подстановки (substitutions) - в указанные места будут подставлены значения захваченных групп с заданными именами. Синтаксис подстановок следующий:
$n - Подставляет последнюю подстроку, соответствующую группе с номером n.
Например:
Replace(str, "_$1_") обрамляет все последовательности букв 'a' символами подчеркивания (например, строка "bacghghaaab" превратится в "b_a_cghgh_aaa_b"
Regex r = new Regex(@"(a+)");
string s="bacghghaaab";
s=r.Replace(s,"_$1_");
Console.WriteLine("{0}",s);
Можно задать третий параметр, указывающий сколько замен нужно произвести:
Regex r = new Regex(@"(dotsite)");
string s="dotsitedotsitedotsiterulez";
s=r.Replace(s,"f",1);
Console.WriteLine("{0}",s);
Если параметр не задан, то заменяются все найденные образцы.
Также можно задать четвертый параметр, указывающий с какого вхождения производить замены:
Regex r = new Regex(@"(dotsite)");
string s="dotsitedotsitedotsiterulez";
s=r.Replace(s,"f",2,1);
Console.WriteLine("{0}",s);
Как уже говорилось, объекты этих классов создаются автоматически при вызове методов Match и Matches. Коллекция MatchCollection, как и все коллекции, позволяет получить доступ к каждому ее элементу - объекту Match. Можно, конечно, организовать цикл foreach для последовательного доступа ко всем элементам коллекции.
При работе с объектами класса Match наибольший интерес представляют не столько методы класса, сколько его свойства, большая часть которых унаследована от родительских классов. Рассмотрим основные свойства:
· свойства Index, Length и Value наследованы от прародителя Capture. Они описывают найденную подстроку- индекс начала подстроки в искомой строке, длину подстроки и ее значение;
· свойство Groups класса Match возвращает коллекцию групп - объект GroupCollection, который позволяет работать с группами, созданными в процессе поиска соответствия;
· свойство Captures, наследованное от объекта Group, возвращает коллекцию CaptureCollection. Как видите, при работе с регулярными выражениями реально приходится создавать один объект класса Regex, объекты других классов автоматически появляются в процессе работы с объектами Regex.
using System;
using System.Text;
using System.Text.RegularExpressions;
namespace Regular_Expressions {
class Test {
public static void Main( ) {
string si = "Это строка для поиска";
// найти любой пробельный символ следующий за непробельным
Это пример простейшего регулярного выражения. (\S) означает любой непробельный символ. Знак (+), стоящий после (\S), означает, что может быть любое количество непробельных символов. (\s) в нижнем регистре— пробельный символ. В целом, это выражение означает: «Найти все наборы, которые начинаются с непробельного символа и заканчиваются пробельным».
Коллекция GroupCollection возвращается при вызове свойства Group объекта Match. Имея эту коллекцию, можно добраться до каждого объекта Group, в нее входящего. Класс Group является наследником класса Capture и, одновременно, родителем класса Match. От своего родителя он наследует свойства Index, Length и Value, которые и передает своему потомку.
Давайте рассмотрим чуть более подробно, когда и как создаются группы в процессе поиска соответствия. Если внимательно проанализировать предыдущую таблицу, которая описывает символы, используемые в регулярных выражениях, в частности символы группирования, то можно понять несколько важных фактов, связанных с группами:
· при обнаружении одной подстроки, удовлетворяющей условию поиска, создается не одна группа, а коллекция групп;
· группа с индексом 0 содержит информацию о найденном соответствии;
· число групп в коллекции зависит от числа круглых скобок в записи регулярного выражения. Каждая пара круглых скобок создает дополнительную группу, которая описывает ту часть подстроки, которая соответствует шаблону, заданному в круглых скобках;
· группы могут быть индексированы, но могут быть и именованными, поскольку в круглых скобках разрешается указывать имя группы.
В заключение отмечу, что создание именованных групп крайне полезно при разборе строк, содержащих разнородную информацию.
Класс Regex позволяет объединять регулярные выражения в группы. Это бывает очень полезно, если необходимо выбрать из исходной строки все подстроки, удовлетворяющие определенной категории, и таких категорий несколько. Например, нужно выбрать все подстроки, которые могут являться IP адресами и объединить их вместе. Для этого существует класс Group. Любое регулярное выражение может быть добавлено в группу и представлять свою группу по имени.
Для начала необходимо уяснить, как создавать группу. Например, для того чтобы создать группу, определяющую IP адрес, вы можете создать следующее регулярное выражение:
@ " ( ? < i p > (\d |\ .) + ) \ s "
Имя группы задается в скобках, перед которыми ставится знак (?). Далее следует описание регулярного выражения, определяющего группу. Класс Match явлется производным от класса Group и содержит коллекцию объектов Group, к которым можно обратиться через свойство Groups.
Пример "Атрибуты"
Как уже говорилось, регулярные выражения особенно хороши при разборе сложных текстов. Примерами таковых могут быть различные справочники, различные текстовые базы данных, весьма популярные теперь XML-документы, разбором которых приходится заниматься. В качестве заключительного примера рассмотрим структурированный документ, строки которого содержат некоторые атрибуты, например, телефон, адрес и e-mail. Структуру документа можно задавать по-разному; будем предполагать, что каждый атрибут задается парой "имя: Значение" Наша задача состоит в том, чтобы выделить из строки соответствующие атрибуты. В таких ситуациях регулярное выражениеудобно задавать в виде групп, где каждая группа соответствует одному атрибуту. Приведу начальный фрагмент кода очередной тестирующей процедуры, в котором описываются строки текста и образцы поиска:
public void TestAttributes(){
string s1 = "tel: (831-2) 94-20-55 ";
string s2 = "Адрес: 117926, Москва, 5-й Донской проезд, стр.10,кв.7";
Строки s4 и s5 представляют строку разбираемого документа. Их две, для того чтобы можно было проводить эксперименты, когда атрибуты в документе представлены в произвольном порядке. Каждая из строк pat1, pat2, pat3 задает одну именованную группу в регулярном выражении, имена групп - tel, Адрес, e-mail - даются в соответствии со смыслом атрибутов. Например, шаблон телефона исходит из того, что номеру предшествует код, заключенный в круглые скобки. Поскольку сами скобки играют особую роль, то для задания скобки как символа используется пара - "\(". Это же касается и многих других символов, используемых в шаблонах, - точки, дефиса и т.п. Строка compat представляет составное регулярное выражение, содержащее все три группы. Строки tel, addr и em нам понадобятся для размещения в них результатов разбора. Применим вначале к строкам s4 и s5 каждый из шаблонов pat1, pat2, pat3 в отдельности и выделим соответствующий атрибут из строки. Вот код, выполняющий эти операции:
Regex reg1 = new Regex(pat1);
Match match1= reg1.Match(s4);
Console.WriteLine("Value =" + match1.Value);
// tel: (831-2) 94-20-55
tel=match1.Groups["tel"].Value;
Console.WriteLine(tel); // (831-2) 94-20-55
Regex reg2 = new Regex(pat2);
Match match2= reg2.Match(s5);
Console.WriteLine("Value =" + match2.Value);
// Адрес: 117926, Москва, 5-й Донской проезд, стр.10,кв.7
Все выполняется нужным образом - создаются именованные группы, к ним можно получить доступ и извлечь найденный значения атрибутов. А теперь попробуем решить ту же задачу одним махом, используя составной шаблон compat:
Regex comreg = new Regex(compat);
Match commatch= comreg.Match(s4);
tel= commatch.Groups["tel"].Value;
Console.WriteLine(tel);
addr= commatch.Groups["addr"].Value;
Console.WriteLine(addr);
em= commatch.Groups["em"].Value;
Console.WriteLine(em);
}
Каждый раз, когда объект Regex соответствует одному из выражений, создается экземпляр класса Capture, который добавляется в коллекцию CaptureCollection. Каждый такой объект представляет собой отдельный результат поиска соответствия. У каждой группы есть коллекция таких результатов для своих выражений, связанная с данной группой.
Самым вероятным случаем является наличие одного объекта Capture в коллекции CaptureCollection, но это совсем не обязательно. Рассмотрим, что получится, если в строке, в которой ведется поиск, название компании может встретиться в одной из двух позиций. Чтобы сгруппировать их в одной результирующей строке, нужно создать группу ?<company> в двух местах регулярного выражения:
Группа ?<company> будет выбирать любую строку символов, которая следует за группой time, а также любую строку, следующую за группой ip. Имея такое регулярное выражение, можно смело приступать к поиску в строке. Почему в группе Company только строка Foo? Где первое имя, которое тоже соответствует подвыражению? Объяснение состоит в том, что второе имя «затерло» собой первое. Однако группа нашла оба имени, о чем свидетельствует содержимое коллекции Captures.
company 1: Double
company 2: Foo
Перечисления С#
Перечисление - это частный случай класса. Перечисление задает конечное множество возможных значений, которые могут получать объекты класса перечисление. Поскольку у перечислений нет собственных методов, то синтаксис объявления этого класса упрощается - остается обычный заголовок и тело класса, содержащее список возможных значений. Вот формальное определение синтаксиса перечислений:
[: базовый класс]
{список_возможных_значений}
public enum MyColors {red, blue, yellow, black, white};
public enum TwoColors {black, white};
public enum Rainbow {красный, оранжевый, желтый, зеленый, голубой, синий, фиолетовый};
public enum Sex: byte {man=1, woman};
public enum Days:long {Sun,Mon,Tue,Wed,Thu, Fri, Sat};
Вот несколько моментов, на которые следует обратить внимание при объявлении перечислений:
· как и другие классы, перечисления могут быть объявлены непосредственно в пространстве имен проекта или могут быть вложены в описание класса. Последний вариант часто применяется, когда перечисление используется в одном классе и имеет атрибут доступа private;
· константы разных перечислений могут совпадать, как в перечислениях MyColors и TwoColors. Имя константы всегда уточняется именем перечисления;
· константы могут задаваться словами русского языка, как в перечислении Rainbow;
· разрешается задавать базовый класс перечисления. Для перечисления Days базовым классом задан класс long;
· разрешается задавать не только базовый класс, но и указывать начальный элемент подмножества, на которое проецируется множество значений перечисления. Для перечисления Sex в качестве базового класса выбран класс byte, а подмножество значений начинается с 1, так что хранимым значением константы man является 1, а woman - 2.
Часто бывает удобным создать набор значимых имен, которые будут представлять числовые значения. Представим себе, что вы создаете систему расчета заработной платы для сотрудников. Скорее всего, вам покажется более удобным вместо значений {0, 1, 2, 3} использовать понятные имена VP, Manager, Grunt и Contractor. Конечно же, С#, как и C/C++, предоставляет возможность использовать для этой цели перечисления (enumerations). Создание перечисления для наших целей может выглядеть так:
// Создаем перечисление
еnиm ЕmрТуре {
Manager, // = 0
Grunt, // = 1
Contractor, // = 2
VP // = 3
}
Перечисление EmpType определяет четыре именованные константы, каждой из которых соответствует определенное числовое значение. По умолчанию в перечислениях С# первому элементу соответствует числовое значение 0, второму - n+1, третьему — n+2 и т. д. При необходимости вы легко сможете изменить исходную точку отсчета:
// Начинаем со 102
enum EmpType {
Manager = 102,
Grunt, // = 103
Contractor, // = 104
VP // = 105
}
Для элементов перечисления вовсе не обязательно использовать строго последовательные числовые значения. Например, перечисление можно создать так, как показано ниже, и компилятор совсем не будет против:
// Элементы перечисления могут иметь произвольные числовые значения:
enum EmpType {
Manager = 10,
Grunt = 1,
Contractor = 100,
VP = 99
}
Если посмотреть, что происходит с элементами перечисления при компиляции, то окажется, что компилятор попросту подставляет вместо них соответствующие числовые значения. По умолчанию для этих числовых значений компилятор использует тип данных int. Однако вам ничего не мешает явным образом объявить компилятору, что следует использовать другой тип данных, в нашем примере — byte:
// Вместо элементов перечисления будут подставляться числовые значения типа byte :
enum EmpType : byte {
Manager = 10,
Grunt = 1,
Contractor = 100,
VP = 9
}
Точно таким же образом можно использовать любой из основных целочисленных типов данных С# (byte, sbyte, short, ushort, int, uint, long, ulong).
После того как перечисление вместе с необходимым типом данных определено, вы можете использовать его элементы в программе, например, так, как показано ниже. Обратите внимание на то, что в нашем классе определена статическая функция, принимающая в качестве единственного параметра EmpType:
using System;
enum EmpType : byte {
Manager = 10,
Grunt = 1,
Contractor = 100,
VP = 9
}
class EnumClass {
public static void AskForBonus(EmpType e){
switch(e) {
case EmpType.Contractor:
Console.WriteLine(“You are already get enough cash..."); break;
case EmpType.Grunt:
Console.WriteLine("You havve got to be kidding..."); break;
case EmpType.Manager:
Console.WriteLine(“How about stock options instead?"); break;
