Теория
Регулярният израз (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.c | abc, 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 или 1 | https? | 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").Count | 3 |
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" |
Код за анализ и пренаписване
Основи: търсене, извличане, замяна и разделяне
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]+реже по запетая, точка и запетая или поредица от празни места наведнъж, затовабанан сливас три интервала не дава празни елементи.
Валидиране на имейл, телефон и дата; алчно срещу мързеливо
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`. Защо и как да отхвърлим такава дата?
Речник на термините
Виж пълния речник на курсаRegex от System.Text.RegularExpressions.^\d{4}$. В C# се записва като verbatim низ @"...", за да останат обратните наклонени черти непроменени.Match носи Success, Value, Index и Groups.\d, \w, \s или набор в квадратни скоби като [A-Za-z] и [^0-9].*, +, ?, {n}, {n,}, {n,m}.^ начало на низа, $ край, \b граница на дума.Groups[1] или, при именувана група (?<име>...), чрез Groups["име"].|, който означава „или“: (cat|dog) съвпада с една от двете думи..*) взема възможно най-много символи и отстъпва при нужда; мързеливият (.*?) взема възможно най-малко и разширява при нужда.Провери знанията
Бърз тест с избор от отговори върху термините на модула — с точки и моментална обратна връзка.
Провери знанията си
9 въпроса върху термините от модула. Показваме определение — ти избираш правилния термин.
Препоръки за този модул
- Изграждайте шаблона на части: тествайте
^\d{2}$, после добавете\., после месеца. Всяка стъпка проверявайте сIsMatchвърху два-три валидни и два-три невалидни низа. - Направете си списък с тестови низове за всяко валидиране – правилни, грешни и гранични (празен низ, интервал в началото, една цифра повече). Ако шаблонът ги мине всичките, значи е готов.
- Ползвайте regex101.com с избран вариант „.NET (C#)“: сайтът оцветява съвпаденията и обяснява всеки символ от шаблона, което е най-бързият начин да разберете защо нещо не хваща.
- Щом групите станат повече от две, именувайте ги (
(?<year>...)). Номерата се разместват при всяка редакция на шаблона, аGroups["year"]остава верен и се чете като изречение.