Модул 39

Регулярни изрази

Как да описваме текстови шаблони с регулярни изрази и да ги прилагаме в C# чрез класа `Regex` – търсене, извличане на числа и части от текст, замяна и разделяне. Валидиране на имейл, телефон и дата с котви, групи и именувани групи, плюс разликата между алчно и мързеливо търсене.

Теория

Регулярният израз (regular expression, накратко regex) е шаблон, който описва цяло семейство от низове. Вместо десет if-а с Contains, StartsWith и Length, казваме с един ред: „четири цифри, точка, две цифри“. Същият механизъм стои зад търсенето във всеки редактор, зад проверката на формите в уебсайтовете и зад обработката на логове. В C# регулярните изрази живеят в пространството System.Text.RegularExpressions, а главният герой е класът Regex. Шаблонът е обикновен низ, но го записваме като verbatim низ @"...", защото в него има много обратни наклонени черти – "\d" в обикновен низ е грешка при компилация, а @"\d" е точно каквото искаме.

Най-простият шаблон е буквален текст: Regex.IsMatch(text, "лв") проверява дали лв се среща някъде. Силата идва от специалните символи: точката . означава „кой да е символ“ (без нов ред), а класовете от символи описват един символ от даден вид – \d е цифра, \w е буква, цифра или _, \s е празно място (интервал, табулация, нов ред), а главните им версии \D, \W, \S означават обратното. В квадратни скоби изброяваме сами: [aeiou] е една гласна, [A-Z] е главна латинска буква, [0-9] е същото като \d, а [^0-9] с ^ отпред е „всичко освен цифра“. Когато ни трябва буквална точка, плюс, скоба или въпросителна, ги екранираме с обратна наклонена черта: \., \+, \(, \?.

Квантификаторите казват колко пъти се повтаря предходният елемент: * – нула или повече, + – един или повече, ? – нула или един, {n} – точно n, {n,} – поне n, {n,m} – между n и m. Така \d{4} е година, \d{3,4} е номер с три или четири цифри, а https? съвпада и с http, и с https. По подразбиране квантификаторите са алчни (greedy) – грабват възможно най-много символи и отстъпват само ако иначе няма съвпадение, затова <.*> върху <b>текст</b> хваща целия низ до последната >. Въпросителна след квантификатора го прави мързелив (lazy): <.*?> спира на първата > и хваща само <b>. Още по-ясно и по-бързо е да кажем какво точно не искаме: <[^>]+>.

Котвите не хващат символи, а позиции: ^ е началото на низа, $ – краят, \b – граница на дума. Без тях шаблонът се търси навсякъде вътре в низа и \d{4} ще „намери“ година в abc12345. Групите в кръгли скоби правят две неща: обединяват част от шаблона, за да приложим квантификатор или алтернатива върху нея, и запомнят съвпадналия текст. Групите се номерират по отварящата скоба от 1 (Groups[1]), а по-четливо е да им дадем име – (?<year>\d{4}) после се чете с Groups["year"]; група, която само обединява, без да запомня, се пише (?:...). Вертикалната черта | е алтернация, тоест „или“: (ERROR|WARN|INFO) съвпада с една от трите думи.

Класът Regex предлага пет статични метода, които покриват почти всичко. Regex.IsMatch(text, pattern) връща bool – има ли съвпадение. Regex.Match връща обект Match за първото съвпадение: Success казва дали изобщо има такова, Value е намереният текст, Index – позицията му, а Groups дава достъп до групите. Regex.Matches връща MatchCollection с всички съвпадения, през която минаваме с foreach. Regex.Replace(text, pattern, replacement) заменя всяко съвпадение, като в замяната можем да ползваме $1 или ${year} за запомнените групи, а Regex.Split разделя низа по шаблон – например по „запетая или интервали“. Когато един шаблон се ползва многократно, създаваме обект веднъж – new Regex(pattern, RegexOptions.IgnoreCase) в поле static readonly – и викаме същите методи върху него.

Валидирането на данни е най-честата работа за регулярните изрази: питаме дали целият въведен низ отговаря на формата, затова шаблонът винаги започва с ^ и завършва с $. Имейл: ^[\w.+-]+@[\w-]+(\.[\w-]+)*\.[a-z]{2,}$ – нещо преди @, домейн и разширение от поне две букви. Български мобилен телефон: ^(\+359|0)8[789]\d{7}$. Дата във формат дд.мм.гггг: ^(?<day>\d{2})\.(?<month>\d{2})\.(?<year>\d{4})$. Регулярният израз обаче проверява само формата, не смисъла – 31.02.2026 минава шаблона, макар че такъв ден няма. Затова след съвпадението вадим групите, превръщаме ги с int.Parse и проверяваме обхвата с DateTime.DaysInMonth(year, month) или направо опитваме DateTime.TryParseExact.

Втората голяма употреба е извличането на данни от свободен текст. Regex.Matches(text, @"\d+") намира всички числа в изречение, а \d+(\.\d+)? хваща и десетичните; после ги превръщаме с int.Parse или double.Parse. С именувани групи един ред от лог като 2026-03-15 14:32:07 ERROR Дискът е пълен се разпада на дата, час, ниво и съобщение. Шаблоните се пишат постепенно: първо проверяваме малка част с IsMatch върху няколко валидни и невалидни низа, после добавяме следващата, а сайтове като regex101 (с избран вариант .NET) показват на живо кое с какво съвпада. И едно предупреждение: когато вмъкваме текст от потребителя в шаблон, го минаваме през Regex.Escape, иначе една точка или скоба променя смисъла на целия израз.

Златни правила

Шаблонът е verbatim низ

Пишете всеки шаблон като @"...". Така \d, \w и \. стигат до Regex непроменени, а компилаторът не се оплаква от непознати escape последователности.

Валидираш – закотвяш

При проверка на вход шаблонът започва с ^ и завършва с $. Иначе IsMatch търси съвпадение някъде вътре в низа и приема abc12345 за четирицифрен код.

Първо Success, после Value

Regex.Match връща обект дори когато няма съвпадение – тогава Success е false, а Value е празен низ. int.Parse върху празен низ хвърля изключение, затова винаги проверявайте Success преди да ползвате резултата.

Кажи какво точно искаш

.* грабва всичко до края и после отстъпва. Предпочитайте точен клас ([^>]+, \d+) или мързелив квантификатор (.*?) – шаблонът става и по-верен, и по-бърз.

Форматът не е смисъл

Регулярният израз проверява формата на датата, телефона или имейла, не дали те съществуват. За обхвати и реални стойности използвайте код след съвпадението – DateTime.DaysInMonth, TryParseExact, сравнения.

Бърз справочник

Синтаксис на шаблоните

ЕлементЗначениеПримерСъвпада с
.кой да е символ освен нов редa.cabc, a7c, a-c
\d, \w, \sцифра; буква, цифра или _; празно място\d{3}123, 907
\D, \W, \Sобратното: не-цифра, не-буква, не-празно място\D+абв, -+
[abc], [a-z], [^0-9]един от изброените; диапазон; всичко освен[A-Z][a-z]+Ivan, Sofia
*, +, ?0 или повече; 1 или повече; 0 или 1https?http, https
{n}, {n,}, {n,m}точно n; поне n; между n и m\d{2,4}12, 2026
^, $, \bначало на низа; край на низа; граница на дума^\d+$само 2026, не a2026
( ), (?<име> ), (?: )група; именувана група; група без запомняне(?<year>\d{4})2026 в Groups["year"]
a|b, \., *?алтернатива; буквална точка; мързелив квантификатор(cat|dog)s?cat, dogs

Методи на класа Regex

МетодКакво връщаПримерРезултат
Regex.IsMatch(text, pattern)bool – има ли съвпадениеRegex.IsMatch("2026", @"^\d{4}$")true
Regex.Match(text, pattern)Match – първото съвпадение (Success, Value, Index, Groups)Regex.Match("Цена 15 лв", @"\d+").Value"15"
Regex.Matches(text, pattern)MatchCollection – всички съвпаденияRegex.Matches("1 и 2 и 3", @"\d").Count3
Regex.Replace(text, pattern, replacement)string със заменени съвпадения; $1 и ${име} вмъкват групиRegex.Replace("a1b22c", @"\d+", "#")"a#b#c"
Regex.Split(text, pattern)string[] – частите между съвпадениятаRegex.Split("a, b;c", @"[,;]\s*"){ "a", "b", "c" }
match.Groups[1].Value, match.Groups["име"].Valueтекстът на съответната групаRegex.Match("15.03", @"(\d+)\.(\d+)").Groups[2].Value"03"
new Regex(pattern, RegexOptions.IgnoreCase)обект за многократна употреба, без разлика главни/малкиnew Regex("abc", RegexOptions.IgnoreCase).IsMatch("ABC")true
Regex.Escape(text)низ, в който специалните символи са екранираниRegex.Escape("1+1=2")"1\+1=2"

Код за анализ и пренаписване

Основи: търсене, извличане, замяна и разделяне

Program.cs
using System;
using System.Text.RegularExpressions;

namespace RegexBasics
{
    class Program
    {
        static void Main(string[] args)
        {
            string text = "Поръчка 1042: 3 тетрадки, 12 химикалки и 2 линии. Общо 27.80 лв.";

            // 1. IsMatch – има ли поне една цифра в текста?
            bool hasDigit = Regex.IsMatch(text, @"\d");
            Console.WriteLine($"Има ли цифри: {hasDigit}");

            // 2. Match – първото съвпадение и къде се намира
            Match first = Regex.Match(text, @"\d+");
            if (first.Success)
            {
                Console.WriteLine($"Първо число: {first.Value} (позиция {first.Index})");
            }

            // 3. Matches – всички числа, включително десетичните
            MatchCollection all = Regex.Matches(text, @"\d+(\.\d+)?");
            Console.WriteLine($"Намерени числа: {all.Count}");
            foreach (Match m in all)
            {
                Console.WriteLine($"  {m.Value}");
            }

            // 4. Групи и алтернация – брой + артикул
            int totalItems = 0;
            foreach (Match m in Regex.Matches(text, @"(\d+) (тетрадки|химикалки|линии)"))
            {
                Console.WriteLine($"  {m.Groups[2].Value}: {m.Groups[1].Value} бр.");
                totalItems += int.Parse(m.Groups[1].Value);
            }
            Console.WriteLine($"Общо артикули: {totalItems}");

            // 5. Replace – скриваме всяка цифра
            Console.WriteLine(Regex.Replace(text, @"\d", "#"));

            // 6. Split – разделяне по запетая, точка и запетая или интервали
            string[] parts = Regex.Split("ябълка, круша;банан   слива", @"[,;\s]+");
            Console.WriteLine(string.Join(" | ", parts));
        }
    }
}

Какво се случва тук?

  • using System.Text.RegularExpressions; отваря достъп до класовете Regex, Match и MatchCollection; всички шаблони са verbatim низове @"...", за да не се борим с обратните наклонени черти.
  • Regex.IsMatch(text, @"\d") отговаря само с true/false – има ли поне една цифра; това е най-евтината проверка, когато не ни интересува къде и какво точно е съвпаднало.
  • Regex.Match(text, @"\d+") връща първото съвпадение като обект Match; проверяваме Success, преди да ползваме Value (1042) и Index (позиция 8, защото Поръчка плюс интервалът заемат 8 символа).
  • Regex.Matches с шаблона \d+(\.\d+)? намира и петте числа, включително 27.80: групата (\.\d+)? е незадължителна заради ?, а точката е екранирана, защото иначе означава „кой да е символ“.
  • Шаблонът (\d+) (тетрадки|химикалки|линии) съчетава група за броя и алтернация за артикула; m.Groups[1] е числото, m.Groups[2] – думата, а Groups[0] би бил целият текст на съвпадението.
  • Regex.Replace(text, @"\d", "#") заменя всяка отделна цифра, затова 1042 става #### – ако шаблонът беше \d+, цялото число щеше да стане едно #.
  • Regex.Split с [,;\s]+ реже по запетая, точка и запетая или поредица от празни места наведнъж, затова банан слива с три интервала не дава празни елементи.

Валидиране на имейл, телефон и дата; алчно срещу мързеливо

Program.cs
using System;
using System.Text.RegularExpressions;

namespace RegexValidation
{
    class Program
    {
        // Шаблоните се създават веднъж и се преизползват
        static readonly Regex EmailRegex = new Regex(
            @"^[\w.+-]+@[\w-]+(\.[\w-]+)*\.[a-z]{2,}$", RegexOptions.IgnoreCase);

        static readonly Regex PhoneRegex = new Regex(@"^(\+359|0)8[789]\d{7}$");

        static readonly Regex DateRegex = new Regex(
            @"^(?<day>\d{2})\.(?<month>\d{2})\.(?<year>\d{4})$");

        static void Main(string[] args)
        {
            string[] emails = { "ivan.petrov@abv.bg", "maria@school.edu.bg", "losh@mail", "@abv.bg" };
            foreach (string e in emails)
            {
                string verdict = EmailRegex.IsMatch(e) ? "валиден" : "невалиден";
                Console.WriteLine($"{e,-22} email: {verdict}");
            }

            string[] phones = { "0888123456", "+359888123456", "0888 123 456", "0788123456" };
            foreach (string p in phones)
            {
                string verdict = PhoneRegex.IsMatch(p) ? "валиден" : "невалиден";
                Console.WriteLine($"{p,-22} телефон: {verdict}");
            }

            string[] dates = { "15.03.2026", "5.3.2026", "31.02.2026" };
            foreach (string d in dates)
            {
                Match m = DateRegex.Match(d);
                if (!m.Success)
                {
                    Console.WriteLine($"{d,-22} дата: грешен формат");
                    continue;
                }

                int day = int.Parse(m.Groups["day"].Value);
                int month = int.Parse(m.Groups["month"].Value);
                int year = int.Parse(m.Groups["year"].Value);
                bool exists = year >= 1 && month >= 1 && month <= 12
                    && day >= 1 && day <= DateTime.DaysInMonth(year, month);
                Console.WriteLine($"{d,-22} дата: {(exists ? "валидна" : "несъществуваща")}");
            }

            // Алчно срещу мързеливо търсене
            string html = "<b>Регулярните</b> изрази са <i>мощни</i>.";
            Console.WriteLine(Regex.Match(html, @"<.*>").Value);   // алчно: до последния >
            Console.WriteLine(Regex.Match(html, @"<.*?>").Value);  // мързеливо: до първия >
            Console.WriteLine(Regex.Replace(html, @"<.*?>", ""));  // маха всички тагове
        }
    }
}

Какво се случва тук?

  • Трите шаблона са static readonly Regex полета – създават се веднъж при зареждане на класа, а после IsMatch и Match се викат върху обекта; така не разбираме шаблона наново при всяко извикване.
  • Имейлът ^[\w.+-]+@[\w-]+(\.[\w-]+)*\.[a-z]{2,}$ иска поне един символ преди @, име на домейн, нула или повече поддомейни в групата (\.[\w-]+)* и разширение от поне две букви; RegexOptions.IgnoreCase позволява и .BG.
  • losh@mail пада, защото след домейна няма \. и разширение, а @abv.bg – защото [\w.+-]+ изисква поне един символ преди @.
  • Телефонът ^(\+359|0)8[789]\d{7}$ приема само префикс +359 или 0, после 87, 88 или 89 и още седем цифри; 0888 123 456 е невалиден, защото интервалите не са предвидени, а 0788123456 – защото втората цифра трябва да е 8.
  • Датата използва именувани групи (?<day>...), (?<month>...), (?<year>...); 5.3.2026 пада още на формата (\d{2} иска точно две цифри), а 31.02.2026 минава формата, но DateTime.DaysInMonth(2026, 2) връща 28, затова кодът я обявява за несъществуваща.
  • Условието проверява month преди DaysInMonth, защото && спира при първото false – така никога не викаме метода с месец 13, което би хвърлило изключение.
  • В края <.*> е алчен и хваща от първата < до последната > на реда, докато <.*?> спира на първата >; същият мързелив шаблон в Regex.Replace с празна замяна маха всички тагове и оставя чистия текст.

Внимавай! Чести грешки

Грешките, които почти всеки прави в тази тема — виж разликата между грешния и правилния код.

Валидиране без котви

Грешно

string input = "abc12345xyz";
bool ok = Regex.IsMatch(input, @"\d{4}");
// true – но входът НЕ е четирицифрен код!

Правилно

string input = "abc12345xyz";
bool ok = Regex.IsMatch(input, @"^\d{4}$");
// false – целият низ трябва да е точно 4 цифри

IsMatch търси шаблона някъде в низа, затова \d{4} намира 1234 вътре в abc12345xyz. Котвите ^ и $ заставят съвпадението да обхване целия вход.

Обикновен низ вместо verbatim

Грешно

// Грешка CS1009: Unrecognized escape sequence
bool ok = Regex.IsMatch("2026", "\d{4}");

Правилно

bool ok = Regex.IsMatch("2026", @"\d{4}");
// или с удвоена наклонена черта: "\\d{4}"

В обикновен низ \d не е валидна escape последователност и кодът дори не се компилира, а \b би станало символ backspace без никаква грешка. Verbatim низът @"..." предава всяка обратна наклонена черта непроменена на Regex.

Алчният .* грабва твърде много

Грешно

string html = "<b>текст</b> и <i>още</i>";
string tag = Regex.Match(html, "<.*>").Value;
// "<b>текст</b> и <i>още</i>" – целият ред

Правилно

string html = "<b>текст</b> и <i>още</i>";
string tag = Regex.Match(html, "<.*?>").Value;  // "<b>"
// или още по-точно: "<[^>]+>"

Алчният * взема всичко до края и отстъпва само докато намери последната >. Мързеливият *? спира на първата, а [^>]+ казва направо „всичко освен >“ и изобщо не разчита на отстъпване.

Неекранирана точка в домейна

Грешно

bool ok = Regex.IsMatch("ivan@abvXbg", @"^\w+@abv.bg$");
// true – точката хваща и X

Правилно

bool ok = Regex.IsMatch("ivan@abvXbg", @"^\w+@abv\.bg$");
// false – \. е буквална точка

Точката е метасимвол за „кой да е символ“, затова abv.bg съвпада и с abvXbg, и с abv-bg. Когато искаме истинска точка, пишем \. – същото важи за +, ?, (, [ и |.

Задачи за самостоятелна работа

Опитай първо сам — подсказката е там само ако наистина закъсаш.

Числа в изречение

Прочетете един ред текст от конзолата. Намерете всички цели числа в него с Regex.Matches, изведете колко са и каква е сумата им, а накрая отпечатайте текста без числата (махнете и интервала пред всяко число). Пример: Купих 3 ябълки за 2 лв, 10 банана за 7 лв и 1 диня за 5 лв. дава 6 числа със сума 28.

Валидатор на телефонни номера

Четете редове от конзолата до думата край. За всеки ред проверете дали е български мобилен номер: започва с +359 или 0, следват 87, 88 или 89 и още седем цифри, като между групите може да има един интервал или тире (0888 123 456, 0888-123-456, +359 888 123 456). За валидните изведете валиден -> и номера в единен вид +359XXXXXXXXX (без интервали и тирета), за останалите – невалиден.

Разбор на лог файл

Даден е масив от редове на лог във формат гггг-мм-дд чч:мм:сс НИВО съобщение, където нивото е ERROR, WARN или INFO; някои редове са повредени и не спазват формата. С един регулярен израз с именувани групи date, time, level и message разбийте всеки ред. Пребройте записите по ниво, изведете всички ERROR съобщения във вида дд.мм.гггг чч:мм - съобщение (без секундите) и накрая покажете броя на неразпознатите редове.

Мини-тест за проверка

Отговори си наум (или на глас!) и чак тогава разкрий отговора.

1. Защо `Regex.IsMatch("abc123", @"\d{3}")` връща `true`, след като `abc123` очевидно не е трицифрено число?

2. Какво връща `Regex.Match("<b>x</b> <i>y</i>", "<.*>").Value` и как да получим само `<b>`?

3. Шаблонът `"^\w+@abv.bg$"` е записан като обикновен (не verbatim) низ. Какви два проблема има?

4. Шаблонът `^(?<day>\d{2})\.(?<month>\d{2})\.(?<year>\d{4})$` приема `31.02.2026`. Защо и как да отхвърлим такава дата?

Речник на термините

Виж пълния речник на курса
Регулярен израз (regular expression, regex)
Шаблон, описващ множество от низове чрез обикновени символи и специални метасимволи. В C# се прилага чрез класа Regex от System.Text.RegularExpressions.
Шаблон (pattern)
Самият текст на регулярния израз, например ^\d{4}$. В C# се записва като verbatim низ @"...", за да останат обратните наклонени черти непроменени.
Съвпадение (match)
Част от входния низ, която отговаря на шаблона. Обектът Match носи Success, Value, Index и Groups.
Клас от символи (character class)
Описание на един символ от определен вид: \d, \w, \s или набор в квадратни скоби като [A-Za-z] и [^0-9].
Квантификатор (quantifier)
Указва колко пъти се повтаря предходният елемент: *, +, ?, {n}, {n,}, {n,m}.
Котва (anchor)
Елемент, който съвпада с позиция, а не със символ: ^ начало на низа, $ край, \b граница на дума.
Група (group)
Част от шаблона в кръгли скоби, която се третира като едно цяло и запомня съвпадналия текст. Достъпва се чрез Groups[1] или, при именувана група (?<име>...), чрез Groups["име"].
Алтернация (alternation)
Операторът |, който означава „или“: (cat|dog) съвпада с една от двете думи.
Алчен и мързелив квантификатор (greedy, lazy)
Алчният (.*) взема възможно най-много символи и отстъпва при нужда; мързеливият (.*?) взема възможно най-малко и разширява при нужда.

Провери знанията

Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.

Провери знанията си

9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.

Препоръки за този модул

  • Изграждайте шаблона на части: тествайте ^\d{2}$, после добавете \., после месеца. Всяка стъпка проверявайте с IsMatch върху два-три валидни и два-три невалидни низа.
  • Направете си списък с тестови низове за всяко валидиране – правилни, грешни и гранични (празен низ, интервал в началото, една цифра повече). Ако шаблонът ги мине всичките, значи е готов.
  • Ползвайте regex101.com с избран вариант „.NET (C#)“: сайтът оцветява съвпаденията и обяснява всеки символ от шаблона, което е най-бързият начин да разберете защо нещо не хваща.
  • Щом групите станат повече от две, именувайте ги ((?<year>...)). Номерата се разместват при всяка редакция на шаблона, а Groups["year"] остава верен и се чете като изречение.

Учебен наръчник — теория, примери, задачи и тестове по предметите от учебния план.

Натисни Ctrl K или / отвсякъде, за да търсиш.