В этой статье
Регулярное выражение – это шаблон, который обработчик регулярных выражений пытается сопоставить с введенным текстом.A regular expression is a pattern that the regular expression engine attempts to match in input text. Шаблон состоит из односимвольных или многосимвольных литералов, операторов или конструкций.A pattern consists of one or more character literals, operators, or constructs. См. краткое описание регулярных выражений .NET.For a brief introduction, see .NET Regular Expressions.
В каждом разделе этого краткого справочника приводится перечень конкретной категории символов, операторов и конструкций, которые можно использовать для задания регулярных выражений.Each section in this quick reference lists a particular category of characters, operators, and constructs that you can use to define regular expressions.
Мы также представили эту информацию в двух форматах, чтобы вы могли ее скачать и распечатать для справки:We’ve also provided this information in two formats that you can download and print for easy reference:
Escape-знакиCharacter Escapes Обратная косая черта (\) в регулярных выражениях указывает, что следующий за ней символ либо является специальным знаком (как показано в следующей таблице), либо должен интерпретироваться буквально.The backslash character (\) in a regular expression indicates that the character that follows it either is a special character (as shown in the following table), or should be interpreted literally. Дополнительные сведения см. в разделе Escape-символы.For more information, see Character Escapes.
Escape-символEscaped character
ОписаниеDescription
ШаблонPattern
Число соответствийMatches
\aСоответствует знаку колокольчика, \u0007.Matches a bell character, \u0007.
\a"\u0007" в "Error!" + '\u0007'"\u0007" in "Error!" + '\u0007'
\bВ классе символов соответствует знаку BACKSPACE, \u0008.In a character class, matches a backspace, \u0008.
[\b]{3,}"\b\b\b\b" в "\b\b\b\b""\b\b\b\b" in "\b\b\b\b"
\tСоответствует знаку табуляции, \u0009.Matches a tab, \u0009.
(\w+)\t"item1\t", "item2\t" в "item1\titem2\t""item1\t", "item2\t" in "item1\titem2\t"
\rСоответствует знаку возврата каретки, \u000D.Matches a carriage return, \u000D. (\r не эквивалентен знаку начала новой строки, \n.)(\r is not equivalent to the newline character, \n.
\r\n(\w+)"\r\nThese" в "\r\nThese are\ntwo lines.""\r\nThese" in "\r\nThese are\ntwo lines."
\vСоответствует знаку вертикальной табуляции, \u000B.Matches a vertical tab, \u000B.
[\v]{2,}"\v\v\v" в "\v\v\v""\v\v\v" in "\v\v\v"
\fСоответствует знаку перевода страницы, \u000C.Matches a form feed, \u000C.
[\f]{2,}"\f\f\f" в "\f\f\f""\f\f\f" in "\f\f\f"
\nСоответствует знаку новой строки, \u000A.Matches a new line, \u000A.
\r\n(\w+)"\r\nThese" в "\r\nThese are\ntwo lines.""\r\nThese" in "\r\nThese are\ntwo lines."
\eСоответствует escape-знаку, \u001B.
\e"\x001B" в "\x001B""\x001B" in "\x001B"
\ nnn \ nnn Использует восьмеричное представление для указания символа ( nnn состоит из двух или трех цифр).Uses octal representation to specify a character ( nnn consists of two or three digits).
\w\040\w"a b", "c d" в "a bc d""a b", "c d" in "a bc d"
\x nn \x nn Использует шестнадцатеричное представление для указания символа ( nn состоит ровно из двух цифр).Uses hexadecimal representation to specify a character ( nn consists of exactly two digits).
\w\x20\w"a b", "c d" в "a bc d""a b", "c d" in "a bc d"
\c X \c X
\c x \c x
Соответствует управляющему символу ASCII, который задан как X или x , где X или x является буквой управляющего символа.X or x , where X or x is the letter of the control character.
\cC"\x0003" в "\x0003" (Ctrl-C)"\x0003" in "\x0003" (Ctrl-C)
\u nnnn \u nnnn Совпадение со знаком Юникода в шестнадцатеричном представлении (строго четыре цифры, представленные как nnnn ).Matches a Unicode character by using hexadecimal representation (exactly four digits, as represented by nnnn ).
\w\u0020\w"a b", "c d" в "a bc d""a b", "c d" in "a bc d"
\Если за этим знаком следует символ, не распознанный как escape-символ из этой и других таблиц данной темы, то соответствует в точности этому символу.When followed by a character that is not recognized as an escaped character in this and other tables in this topic, matches that character.\* — это то же самое, что и \x2A, а \. — то же самое, что и \x2E.For example, \* is the same as \x2A, and \. is the same as \x2E. Это позволяет обработчику регулярных выражений распознавать языковые элементы (такие как *или ?) и символьные литералы (представленные как \* или \?).This allows the regular expression engine to disambiguate language elements (such as * or ?) and character literals (represented by \* or \?).
\d+[\+-x\*]\d+"2+2" и "3*9" в "(2+2) * 3*9""2+2" and "3*9" in "(2+2) * 3*9"
Классы символовCharacter Classes Класс символов соответствует какому-либо одному набору символов.A character class matches any one of a set of characters. Классы символов состоят из языковых элементов, приведенных в следующей таблице.aei]
"r", "g", "n" в "reign""r", "g", "n" in "reign"
[ first - last ][ first - last ]Диапазон символов: соответствует одному символу в диапазоне от первого до последнего .Character range: Matches any single character in the range from first to last .
[A-Z]"A", "B" в "AB123""A", "B" in "AB123"
.Подстановочный знак: соответствует любому одиночному символу, кроме \n.Wildcard: Matches any single character except \n.
Для сопоставления символа точки (.To match a literal period character (. или \u002E) перед ней нужно поставить дополнительную обратную косую черту (\.).or \u002E), you must precede it with the escape character (\.).
a.e"ave" в "nave""ave" in "nave"
"ate" в "water""ate" in "water"
\p{ имя }\p{ name }Соответствует любому одиночному символу в общей категории Юникода или в именованном блоке, указанном в параметре имя .Matches any single character in the Unicode general category or named block specified by name .
\p{Lu}
\p{IsCyrillic}
"C", "L" в "City Lights""C", "L" in "City Lights"
"Д", "Ж" в "ДЖem""Д", "Ж" in "ДЖem"
\P{ имя }\P{ name }Соответствует любому одиночному символу, не входящему в общую категорию Юникода или в именованный блок, указанный в параметре имя .Matches any single character that is not in the Unicode general category or named block specified by name .
\P{Lu}
\P{IsCyrillic}
"i", "t", "y" в "City""i", "t", "y" in "City"
"e", "m" в "ДЖem""e", "m" in "ДЖem"
\wСоответствует любому алфавитно-цифровому знаку.Matches any word character.
\w"I", "D", "A", "1", "3" в "ID A1.3""I", "D", "A", "1", "3" in "ID A1.3"
\WСоответствует любому символу, который не является буквенно-цифровым знаком.Matches any non-word character.
\W" ", "." в "ID A1.3"" ", "." in "ID A1.3"
\sСоответствует любому знаку пробела.Matches any white-space character.
\w\s"D " в "ID A1.3""D " in "ID A1.3"
\SСоответствует любому знаку, не являющемуся пробелом.Matches any non-white-space character.
\s\S" _" в "int __ctr"" _" in "int __ctr"
\dСоответствует любой десятичной цифре.Matches any decimal digit.
\d"4" в "4 = IV""4" in "4 = IV"
\DСоответствует любому символу, не являющемуся десятичной цифрой.Matches any character other than a decimal digit.
\D" ", "=", " ", "I", "V" в "4 = IV"" ", "=", " ", "I", "V" in "4 = IV"
ПривязкиAnchors Привязки, или атомарные утверждения нулевой ширины, приводят к успеху или сбою сопоставления, в зависимости от текущей позиции в строке, но не предписывают обработчику перемещаться по строке или обрабатывать символы.\d{3}
"901" в "901-333-""901" in "901-333-"
$По умолчанию соответствие должно обнаруживаться в конце строки или перед символом \n в конце строки. В многострочном режиме соответствие должно обнаруживаться до конца линии или перед символом \n в конце линии.By default, the match must occur at the end of the string or before \n at the end of the string; in multiline mode, it must occur before the end of the line or before \n at the end of the line.
-\d{3}$"-333" в "-901-333""-333" in "-901-333"
\AСоответствие должно обнаруживаться в начале строки.The match must occur at the start of the string.
\A\d{3}"901" в "901-333-""901" in "901-333-"
\ZСоответствие должно обнаруживаться в конце строки или до символа \n в конце строки.The match must occur at the end of the string or before \n at the end of the string.
-\d{3}\Z"-333" в "-901-333""-333" in "-901-333"
\zСоответствие должно обнаруживаться в конце строки.The match must occur at the end of the string.
-\d{3}\z"-333" в "-901-333""-333" in "-901-333"
\GСоответствие должно обнаруживаться в той точке, где заканчивается предыдущее соответствие.The match must occur at the point where the previous match ended.
\G\(\d\)"(1)", "(3)", "(5)" в "(1)(3)(5)[7](9)""(1)", "(3)", "(5)" in "(1)(3)(5)[7](9)"
\bСоответствие должно обнаруживаться на границе между символом \w (алфавитно-цифровым) и символом \W (не алфавитно-цифровым).The match must occur on a boundary between a \w (alphanumeric) and a \W (nonalphanumeric) character.
\b\w+\s\w+\b"them theme", "them them" в "them theme them them""them theme", "them them" in "them theme them them"
\BСоответствие не должно обнаруживаться на границе \b.The match must not occur on a \b boundary.
\Bend\w*\b"ends", "ender" в "end sends endure lender""ends", "ender" in "end sends endure lender"
Конструкции группированияGrouping Constructs Конструкции группирования отображают части выражений регулярных выражений и обычно захватывают части строки входной строки.Grouping constructs delineate subexpressions of a regular expression and typically capture substrings of an input string. Конструкции группирования состоят из языковых элементов, приведенных в следующей таблице.Grouping constructs include the language elements listed in the following table. Для получения дополнительной информации см. Конструкции группирования.For more information, see Grouping Constructs.
Конструкция группированияGrouping construct
ОписаниеDescription
ШаблонPattern
Число соответствийMatches
( subexpression )( subexpression )Захватывает соответствующую часть выражения и назначает ей порядковый номер, отсчитываемый от единицы.Captures the matched subexpression and assigns it a one-based ordinal number.
(\w)\1"ee" в "deep""ee" in "deep"
(?< name > subexpression )(?< name > subexpression )(?' name ' subexpression )(?' name ' subexpression )Выделяет соответствующую часть выражения в именованную группу.Captures the matched subexpression into a named group.
(?<double>\w)\k<double>"ee" в "deep""ee" in "deep"
(?< name1 - name2 > subexpression )(?< name1 - name2 > subexpression ) (?' name1 - name2 ' subexpression )(?' name1 - name2 ' subexpression )Задает сбалансированное определение группы.Defines a balancing group definition. Дополнительные сведения см. в разделе «Сбалансированное определение группы» статьи Конструкции группирования.For more information, see the «Balancing Group Definition» section in Grouping Constructs.
(((?'Open'\()[^\(\)]*)+((?'Close-Open'\))[^\(\)]*)+)*(?(Open)(?!))$"((1-3)*(3-1))" в "3+2^((1-3)*(3-1))""((1-3)*(3-1))" in "3+2^((1-3)*(3-1))"
(?: subexpression )(?: subexpression )Определяет невыделяемую группу.Defines a noncapturing group.
Write(?:Line)?"WriteLine" в "Console.WriteLine()""WriteLine" in "Console.WriteLine()"
"Write" в "Console.Write(value)""Write" in "Console.Write(value)"
(?imnsx-imnsx: subexpression )(?imnsx-imnsx: subexpression )Применяет или отключает указанные параметры в части выражения .Applies or disables the specified options within subexpression . Для получения дополнительной информации см. Параметры регулярных выражений.For more information, see Regular Expression Options.
A\d{2}(?i:\w+)\b"A12xl", "A12XL" в "A12xl A12XL a12xl""A12xl", "A12XL" in "A12xl A12XL a12xl"
(?= subexpression )(?= subexpression )Утверждение положительного просмотра вперед нулевой ширины.Zero-width positive lookahead assertion.
\w+(?=\.)"is", "ran" и "out" в "He is. The dog ran. The sun is out.""is", "ran", and "out" in "He is. The dog ran. The sun is out."
(?! subexpression )(?! subexpression )Утверждение отрицательного просмотра вперед нулевой ширины.Zero-width negative lookahead assertion.
\b(?!un)\w+\b"sure", "used" в "unsure sure unity used""sure", "used" in "unsure sure unity used"
(?<= subexpression )(?<= subexpression )Утверждение положительного просмотра назад нулевой ширины.Zero-width positive lookbehind assertion.
(?<=19)\d{2}\b"99", "50", "05" в "1851 1999 1950 1905 2003""99", "50", "05" in "1851 1999 1950 1905 2003"
(?<! subexpression )(?<! subexpression )Утверждение отрицательного просмотра назад нулевой ширины.Zero-width negative lookbehind assertion.
(?<!19)\d{2}\b"51", "03" в "1851 1999 1950 1905 2003""51", "03" in "1851 1999 1950 1905 2003"
(?> subexpression )(?> subexpression )Атомарная группа.Atomic group.
[13579](?>A+B+)"1ABB", "3ABB" и "5AB" в "1ABB 3ABBC 5AB 5AC""1ABB", "3ABB", and "5AB" in "1ABB 3ABBC 5AB 5AC"
КвантификаторыQuantifiers Квантор указывает количество вхождений предшествующего элемента (знака, группы или класса знаков), которое должно присутствовать во входной строке, чтобы было зафиксировано соответствие.A quantifier specifies how many instances of the previous element (which can be a character, a group, or a character class) must be present in the input string for a match to occur. Кванторы состоят из языковых элементов, приведенных в следующей таблице.Quantifiers include the language elements listed in the following table. Для получения дополнительной информации см. Квантификаторы.For more information, see Quantifiers.
КвантификаторQuantifier
ОписаниеDescription
ШаблонPattern
Число соответствийMatches
*Соответствует предыдущему элементу ноль или более раз.Matches the previous element zero or more times.
\d*\.\d".0", "19.9", "219.9"".0", "19.9", "219.9"
+Соответствует предыдущему элементу один или более раз.Matches the previous element one or more times.
"be+""bee" в "been", "be" в "bent""bee" in "been", "be" in "bent"
?Соответствует предыдущему элементу ноль или один раз.Matches the previous element zero or one time.
"rai?n""ran", "rain""ran", "rain"
{ n }
JavaScript | Регулярные выражения
Мы запустили ТГ-канал по урокам C#
Toggle navigation
Professor Web
C# 5.0 и .NET 4.5
Руководство C# — Часть 1
Руководство C# — Часть 2
Основы .NET
Сборки .NET
Потоки и файлы
Работа с сетью
Оптимизация приложений
WPF
Основа WPF
Элементы управления WPF
Привязка и стили
Графика и анимация
Шаблоны WPF
Периферия WPF
Темы WPF
Dark Blue UI
Dark Orange UI
Silverlight 5
Работа с БД
ADO.NET
Entity Framework 6
SQL Server 2012
Оконные функции
LINQ
LINQ to Objects
LINQ to XML
LINQ to DataSet и SQL
LINQ to Entities
Parallel LINQ
ASP.NET
Основы ASP.NET
Веб-сайты
Безопасность
Интернет магазин
ASP.NET Web Forms 4.5
ASP.NET MVC 5
Аутентификация
Регулярные выражения — Википедия Шпаргалка по регулярным выражениям Квантификаторы
Аналог
Пример
Описание
?
{0,1}
a?
одно или ноль вхождений «а»
+
{1,}
a+
одно или более вхождений «а»
*
{0,}
a*
ноль или более вхождений «а»
Модификаторы Символ «минус» (-) меред модификатором (за исключением U) создаёт его отрицание.
Описание
g
глобальный поиск (обрабатываются все совпадения с шаблоном поиска)
i
игнорировать регистр
m
многострочный поиск. Поясню: по умолчанию текст это одна строка, с модификатором есть отдельные строки, а значит — начало строки в тексте, — конец строки в тексте.
s
текст воспринимается как одна строка, спец символ «точка» (.) будет вкючать и перевод строки
u
используется кодировка UTF-8
U
инвертировать жадность
x
игнорировать все неэкранированные пробельные и перечисленные в классе символы
Спецсимволы
Аналог
Описание
()
подмаска, вложенное выражение
[]
групповой символ
{a,b}
количество вхождений от «a» до «b»
|
логическое «или», в случае с односимвольными альтернативами используйте []
\
экранирование спец символа
.a
a aa aaaначало строки
$
a$
aaa aaa
конец строки
\A
\Aa
a aa aaaначало текста
\z
a\z
aaa aaaa
конец текста
\b
a\b
aaa aaa a aa a aa
граница слова, утверждение: предыдущий символ словесный, а следующий — нет, либо наоборот
\B
\Ba\B
aa a aa a
отсутствие границы слова
\G
\Ga
aaa aaaПредыдущий успешный поиск, поиск остановился на 4-й позиции — там, где не нашлось a
Скачать в PDF, PNG.
Якоря Якоря в регулярных выражениях указывают на начало или конец чего-либо.
Например, строки или слова. Они представлены определенными символами. К примеру, шаблон, соответствующий строке, начинающейся с цифры, должен иметь следующий вид:
Здесь символ обозначает начало строки. Без него шаблон соответствовал бы любой строке, содержащей цифру.
Символьные классы Символьные классы в регулярных выражениях соответствуют сразу некоторому набору символов. Например, соответствует любой цифре от 0 до 9 включительно, соответствует буквам и цифрам, а— всем символам, кроме букв и цифр. Шаблон, идентифицирующий буквы, цифры и пробел, выглядиттак:
POSIX POSIX — это относительно новое дополнение семейства регулярных выражений. Идея, как и в случае с символьнымиклассами, заключается в использовании сокращений, представляющих некоторую группу символов.
Утверждения Поначалу практически у всех возникают трудности с пониманием утверждений, однако познакомившись с ними ближе, выбудете использовать их довольно часто. Утверждения предоставляют способ сказать: «я хочу найти в этом документекаждое слово, включающее букву “q”, за которой не следует “werty”».
Приведенный выше код начинается с поиска любых символов, кроме пробела (), за которыми следует. Затем парсер достигает «смотрящего вперед» утверждения. Это автоматически делает предшествующийэлемент (символ, группу или символьный класс) условным — он будет соответствовать шаблону, только еслиутверждение верно. В нашем случае, утверждение является отрицательным (), т. е. оно будет верным,если то, что в нем ищется, не будет найдено.
Итак, парсер проверяет несколько следующих символов по предложенному шаблону (). Если они найдены,то утверждение ложно, а значит символ будет «проигнорирован», т. е. не будет соответствовать шаблону.Если же не найдено, то утверждение верно, и с все в порядке. Затем продолжаетсяпоиск любых символов, кроме пробела ().
Кванторы Кванторы позволяют определить часть шаблона, которая должна повторяться несколько раз подряд. Например, если выхотите выяснить, содержит ли документ строку из от 10 до 20 (включительно) букв «a», то можно использовать этотшаблон:
По умолчанию кванторы — «жадные». Поэтому квантор , означающий «один или больше раз», будетсоответствовать максимально возможному значению. Иногда это вызывает проблемы, и тогда вы можете сказать кванторуперестать быть жадным (стать «ленивым»), используя специальный модификатор. Посмотрите на этот код:
Этот шаблон соответствует тексту, заключенному в двойные кавычки. Однако, ваша исходная строка может быть вродеэтой:
Приведенный выше шаблон найдет в этой строке вот такую подстроку:
Он оказался слишком жадным, захватив наибольший кусок текста, который смог.
Этот шаблон также соответствует любым символам, заключенным в двойные кавычки. Но ленивая версия (обратите вниманиена модификатор ) ищет наименьшее из возможных вхождений, и поэтому найдет каждую подстроку в двойныхкавычках по отдельности:
Экранирование в регулярных выражениях Регулярные выражения используют некоторые символы для обозначения различных частей шаблона. Однако, возникаетпроблема, если вам нужно найти один из таких символов в строке, как обычный символ. Точка, к примеру, в регулярномвыражении обозначает «любой символ, кроме переноса строки». Если вам нужно найти точку в строке, вы не можете простоиспользовать «» в качестве шаблона — это приведет к нахождению практически всего. Итак, вамнеобходимо сообщить парсеру, что эта точка должна считаться обычной точкой, а не «любым символом». Это делается спомощью знака экранирования.
Знак экранирования, предшествующий символу вроде точки, заставляет парсер игнорировать его функцию и считать обычнымсимволом. Есть несколько символов, требующих такого экранирования в большинстве шаблонов и языков. Вы можете найтиих в правом нижнем углу шпаргалки («Мета-символы»).
Шаблон для нахождения точки таков:
Другие специальные символы в регулярных выражениях соответствуют необычным элементам в тексте. Переносы строки итабуляции, к примеру, могут быть набраны с клавиатуры, но вероятно собьют с толку языки программирования. Знакэкранирования используется здесь для того, чтобы сообщить парсеру о необходимости считать следующий символспециальным, а не обычной буквой или цифрой.
Спецсимволы экранирования в регулярных выражениях
Выражение
Соответствие
\
не соответствует ничему, только экранирует следующий за ним символ.
Это нужно, если вы хотите ввести метасимволы в качестве их буквальных значений.
\Q
не соответствует ничему, только экранирует все символы вплоть до
\E
не соответствует ничему, только прекращает экранирование, начатое
Подстановка строк Подстановка строк подробно описана в следующем параграфе «Группы и диапазоны», однако здесь следует упомянуть осуществовании «пассивных» групп. Это группы, игнорируемые при подстановке, что очень полезно, если вы хотитеиспользовать в шаблоне условие «или», но не хотите, чтобы эта группа принимала участие в подстановке.
Группы и диапазоны Группы и диапазоны очень-очень полезны. Вероятно, проще будет начать с диапазонов. Они позволяют указать наборподходящих символов. Например, чтобы проверить, содержит ли строка шестнадцатеричные цифры (от 0 до 9 и от A до F),следует использовать такой диапазон:
Чтобы проверить обратное, используйте отрицательный диапазон, который в нашем случае подходит под любой символ, кромецифр от 0 до 9 и букв от A до F:
Группы наиболее часто применяются, когда в шаблоне необходимо условие «или»; когда нужно сослаться на часть шаблонаиз другой его части; а также при подстановке строк.
Использовать «или» очень просто: следующий шаблон ищет «ab» или «bc»:
Если в регулярном выражении необходимо сослаться на какую-то из предшествующих групп, следует использовать, где вместо подставить номер нужной группы. Вам может понадобиться шаблон,соответствующий буквам «aaa» или «bbb», за которыми следует число, а затем те же три буквы. Такой шаблон реализуетсяс помощью групп:
Первая часть шаблона ищет «aaa» или «bbb», объединяя найденные буквы в группу. За этим следует поиск одной или болеецифр (), и наконец . Последняя часть шаблона ссылается на первую группу и ищет тоже самое. Она ищет совпадение с текстом, уже найденным первой частью шаблона, а не соответствующее ему. Такимобразом, «aaa123bbb» не будет удовлетворять вышеприведенному шаблону, так как будет искать «aaa»после числа.
Одним из наиболее полезных инструментов в регулярных выражениях является подстановка строк. При замене текста можносослаться на найденную группу, используя . Скажем, вы хотите выделить в тексте все слова «wish»жирным начертанием. Для этого вам следует использовать функцию замены по регулярному выражению, которая можетвыглядеть так:
Первым параметром будет примерно такой шаблон (возможно вам понадобятся несколько дополнительных символов для этойконкретной функции):
Он найдет любые вхождения слова «wish» вместе с предыдущим и следующим символами, если только это не буквы или цифры.Тогда ваша подстановка может быть такой:
Ею будет заменена вся найденная по шаблону строка. Мы начинаем замену с первого найденного символа (который не букваи не цифра), отмечая его . Без этого мы бы просто удалили этот символ из текста. То же касается концаподстановки (). В середину мы добавили HTML тег для жирного начертания (разумеется, вместо него выможете использовать CSS или ), выделив им вторую группу, найденную по шаблону().
Модификаторы шаблонов Модификаторы шаблонов используются в нескольких языках, в частности, в Perl. Они позволяют изменить работу парсера.Например, модификатор заставляет парсер игнорировать регистры.
Регулярные выражения в Perl обрамляются одним и тем же символом в начале и в конце. Это может быть любой символ (чащеиспользуется «/»), и выглядит все таким образом:
Модификаторы добавляются в конец этой строки, вот так:
Мета-символы Наконец, последняя часть таблицы содержит мета-символы. Это символы, имеющие специальное значение в регулярныхвыражениях. Так что если вы хотите использовать один из них как обычный символ, то его необходимо экранировать. Дляпроверки наличия скобки в тексте, используется такой шаблон:
Шпаргалка представляет собой общее руководство по шаблонам регулярных выражений без учета специфики какого-либо языка.Она представлена в виде таблицы, помещающейся на одном печатном листе формата A4.Создана под лицензией Creative Commons на базе шпаргалки, автором которой является Dave Child.Скачать в PDF, PNG.
Регулярные выражения
DC — Синтаксис регулярных выражений Double Commander использует свободную Delphi-библиотеку TRegExpr Андрея В. Сорокина: https://regex.sorokin.engineer/ru/latest/. Большинство из приведённых далее объяснений и примеров позаимствовано из справочного файла к этой библиотеке.
Регулярные выражения — это широко используемый способ описания шаблонов для поиска текста и проверки соответствия текста шаблону.
Специальные метасимволы позволяют определять, например, что мы ищем подстроку в начале входной строки или n повторений определённого символа.
Регулярные выражения предназначены главным образом для профессионалов, однако могут быть полезны и при работе в офисе для поиска определённых документов (см. примеры ниже).
Double Commander поддерживает регулярные выражения в следующих функциях:
(наверх)
Любой символ совпадает с самим собой, если он не относится к специальным метасимволам, описанным чуть ниже.
Последовательность символов совпадает с такой же последовательностью во входной строке, так что шаблон «bluh» совпадет с подстрокой «bluh» во входной строке.FooBarPtr»
(наверх)
Любой символ может быть определён с помощью escape-последовательности так же, как это делается в языках C или Perl: «\n» означает начало строки, «\t» — табуляцию и т.д.
\xnn, где nn — это последовательность шестнадцатеричных цифр, означает символ с ASCII-кодом nn.
Если необходимо определить двухбайтный (Юникод) символ, используем формат «\x{nnnn}», где «nnnn» — одна или более шестнадцатеричных цифр.
Escape-последовательности
Выражение
Результат
\xnn
символ с шестнадцатеричным кодом nn
\x{nnnn}
символ с шестнадцатеричным кодом nnnn (один байт для обычного текста и два для Юникода)
Biu thức chính quy — Công nghệ lập trình Web
\
Tìm với luật dưới đây:
Một dấu gạch chéo ngược sẽ biến một kí tự thường liền kế phía sau thành một kí t c biệt, tứm thm Ví d, trường hợp kí tự ‘ b ‘ không có dấu gạch chéo ngược này sẽ được khớp với các kí tự ‘b’ in thường, nhưng khi nó có thêm dấu gc chéo 9000, nhc chéo sẽ không khớp với bất kì kí tự nào nữa, lúc này nó trở thành kí tự đặc biệt.Xem thêm phần символ границы слова để biết thêm chi tiết.
Tuy nhiên nếu ng trước một kí tự đặc biệt thì nó sẽ biến kí tự này thành một kí tự thường, tức là bạn có thể tìm kiếm kí tự c trong k Ví dụ, mẫu / a * / có ‘*’ là kí tự c biệt và mẫu này sẽ bị phụ thuộc vào kí tự này, nên được hiểu là sẽ tìm khớp với 0 hoặc tựhiều. Nhng, với mẫu / a \ * / thì kí tự ‘ * ‘ lúc này được hiểu là kí tự thường nên mẫu này sẽ tìm kiếm xâu con là ‘a *’.’sẽ thay đổi khi nó xuất hiện như một kí tự đầu tiên trong một lớp kí tự, xem phần дополняет наборы символов để biết thêm chi tiết.
$
Со khớp ở cuối chuỗi. Nếu gắn cờ многострочный (đa dòng), nó sẽ khớp ngay trước kí tự xuống dòng.
Ví d, / t $ / không khp với ‘t’ trong chuỗi «пожиратель» nhưng li khớp trong chuỗi «есть».
*
Cho phép kí tự trước nó lặp lại 0 lần hoặc nhiều lần.Tương đương với cách viết {0,}.
Ví dụ, / bo * / khớp với ‘boooo’ trong chui «Призрак освистал» nhưng không khp trong chui «Рождение трели».
+
Cho phép kí tự trước nó lặp lại 1 lần hoặc nhiều lần. Tương đương với cách viết {1,}.
Ví dụ, / a + / khớp với ‘a’ trong chui «конфета» và khớp với tất cả kí tự a liền nhau trong chuỗi «caaaaaaandy».
?
Cho phép kí tự trước nó lặp lại 0 ln hoặc 1 lần duy nhất.Tương đương với cách viết {0,1}.
Ví dụ, / e? Le? / Khớp với ‘el’ trong chuỗi «ангел» và ‘le’ trong chuỗi «угол» hay ‘l’ trong «осло».
Nếu sử dụng kí tự này ngay sau bất kì kí tự định lng nào trong số *, + ,? хай {}, đều làm bộ định lượng «чан ан» (dừng so khớp sau ngay khi tìm được kí tự phù hợp), trái ngược với đức tính «tham lam» vốn sẵìn th k ). Ví d, áp dụng biểu mẫu / \ d + / cho «123abc» ta c «123». Nhưng áp / \ d +? / Cho chính chuỗi trên ta chỉ nhận được kết quả là «1».
Bạn có thể đọc thêm trong mục x (? = Y) và x (?! Y) của bảng này.
.
Dấu. khớp với bất kì kí tự đơn nào ngoại trừ kí tự xuống dòng.
Ví dụ, /.n/ khớp với ‘an’ và ‘on’ trong chuỗi «нет, яблоко на дереве», nhưng không khớp với ‘но’.
(х)
Khớp ‘x’ và nhớ kết quả so khớp này, như ví dụ ở dưới. Các dấu ngoặc tròn được gọi là các dấu ngoc có nhớ.
Biểu mẫu / (foo) (bar) \ 1 \ 2 / khớp với 'foo' và 'bar' trong chuỗi «foo bar foo bar». \ 1 và \ 2 trong mẫu khớp với 2 từ cuối.
Chú ý rằng \ 1 , \ 2 , \ n được sử dụng để so khớp các phần trong regex, nó đại diện cho nhóm so khớp đằng trước. Ví dụ: / (foo) (bar) \ 1 \ 2 / tương đương với biểu thức / (foo) (bar) foo bar /.
Cú pháp $ 1, $ 2, $ n còn được sử dụng trong việc thay thế các phần của một regex.Ví dụ: 'bar foo'.replace (/ (...) (...) /,' $ 2 $ 1 ') sẽ đảo vị trí 2 từ’ bar ‘và’ foo ‘cho nhau.
(?: X)
Khớp ‘x’ nhưng không nhớ kết quả so khp. Nhng dặu ngoặc tròn c gọi là những du ngoặc không nhớ, nó cho phép bạn định nghĩa những biểu thức con cho những toán tử so khớp. Xem xét biểu thức đơn giản / (?: foo) {1,2} /. Nếu biểu thức này được viết là / foo {1,2} / , {1,2} sẽ chỉ áp dụng cho kí tự ‘o’ ở cuối chuỗi ‘foo’.Với những dấu ngoặc không nhớ, {1,2} sẽ áp dụng cho cả cụm ‘foo’.
x (? = Y)
Chỉ khớp ‘x’ nếu ‘x’ theo sau bởi ‘y’.
Ví dụ, / Jack (? = Sprat) / chỉ khớp với ‘Jack’ nếu đằng sau nó là ‘Sprat’. / Jack (? = Sprat | Frost) / chỉ khớp ‘Джек’ nếu theo sau nó là ‘Sprat’ hoặc ‘Frost’. Tuy nhiên, cả ‘Sprat’ và ‘Frost’ đều không phải là một phần của kết quả so khớp trả về.
х (?! Y)
Chỉ khớp ‘x’ nếu ‘x’ không được theo sau bởi ‘y’.
Ví dụ: /\d+(?!\.)/ chỉ khớp với số không có dấu . đằng sau. Biểu thức /\d+(?!\.)/.exec("3.141 ") cho kết quả là ‘141’ mà không phải ‘3.141’.
х | у
Khp ‘x’ hoặc ‘y’
Ví dụ, / зеленый | красный / khớp với ‘зеленый’ trong chuỗi «зеленое яблоко» và ‘red’ trong chuỗi «красное яблоко».
{n}
Kí tự đứng trước phải xuất hiện n lần. n phải là một số nguyên dương.
Ví d, / a {2} / không khp với ‘a’ trong «конфета», nhưng nó khớp với tất cả kí tự ‘a’ a ‘trong «caandy», và khớp với 2 kí tự’ a ‘u ti trong «caaandy».
{n, m}
Kí tự đứng trước phải xuất hiện từ n đến m lần. n và m là số nguyên dương và n <= m.Nếu m bị bỏ qua, nó tương đương như ∞.
Ví dụ, / a {1,3} / không khớp bất kì kí tự nào trong «cndy», kí tự ‘a’ trong «конфеты», 2 kí tự ‘a’ u tiên trong «caandy», và 3 ки tự ‘a’ đầu tiên trong «caaaaaaandy». Lưu ý là «caaaaaaandy» chỉ khớp với 3 ки tự ‘a’ u tiên mặc dù chuỗi đó chứa 7 kí tự ‘a’.
[xyz]
Lớp kí tự. Loại mẫu này dùng để so khớp với một kí tự bất kì trong dấu ngoặc vuông, bao gồm cả escape-последовательности.a-c], khớp với ‘r’ trong «грудинка» và ‘h’ trong «отбивная» là kí tự đầu tiên không thuộc khoảng a đến c.
[\ b]
Khớp với kí tự dịch lùi — backspace (U + 0008). Bn phải đặt trong dấu ngoặc vuông nếu muốn so khớp một kí tự dịch lùi. (Đừng nhầm lẫn với mẫu \ b).
\ b
Khớp với kí tự biên. Kí tự biên là một kí tự giả, nó khớp với vị trí mà một kí tự không được theo sau hoặc đứng trước bởi một kí tự khác.\ w | \ w $ | \ W \ w | \ w \ W). L u ý rằng một kí tự biên được khớp sẽ không bao gồm trong kết quả so khớp. Nói cách khác, độ dài của một kí tự biên là 0. (Đừng nhầm lẫn với mẫu [\ b])
Ví dụ: / \ bm / khớp với ‘m’ trong chuỗi «луна»; / oo \ b / không khớp ‘oo’ trong chuỗi «луна», bởi vì ‘oo’ được theo sau bởi kí tự ‘n’; / oon \ b / khớp với ‘oon’ trong chuỗi «луна», bởi vì ‘oon’ cuối chuỗi nên nó không được theo sau bởi một kí tự; / \ w \ b \ w / sẽ không khớp với bất kì thứ gì, bởi vì một kí tự không thể theo sau một kí tự biên và một kí tự thường.
Chú ý: Engine biên dịch biểu thức chính quy trong Javascript nh nghĩa một lớp kí tự là những kí tự thường. Bt kỳ kí tự nào không thuộc lớp kí tự bị xem như một kí tự ngắt. Lớp kí tự này khá hạn chế: nó bao gồm bộ kí tự La-tinh cả hoa và thường, số thập phân và kí tự gạch dưới. Kí tự có dấu, như «é» hay «ü», không may, bị đối xử như một kí tự ngắt.
\ B
Khớp với kí tự không phải kí tự biên.Mẫu này khớp tại vị trí mà kí tự trước và kí tự sau nó cùng kiểu: hoặc cả hai là kí tự hoặc cả hai không phải là kí tự. Bắt đầu và kết thúc chuỗi không được xem là những kí tự.
Ví dụ, /\B../ khớp với ‘oo’ trong «полдень», và /y\B./ khớp với ‘ye’ trong «возможно, вчера».
\ c X
X là một kí tự trong khoảng A tới Z. Mẫu này khớp với một kí tự iều khiển trong một chuỗi.
Ví dụ: / \ cM / khớp với control-M (U + 000D) trong chuỗi.
\ d
Приложение A. ОБЫЧНЫЙ ПОИСК ВЫРАЖЕНИЯ Приложение A. ОБЫЧНЫЙ ПОИСК ВЫРАЖЕНИЯ Краткая справочная информация Регулярное выражение состоит из строки символов, в которой даны некоторые символы
Поддерживаемый синтаксис [] Таблица A.1. Символы
x
Символ x
\\
Символ обратной косой черты
\ 0n с восьмеричным числом
\ 0n <= n <= 7)
\ 0nn
Символ с восьмеричным значением 0nn (0 <= n <= 7)
\ 0mnn
Символ с восьмеричным значением 0mnn (0 <= m <= 3, 0 <= n <=
7)
\ xhh
Символ с шестнадцатеричным значением 0xhh
\ uhhhh
Символ с шестнадцатеричным значением 0xhhhh
\
\ u0009 ')
\ n
Символ новой строки (перевод строки) (' \ u000A ')
\ r
Символ возврата каретки (' \ u000D ')
\ f
Символ подачи страницы (' \ u000C ')
\ a
Знак предупреждения (колокольчик) (' \ u0007 ')
\ e
Управляющий символ (' \ u001B ')
\ cx
Управляющий символ, соответствующий x
9036 8 Таблица А. m-p]]
a – z , а не m – p : [a-lq-z] (вычитание)
Таблица A.\ w]
Таблица A.4. Классы символов POSIX (только US-ASCII)
\ p {Lower}
Буквенный символ нижнего регистра: [az]
\ p {Upper}
Буквенный символ верхнего регистра: [AZ]
\ p {ASCII}
Все ASCII: [\ x00- \ x7F]
\ p {Alpha}
Буквенный символ: [\ p {Lower} \ p {Upper}]
\ p {Digit}
Десятичная цифра: [0-9]
\ p {Alnum}
Буквенно-цифровой символ: [\ p {Alpha} \ p {Digit}]
\ p {Punct}
Пунктуация: одна из! "# $% & '() * +, -._` {|} ~
\ p {Graph}
Видимый символ: [\ p {Alnum} \ p {Punct}]
\ p {Print}
Печатный символ: [\ p {Graph}]
\ p {Пусто}
Пробел или табуляция: [\ t]
\ p {Cntrl}
Управляющий символ: [\ x00- \ x1F \ x7F]
\ p {XDigit}
Шестнадцатеричная цифра: [0-9a-fA-F]
\ p {Пробел}
Пробельный символ: [\ t \ n \ x0B \ f \ r]
Таблица A.5. Классы для блоков и категорий Unicode
\ p {InGreek}
Символ в греческом блоке (простой блок)
\ p {Lu}
Заглавная буква (простая категория)
\ p {Sc}
Символ валюты
\ P {InGreek}
Любой символ, кроме одного в греческом блоке (отрицание)
[\ p {L} && [^ \ p {Lu}]]
Любая буква, кроме прописной (вычитание)
Таблица A.
Начало строки
$
Конец строки
\ b
Граница слова
\ B граница слова
\ A
Начало ввода
\ G
Конец предыдущего совпадения
\ Z
Конец ввода, но для финала терминатор, если есть
\ z
Конец входа
Таблица A.7. Жадные кванторы
X?
X, однократно или не сразу
X *
X, ноль или более
X +
X, один или несколько раз
X {n}
X, ровно n раз
X {n,}
X, не менее n раз
X {n, m}
X, не менее n, но не более м раз
Таблица А.8. Нехватка кванторов
X ??
X, один раз или не сразу
X *?
X, ноль или более раз
X +?
X, один или несколько раз
X {n}?
X, ровно n раз
X {n,}?
X, не менее n раз
X {n, m}?
X, не менее n, но не более m раз
Таблица A.9. Притяжательные кванторы
X? +
X, однократно или не полностью
X * +
X, ноль или более
000
X ++
X, один или несколько раз
X {n} +
X, ровно n раз
X {n,} +
X, не менее n раз
X {n, m} +
X, не менее n, но не более m раз
Таблица A.10. Логические операторы
Таблица A.11. Обратные ссылки
Таблица A.12. Предложение
\
Ничего, кроме кавычек следующего символа
\ Q
Ничего, но цитирует все символы до 000 \ E 000 \ E E
Ничего, но завершает котировку, начатую на \ Q
Таблица A.13. Специальные конструкции (не захватывающие)
(?: X)
X, как группа без захвата
(? Idmsux-idmsux)
Ничего, но включает / выключает флаги соответствия
(? Idmsux-idmsux: X)
X, как группа без захвата с заданными флагами вкл / выкл
(? = X)
X, через положительный просмотр вперед нулевой ширины
(?! X)
X, через отрицательный просмотр вперед нулевой ширины
(? <= X)
X, через ноль положительный просмотр назад с шириной
(?
X, через отрицательный просмотр назад с нулевой шириной
(?> X)
X, как независимый, без захвата группа
Обратные косые черты, экранирование и цитирование Символ обратной косой черты (' \ ') служит для введения экранированных конструкций, как \ соответствует одной обратной косой черте и \ { соответствует левой фигурной скобке.
Использование обратной косой черты перед любым буквенным символом, не обозначающим
Обратные косые черты в строковых литералах в исходном коде Java интерпретируются в соответствии с требованиями \ b " соответствует одному \\ b " соответствует \ (привет \) » является недопустимым и приводит к \ (привет \) ".
Классы символов могут появляться в других классах символов и могут состоять из && ). Союз
Приоритет операторов класса символов следующий, от наивысшего к низшему:
1
Буквальный переход
\ x
2
Группировка
[...]
3
Диапазон
az
4
Union
[ae] [iu]
9 -0003
5
[пересечение [aeiou]]
Обратите внимание, что набор метасимволов, который действует внутри символа
Якоря регулярного выражения Якоря относятся к семейству токенов регулярных выражений, которые не соответствуют никаким символам, но которые утверждают что-то о строке или процессе сопоставления. Якоря утверждают, что текущая позиция движка в строке совпадает с четко определенным положением: например, начало строки или конец строки.
Этот тип утверждения полезен по нескольким причинам. Во-первых, он выразительный: он позволяет вам указать, что вы хотите сопоставить цифры в конце строки, но не где-либо еще. Во-вторых, это эффективно: когда вы говорите движку, что хотите найти комплексный шаблон в заданном месте, ему не нужно тратить время на попытки найти этот шаблон во многих других местах. Вот почему руководство по стилю регулярных выражений рекомендует по возможности использовать якоря, даже если ваше регулярное выражение будет соответствовать без них. называется якорем, а \ b - границей и (? a в обеих строках:
(прямая ссылка)
Доллар $: конец строки (или строки) Якорь доллара меняет свое значение в зависимости от того, какой движок мы используем и включен ли многострочный режим. Начнем с самого узкого смысла, а затем постепенно расширим.
(прямая ссылка) Все двигатели: совпадение в самом конце строки яблоко , привязка $ соответствует позиции после e , а e $ соответствует окончательному e , но не первому.
Для удобства большинство движков встраивают некоторую гибкость в $, позволяя ему соответствовать до окончательного разрыва строки - мы рассмотрим это в следующих разделах.
JavaScript, однако, не обладает такой гибкостью (что вас не удивит, если вы помните, что JavaScript, по большому счету, является худшим среди всех основных движков регулярных выражений).Если вы добавите разрыв строки в конце строки яблоко , как в яблоко \ n , механизм JavaScript больше не будет соответствовать окончательному e .
(прямая ссылка) Все движки, кроме JavaScript: соответствие до одного окончательного разрыва строки
Во всех основных движках, кроме JavaScript, если в строке есть один последний разрыв строки, то привязка $ может совпадать с ним. Например, в яблоко \ n , e $ соответствует окончательному e .
Это удобно: если вы хотите сопоставить некоторые символы в конце строки, вам не нужно беспокоиться о том, может ли это иметь разрыв строки в конце.
(прямая ссылка) \ n . Но в PCRE (C, PHP, R…) определение разрыва строки для привязки $ зависит от того, как был скомпилирован PCRE. В зависимости от языка и инструмента, последнему символу новой строки может быть разрешено быть переводом строки, возвратом каретки, последовательностью перевода строки и возврата каретки или любого из вышеперечисленных.
Помимо этих потенциальных различий, связанных с тем, как был скомпилирован PCRE, PCRE также позволяет вам переопределить новую строку по умолчанию (и, следовательно, поведение $ anchor) одним из специальных модификаторов начала шаблона PCRE, таких как (* ANYCRLF), ( * CR) и (* ЛЮБОЙ)
(прямая ссылка) Многострочный режим (и Ruby по умолчанию): $ соответствует каждой строке
В Ruby привязка $ всегда соответствует концу строки. Например, e $ соответствует e в обеих строках:
Другие движки (включая JavaScript) также позволяют использовать $ в конце строки при включении многострочного режима (перейдите по ссылке, чтобы узнать, как включить многострочность на разных языках).и $ для соответствия в каждой строке может показаться раздражающим, потому что это нестандартно. Однако, как только вы узнаете о якорях, таких как \ A и \ Z, вы увидите, что этот способ действий имеет большой смысл, поскольку он придает якорям однозначное значение. также соответствует этой позиции.меняет свое значение, когда включена многострочная строка, \ A дает нам однозначную привязку, чтобы гарантировать, что мы действительно когда-либо сопоставляем только начало строки.
(прямая ссылка)
Самый конец строки: \ z
Строка идет
Во всех основных разновидностях регулярных выражений, кроме JavaScript и Python (где этот токен не существует), привязка \ z утверждает, что текущая позиция движка в строке - это самый конец строки (за исключением любых возможных окончательных разрывов строки).Следовательно, в следующей строке e \ z соответствует e в orange , но не apple :
Конечно, привязка $ также соответствует этой позиции. Но поскольку $ меняет свое значение, когда включена многострочная строка, \ z дает нам однозначную привязку, чтобы гарантировать, что мы действительно когда-либо сопоставляем только в самом конце строки.
Так как привязка \ A определяет самое начало строки, мы могли ожидать в конце строки другую заглавную букву, а не строчную \ z.Вместо этого \ Z (который мы увидим дальше) дает нам некоторую гибкость при переносе строки (кроме Python). Поэтому полезно думать о строке как о переходе от \ A к \ z.
(прямая ссылка)
Конец строки (или перед необязательным разрывом строки): \ Z Этот гибкий якорь «на конце струны» ведет себя по-разному в зависимости от двигателя.
✽ В Python токен \ Z делает то, что \ z делает в других движках: он соответствует только в самом конце строки.
✽ В .NET, Perl и Ruby разрешено совпадение \ Z перед окончательным переводом строки. Следовательно, e \ Z будет соответствовать заключительному e в строке apple \ norange \ n
✽ В Java \ Z также будет соответствовать перед последним символом разрыва строки, который может быть переводом строки или возвратом каретки и другие разделители строк.
✽ В PCRE (C, PHP, R…) \ Z также будет соответствовать перед последним символом разрыва строки. Как обсуждалось ранее, то, что PCRE определяет как символ разрыва строки, зависит от того, как он был скомпилирован, а также от потенциального присутствия специальных модификаторов начала шаблона PCRE, таких как (* ANYCRLF), (* CR) и (* ANY)
(прямая ссылка)
Наводим порядок: постоянно многострочный Есть хороший аргумент в пользу того, чтобы всегда оставлять многострочный режим включенным, чтобы дать четкие роли всем якорям, которые мы видели до сих пор.всегда совпадать в каждой строке. И если вам нужно найти совпадение в начале или конце строки, вы можете использовать \ A, \ Z или \ z.
Фактически, это поведение Руби. К этому же и движется Perl 6. Для меня эта идея имеет большой смысл: она избавляет от многострочного режима m и делает якоря более значимыми.
(прямая ссылка)
Начало строки или конец предыдущего совпадения: \ G .NET, PCRE (C, PHP, R…), Java, Perl и Ruby поддерживают \ G, полезную привязку, которая может соответствовать одной из двух позиций:
Среди прочего, \ G может пригодиться в токенизированных строках, когда вы хотите сопоставить токены в определенных областях строки, но не в других. Рассмотрим, например, эту строку, показывающую время Джейн и Тарзана в трех отдельных тестах на плавание:
(?: Jane | \ G) \ w +: (\ d +)
Есть и другие способы сделать это, особенно если у вас есть бесконечный просмотр назад (.NET), но такой подход особенно экономичен.
Как это работает? Когда движок пытается сопоставить начало строки, первый токен (?: Jane | \ G) завершается успешно, потому что \ G совпадает с началом строки. Однако следующий жетон (пробел) не работает против T Тарзана. Следующий шанс совпадения шаблона - в позиции перед Jane . Двигатель соответствует " Jane A: 35 ", что соответствует 35 Группе 1.В начальной позиции следующей попытки совпадения \ G совпадает, а двигатель соответствует " B: 33 ". Наконец, \ G снова совпадает, а двигатель соответствует " C: 31 ".
Между прочим, в PCRE, Perl и Ruby вам не нужно извлекать время из группы 1: вы можете сопоставить их напрямую с помощью этого небольшого варианта, где \ K говорит движку отбросить то, что было сопоставлено так далеко от совпадения. должен быть возвращен: (?: Jane | \ G) \ w +: \ K \ d +
(прямая ссылка) Матч "Начало строки": Использование или Bridling \ G
Для нашего второго примера рассмотрим эту строку, которая может представлять две потенциальные позиции для размещения «подводной лодки» на бумажной сетке при подготовке к морскому сражению: против ) имеет три жетона, состоящих из одной буквы и одной цифры.
Предположим, мы хотим сопоставить первые три токена, то есть A1 , B1 , C1 .N соответствует всем строкам, начинающимся с N.
Конец строки ($) Символ доллара $ соответствует концу строки.
Отобразите строки, заканчивающиеся буквой r:
$ sed -n '/ r $ / p' employee.txt
102, Джейсон Смит, ИТ-менеджер
104, Ананд Рам, разработчик
105, Джейн Миллер, менеджер по продажам
Односимвольный (.) Специальный метасимвол «.» (точка) соответствует любому символу, кроме символа конца строки.
. соответствует одиночному символу
.. соответствует двум символам
... соответствует трем символам
и т. Д.
В следующем примере шаблон «J, за которым следуют три символа и пробел» будет заменен на «Джейсон, за которым следует пробел». Итак, «J ...» соответствует как «Джон», так и «Джейн» из employee.txt, и эти две строки заменяются соответственно, как показано ниже.
$ sed -n 's / J ... / Джейсон / p' employee.txt
101, Джейсон Доу, генеральный директор
105, Джейсон Миллер, менеджер по продажам
Ноль или более вхождений (*) Специальный символ «*» (звездочка) соответствует нулю или более вхождений предыдущего символа.Например, шаблон ’1 *’ соответствует нулю или более чем ’1 '.
Для этого примера создайте следующий файл log.txt:
$ vi log.txt
журнал: ввод подтвержден
журнал:
журнал: тестирование возобновлено
журнал:
журнал: вывод создан
Предположим, вы хотите просмотреть только те строки, которые содержат «log:», за которым следует сообщение. Сообщение может сразу же следовать за журналом или содержать пробелы. Вы не хотите, чтобы строки, содержащие "log:", ничего не отображали.
Отобразите все строки, которые содержат «журнал:», за которым следует один или несколько пробелов, за которыми следует символ:
$ sed -n '/ журнал: *./ p 'log.txt
журнал: ввод подтвержден
журнал: тестирование возобновлено
журнал: вывод создан
Примечание. В приведенном выше примере точка в конце необходима. Если не указан, sed также распечатает все строки, содержащие только «log:».
Одно или несколько происшествий (\ +) Специальный символ «\ +» соответствует одному или нескольким вхождениям предыдущего символа. Например, пробел перед «\ +», т.е. «\ +» соответствует как минимум одному или нескольким пробелам. Давайте использовать тот же файл log.txt в качестве примера файла.
Отобразите все строки, содержащие слово «log:», за которым следует один или несколько пробелов:
$ sed -n '/ журнал: \ + / p' журнал.текст
журнал: ввод подтвержден
журнал: тестирование возобновлено
Примечание. В дополнение к несоответствию строк «log:» only, приведенный выше пример также не соответствует строке «log: output created», поскольку в этой строке нет места после «log:».
Ноль или один вхождение (\?) Специальный символ «?» соответствует нулю или одному вхождению предыдущего символа, как показано ниже.
$ sed -n '/ журнал: \? / p' log.txt
журнал: ввод подтвержден
журнал:
журнал: тестирование возобновлено
журнал:
журнал: вывод создан
Экранирование специального символа (\) Если вы хотите искать специальные символы (например: *, точка) в содержимом, вам необходимо экранировать специальный символ в регулярном выражении.
$ sed -n '/127\.0\.0\.1/ p' / etc / hosts
127.0.0.1 локальный хост.localdomain локальный хост
Класс символов ([0-9]) Класс символов - это не что иное, как список символов, упомянутых в квадратных скобках; это используется для соответствия только одному из нескольких символов.
Соответствует любой строке, содержащей 2, 3 или 4:
$ sed -n '/ [234] / p' employee.txt
102, Джейсон Смит, ИТ-менеджер
103, Радж Редди, системный администратор
104, Ананд Рам, разработчик
В квадратных скобках вы можете использовать дефис, вы можете указать диапазон символов.Например, [0123456789] может быть представлен как [0-9], а алфавитные диапазоны могут быть указаны, например, [a-z], [A-Z] и т. Д.
Соответствует любой строке, содержащей 2, 3 или 4 (альтернативная форма):
$ sed -n '/ [2-4] / p' employee.txt
102, Джейсон Смит, ИТ-менеджер
103, Радж Редди, системный администратор
104, Ананд Рам, разработчик
21. Дополнительные регулярные выражения Операция ИЛИ (|) Символ вертикальной черты (|) используется для указания того, что в позиции может встречаться любое из двух целых подвыражений. «Подвыражение1 | подвыражение2 »соответствует подвыражению1 или подвыражению2.Выведите строки, содержащие либо 101, либо 102:
$ sed -n '/ 101 \ | 102 / p' employee.txt
101, Джон Доу, генеральный директор
102, Джейсон Смит, ИТ-менеджер
Обратите внимание, что | символ экранирован символом /.
Выведите строки, содержащие символы от 2 до 3 или содержащие строку 105:
$ sed -n '/ [2-3] \ | 105 / p' employee.txt
102, Джейсон Смит, ИТ-менеджер
103, Радж Редди, системный администратор
105, Джейн Миллер, менеджер по продажам
Ровно M вхождений ({m}) Регулярное выражение, за которым следует {m}, соответствует точно m вхождениям предыдущего выражения.[0-9] \ {3,5 \} $ / p 'numbers.txt
Регулярное выражение, за которым следует {m,} - это особый случай, который соответствует m или более вхождениям предыдущего выражения.
Граница слова (\ b) \ b используется для сопоставления границы слова. \ b соответствует любому символу (символам) в начале (\ bxx) и / или конце (xx \ b) слова, поэтому \ bthe \ b найдет, но не они. \ bThe найдут или они.
Создайте следующий образец файла для тестирования.
$ cat words.txt
сопоставление слов с использованием:
сопоставление слов с использованием: thethe
сопоставление слов с использованием: они
Сопоставьте строки, содержащие целое слово "the":
$ sed -n '/ \ b \ b / p' слова.текст
сопоставление слов с использованием:
Обратите внимание, что если вы не укажете \ b в конце, он будет соответствовать всем строкам.
Сопоставьте строки, содержащие слова, начинающиеся с «the»:
$ sed -n '/ \ bthe / p' words.txt
сопоставление слов с использованием:
сопоставление слов с использованием: thethe
сопоставление слов с использованием: они
Обратные ссылки (\ n) Обратные ссылки позволяют группировать выражения для дальнейшего использования.
Соответствует только строке, в которой слово "the" повторяется дважды:
$ sed -n '/ \ (\) \ 1 / p' words.txt
Используя ту же логику, регулярное выражение «\ ([0-9] \) \ 1» соответствует двузначному числу, в котором обе цифры являются одним и тем же числом, например 11,22,33.
22. Замена Sed регулярным выражением Ниже приведены несколько примеров замены sed, в которой используются регулярные выражения.
Замените последние два символа в каждой строке employee.txt на ", Not Defined":
$ sed 's /..$/, не определено /' employee.txt
101, Джон Доу, C, не определено
102, Джейсон Смит, ИТ-менеджер, не определено
103, Радж Редди, Sysadm, не определено
104, Ананд Рам, Развитие, Не определено
105, Джейн Миллер, менеджер по продажам, не определено
Удалите оставшуюся часть строки, начиная с «Manager»:
$ sed / Manager.#. * / d '/ etc / profile
Вы можете преобразовать символы новой строки DOS (CR / LF) в формат Unix, используя sed. Когда вы копируете файл DOS в Unix, вы можете найти \ r \ n в конце каждой строки.
Преобразуйте формат файла DOS в формат файла Unix с помощью sed:
sed 's /.$//' имя файла
Регулярные выражения Kotlin - использование регулярных выражений в Kotlin
последнее изменение 5 июля 2020 г.
В учебнике по регулярным выражениям Kotlin показано, как использовать регулярные выражения
Регулярные выражения используются для поиска текста и более сложного текста
Регулярное выражение Котлина
В Kotlin мы создаем регулярные выражения с помощью Regex .
Regex ("книга")
"книга" .toRegex ()
Regex.fromLiteral ("книга")
Шаблон - это регулярное выражение, определяющее текст, который мы \ s ищем пробелы.
Специальные символы должны быть экранированы дважды, иначе мы можем использовать Kotlin raw
После того, как мы создали шаблон, мы можем использовать одну из функций соответствует () , containsMatchIn () , find () , findall () , replace () и split () .
В следующей таблице показаны некоторые часто используемые регулярные выражения:
Регулярное выражение
Значение
. abc]
Отрицание, соответствует всему, кроме a, или b, или c.
\ с
Соответствует пробелу.
\ w
Соответствует словесному символу; эквивалент [a-zA-Z_0-9]
Kotlin соответствует и содержит методы MatchIn
Метод Match () возвращает истину, если регулярное выражение containsMatchIn ()
simple_regex.kt
пакет com.zetcode
fun main () {
val words = listOf ("книга", "книжный червь", "Библия",
«книжный», «кулинарная», «книжный магазин», «бумажник»)
val pattern = "книга" .toRegex ()
println ("*********************")
println ("функция containsMatchIn")
words.forEach {слово ->
if (pattern.containsMatchIn (word)) {
println ("$ word совпадает")
}
}
println ("*********************")
println ("соответствует функции")
слова.forEach {слово ->
if (pattern.matches (word)) {
println ("$ word совпадает")
}
}
}
В этом примере мы используем матчей () и containsMatchIn () методов. У нас есть список слов.
val pattern = "книга" .toRegex ()
Шаблон регулярного выражения создается с помощью toRegex ()
words.forEach {слово ->
if (pattern.containsMatchIn (word)) {
println ("$ word совпадает")
}
}
Мы перебираем список и применяем containsMatchIn () к
words.forEach {слово ->
if (pattern.matches (word)) {
println ("$ word совпадает")
}
}
Мы снова перебираем список и применяем совпадений () к
*********************
containsMatchIn функция
забронировать спички
спички книжного червя
книжные спички
поваренная книга спички
книжный магазин спички
карманные спички
*********************
функция соответствия
забронировать спички
Для метода containsMatchIn () шаблон соответствует совпадений () ,
Метод поиска Котлина
Метод find () возвращает первое совпадение обычного
regex_find.kt
пакет com.zetcode
fun main () {
val text = "Я видел лису в лесу. У лисы был рыжий мех."
val pattern = "лиса" .toRegex ()
val match = pattern.find (текст)
val m = совпадение? .value
val idx = match? .range
println ("$ m найдено по индексам: $ idx")
val match3 = шаблон.найти (текст, 11)
val m2 = match3? .значение
val idx2 = match3? .range
println ("$ m2 найдено по индексам: $ idx2")
}
В примере мы узнаем индексы совпадения термина «лиса».
val match = pattern.find (текст)
val m = совпадение? .value
val idx = match? .range
Мы находим первое совпадение термина «лиса». Получаем его стоимость и показатели.
val match3 = pattern.find (текст, 11)
val m2 = match3? .значение
val idx2 = match3? .range
Во втором случае мы начинаем поиск с индекса 11, находя таким образом
лиса найдена по индексам: 8..10
лиса найдено по индексам: 29..31
Это результат.
Kotlin findAll метод
Метод findAll () возвращает последовательность всех вхождений
regex_findall.kt
пакет com.zetcode
fun main () {
val text = "Я видел лису в лесу. У лисы был рыжий мех."
val pattern = "лиса" .toRegex ()
val соответствует = pattern.findAll (текст)
совпадения.forEach {f ->
val m = f.value
val idx = f.range
println ("$ m найдено по индексам: $ idx")
}
}
В этом примере мы находим все вхождения термина «лиса» с findAll () .
Границы слов регулярного выражения Kotlin
Метасимвол \ b - это якорь, который соответствует позиции, которая
word_boundaries.kt
пакет com.zetcode
fun main () {
val text = "Этот остров прекрасен"
val pattern = "\\ bis \\ b" .toRegex ()
val соответствует = pattern.findAll (текст)
match.forEach {m ->
val v = m.value
val idx = m.range
println ("$ v найдено по индексам: $ idx")
}
}
В этом примере мы ищем - это слово. Мы не хотим включать Это и остров слов.
val pattern = "\\ bis \\ b" .toRegex ()
С двумя метасимволами \ b мы ищем - это целое слово .
val соответствует = pattern.findAll (текст)
С помощью функции findAll () мы находим все совпадения.
находится по индексам: 12..13
Это результат.
Регулярное выражение Kotlin неявные границы слов
\ w - это класс символов, используемый для символа, разрешенного в слове. \ w + , обозначающего слово, в начале \ w + - это \ b \ w + \ b .
implicit_word_boundaries.kt
пакет com.zetcode
fun main () {
val content = "" "
Лисицы - всеядные млекопитающие, принадлежащие к нескольким родам.
семейства Canidae. У лисиц уплощенный череп, прямостоячие треугольные уши,
заостренная, слегка вздернутая морда и длинный пушистый хвост. Лисы живут на каждом
континент, кроме Антарктиды. Безусловно, наиболее распространенные и широко распространенные виды
лиса - это рыжая лисица. "" "
val шаблон = "\\ ш +".toRegex ()
val words = pattern.findAll (содержание)
val count = words.count ()
println ("Есть $ count слов")
words.forEach {matchResult ->
println (matchResult.value)
}
}
В этом примере мы ищем все слова в тексте.
val pattern = "\\ w +". toRegex ()
Ищем слова.
val words = pattern.findAll (содержание)
val count = words.count ()
Находим все слова и считаем.
Символы валюты Котлина
Обычное выражение \ p {Sc} можно использовать для поиска валюты
currency_symbols.kt
пакет com.zetcode
fun main () {
val content = "" "
Символы валюты: ฿ Тайская баня, ₹ Индийская рупия, ₾ Грузинский лари, Доллар США,
€ Евро, ¥ Йена, фунт стерлингов "" "
val pattern = "\\ p {Sc}". toRegex (RegexOption.IGNORE_CASE)
val соответствует = pattern.findAll (контент)
match.forEach {matchResult ->
val currency = matchResult.value
val idx = matchResult.range
println ("$ валюта в $ idx")
}
}
В этом примере мы ищем символы валюты.
val content = "" "
Символы валюты: ฿ Тайская баня, ₹ Индийская рупия, ₾ Грузинский лари, Доллар США,
€ Евро, ¥ Йена, фунт стерлингов "" "
В тексте есть пара символов валюты.
val pattern = "\\ p {Sc}". toRegex (RegexOption.IGNORE_CASE)
Мы определяем регулярное выражение для символов валюты.
val соответствует = pattern.findAll (контент)
Находим все совпадения.
match.forEach {matchResult ->
val currency = matchResult.значение
val idx = matchResult.range
println ("$ валюта в $ idx")
}
Мы печатаем все совпавшие значения и их индексы.
฿ в 19..19
₹ в 36..36
₾ на 52..52
$ по 69..69
€ 79..79
¥ в размере 87..87
£ по 94..94
Это результат.
Функция разделения Котлина
Метод split () разбивает входную строку по совпадениям
regex_split.js
пакет com.zetcode
fun main () {
val text = "Я видел лису в лесу.У лисы был рыжий мех ".
val pattern = "\\ W +". toRegex ()
val words = pattern.split (текст) .filter {it.isNotBlank ()}
println (слова)
}
В примере мы узнаем, сколько раз встречается термин «лиса».
val pattern = "\\ W +". toRegex ()
Шаблон содержит именованный класс символов \ W , который +
val words = pattern.split (текст) .filter {it.isNotBlank ()}
С помощью метода split () мы разбиваем входную строку на
[Я видел лису в лесу, лису, рыжую, мех]
Это результат.
Соответствие без учета регистра
Чтобы включить поиск без учета регистра, мы передаем RegexOption.IGNORE_CASE toRegex () .
regex_case_insensitive.kt
пакет com.zetcode
fun main () {
val words = listOf ("собака", "Собака", "СОБАКА", "Собака")
val pattern = "собака" .toRegex (RegexOption.IGNORE_CASE)
words.forEach {слово ->
if (pattern.matches (word)) {
println ("$ word совпадает")
}
}
}
В этом примере мы применяем шаблон к словам независимо от регистра.
val pattern = "собака".toRegex (RegexOption.IGNORE_CASE)
Мы используем RegexOption.IGNORE_CASE , чтобы игнорировать регистр
собачьи спички
Матчи для собак
Матчи DOG
Это результат.
Метасимвол точка
Метасимвол точка (.) Обозначает любой отдельный символ в тексте.
regex_dot_meta.kt
пакет com.zetcode
fun main () {
val words = listOf ("семь", "даже", "предотвратить", "месть", "maven",
«одиннадцать», «аминь», «событие»)
val шаблон = "..even ".toRegex ()
words.forEach {слово ->
if (pattern.containsMatchIn (word)) {
println ("$ word совпадает")
}
}
}
В этом примере у нас есть список из восьми слов. Наносим выкройку
предотвратить матчи
одиннадцать матчей
Есть два слова, которые соответствуют шаблону.
Метасимвол вопросительного знака
Мета-символ вопросительного знака (?) - это квантификатор, соответствующий
regex_qmark_meta.kt
пакет com.zetcode
fun main () {
val words = listOf ("семь", "даже", "предотвратить", "месть", "maven",
«одиннадцать», «аминь», «событие»)
val шаблон = ".? даже" .toRegex ()
words.forEach {слово ->
if (pattern.matches (word)) {
println ("$ word совпадает")
}
}
}
В этом примере мы добавляем вопросительный знак после символа точки.
семь матчей
даже совпадения
Это результат.
Квантор {n, m}
Квантор {n, m} соответствует не менее n и не более m вхождениям
regex_mn_quantifier.kt
пакет com.zetcode
fun main () {
val words = listOf ("ручка", "книга", "круто", "карандаш", "лес", "машина",
«список», «отдых», «спросить», «точка», «глаза»)
val pattern = "\\ w {3,4}". toRegex ()
words.forEach {слово ->
если (шаблон.match (word)) {
println ("$ word совпадает")
} else {
println ("$ word не соответствует")
}
}
}
В этом примере мы ищем слова, в которых есть три или четыре
val pattern = "\\ w {3,4}". toRegex ()
В шаблоне у нас есть символ слова, повторяющийся три или четыре раза.
ручки спички
забронировать спички
крутые матчи
карандаш не подходит
лес не совпадает
автомобильные спички
список совпадений
остальные матчи
спрашивать совпадения
точка не совпадает
глаза совпадают
Это результат.Джейн . Шаблон проверяет, находится ли строка «Джейн» Jane \. будет искать
Чередование регулярных выражений Kotlin
Оператор чередования | создает регулярное выражение с несколькими вариантами.
regex_alternations.kt
пакет com.zetcode
fun main () {
val words = listOf ("Джейн", "Томас", "Роберт",
«Люси», «Беки», «Джон», «Питер», «Энди»)
val pattern = "Джейн | Беки | Роберт".toRegex ()
words.forEach {слово ->
if (pattern.matches (word)) {
println (слово)
}
}
}
У нас в списке восемь имен.
val pattern = "Джейн | Беки | Роберт" .toRegex ()
Это регулярное выражение ищет строки «Джейн», «Беки» или «Роберт».
Подшаблоны регулярных выражений Kotlin
Подшаблоны — это паттерны внутри паттернов. Подшаблоны созданы
regex_subpatterns.kt
пакет com.zetcode
fun main () {
val words = listOf ("книга", "книжная полка", "книжный червь",
«книжный шкаф», «книжный», «бухгалтер», «буклет», «закладка»)
val pattern = "книга (червь | отметка | хранитель)?". toRegex ()
words.forEach {слово ->
if (pattern.matches (word)) {
println ("$ word совпадает")
} else {
println ("$ word не соответствует")
}
}
}
В примере создается подшаблон.
val pattern = "книга (червь | отметка | хранитель)?".toRegex ()
Регулярное выражение использует подшаблон. Соответствует книжному червю,
забронировать спички
книжная полка не совпадает
спички книжного червя
книжный шкаф не соответствует
книжный не соответствует
бухгалтерские матчи
буклет не соответствует
закладки совпадений
Это результат.
Классы символов регулярного выражения Kotlin
Класс символов определяет набор символов, любой из которых может встречаться в
character_classes.kt
пакет com.zetcode
fun main () {
val words = listOf ("серая птица", "седые волосы", "отличный вид")
val pattern = "gr [ea] y" .toRegex ()
words.forEach {слово ->
if (pattern.containsMatchIn (word)) {
println (слово)
}
}
}
В этом примере мы используем класс символов, включающий серый и серый цвета.
val pattern = "gr [ea] y" .toRegex ()
Класс [ea] позволяет использовать символ «e» или «a».
Котлин назвал классы персонажей
Есть несколько предопределенных классов символов. \ s [\ t \ n \ t \ f \ v] , \ d цифра [0-9] и \ w [a-zA-Z0-9_] .
named_character_classes.kt
пакет com.zetcode
fun main () {
val text = "Мы познакомились в 2013 году. Ей должно быть около 27 лет".
val шаблон = "\\ d +". toRegex ()
val found = pattern.findAll (текст)
found.forEach {f ->
val m = f.value
println (м)
}
}
В этом примере мы ищем числа в тексте.
val шаблон = "\\ d +". toRegex ()
Шаблон \ d + ищет любое количество наборов цифр в
val found = pattern.findAll (текст)
Чтобы найти все совпадения с , findAll () .
2013
27
Это результат.
Группы захвата регулярных выражений Kotlin
Круглые скобки () используются для создания групп захвата.Это позволяет
capturing_groups.kt
пакет com.zetcode
fun main () {
val сайты = listOf (
"webcode.me", "zetcode.com", "freebsd.org",
"netbsd.org"
)
val pattern = "(\\ w +) \\. (\\ w +)". toRegex ()
для (сайт на сайтах) {
val match = pattern.findAll (сайт)
match.forEach {matchResult ->
println (matchResult.значение)
println (matchResult.groupValues [1])
println (matchResult.groupValues [2])
println ("*****************")
}
}
}
В этом примере мы разделяем доменные имена на две части с помощью групп.
val pattern = "(\\ w +) \\. (\\ w +)". toRegex ()
Мы определяем две группы скобками.
match.forEach {matchResult ->
println (matchResult.value)
println (matchResult.groupValues [1])
println (matchResult.groupValues [2])
println ("*****************")
}
Доступ к группам осуществляется через функцию groupValues () . groupValues [0]) возвращает всю совпавшую строку; это value property.
webcode.me
веб-код
мне
*****************
zetcode.com
zetcode
com
*****************
freebsd.org
freebsd
org
*****************
netbsd.org
netbsd
org
*****************
Это результат.
В следующем примере мы используем группы для работы с выражениями.
regex_expressions.kt
пакет com.zetcode
fun main () {
val выражения = listOf ("16 + 11", "12 * 5", "27/3", "2-8")
val pattern = "(\\ d +) \\ s + ([- + * /]) \\ s + (\\ d +)". toRegex ()
for (выражение в выражениях) {
val соответствует = pattern.findAll (выражение)
match.forEach {matchResult ->
значение value1 = matchResult.groupValues [1] .toInt ()
значение значение2 = matchResult.groupValues [3] .toInt ()
val msg = когда (matchResult.groupValues [2]) {
"+" -> "$ выражение = $ {значение1 + значение2}"
"-" -> "$ выражение = $ {значение1 - значение2}"
"*" -> "$ выражение = $ {значение1 * значение2}"
"/" -> "$ выражение = $ {значение1 / значение2}"
else -> «Неизвестный оператор»
}
println (сообщение)
}
}
}
В примере анализируются четыре простых математических выражения и вычисляются их.
val выражения = listOf ("16 + 11", "12 * 5", "27/3", "2-8")
У нас есть список из четырех выражений.
val pattern = "(\\ d +) \\ s + ([- + * /]) \\ s + (\\ d +)". toRegex ()
В шаблоне регулярного выражения у нас есть три группы: две группы для значений, одна для
значение value1 = matchResult.groupValues [1] .toInt ()
значение значение2 = matchResult.groupValues [3] .toInt ()
Получаем значения и преобразуем их в целые числа.
val msg = when (matchResult.groupValues [2]) {
"+" -> "$ выражение = $ {значение1 + значение2}"
"-" -> "$ выражение = $ {значение1 - значение2}"
"*" -> "$ выражение = $ {значение1 * значение2}"
"/" -> "$ выражение = $ {значение1 / значение2}"
else -> «Неизвестный оператор»
}
С помощью выражения when мы вычисляем выражения и строим сообщения.
16 + 11 = 27
12 * 5 = 60
27/3 = 9
2-8 = -6
Это результат.
Пример электронного письма с регулярным выражением Kotlin
В следующем примере мы создаем шаблон регулярного выражения для проверки
regex_emails.kt
пакет com.zetcode
fun main () {
val emails = listOf ("[email protected] ", "andy @ yahoocom",
«34234sdfa # 2345», «[email protected] », «[email protected] »)
val шаблон = "[a-zA-Z0-9 ._-] + @ [a-zA-Z0-9 -] + \\.[а-я-я.] {2,18} ". toRegex ()
emails.forEach {email ->
if (pattern.matches (электронная почта)) {
println ("$ email соответствует")
} else {
println ("$ email не соответствует")
}
}
}
Этот пример предлагает одно возможное решение.
val pattern = "[a-zA-Z0-9 ._-] + @ [a-zA-Z0-9 -] + \\. [a-zA-Z.] {2,18}". toRegex ()
Электронное письмо разделено на пять частей. Первая часть — это локальная часть. [a-zA-Z0-9 ._-] + перечисляет все возможные символы, которые мы можем
Вторая часть состоит из буквального символа @ . Третий [a-zA-Z0-9 -] + + позволяет использовать один или несколько из этих символов.
Четвертая часть — это точка; ему предшествует двойной escape
Последняя часть — это доменное имя верхнего уровня: [a-zA-Z.] {2,18} .
[email protected] соответствует
andy @ yahoocom не соответствует
34234sdfa # 2345 не соответствует
[email protected] соответствует
[email protected] не соответствует
Это результат.
В этой главе мы рассмотрели регулярные выражения в Kotlin.
Список всех руководств по Kotlin.
Справочник по регулярным выражениям
— Cisco Содержание Справочник по регулярным выражениям
Детали регулярного выражения PCRE
Обратная косая черта
Непечатаемые символы
Общие типы символов
Свойства символов Юникода
Простые утверждения
Circumflex и доллар
Полная остановка (точка, точка)
Соответствие одному байту
Квадратные скобки и классы символов
Классы символов Posix
Вертикальная полоса
Настройка внутренних опций
Подшаблоны
Именованные подшаблоны
Повторение
Атомарная группировка и притяжательные квантификаторы
Обратные ссылки
Утверждения
Утверждения опережающего просмотра
Утверждения просмотра назад
Использование нескольких утверждений
Условные подшаблоны
Комментарии
Рекурсивные шаблоны
Подшаблоны как подпрограммы
Вызовы
Справочник по регулярным выражениям • Подробности регулярного выражения PCRE
• Обратная косая черта
• Циркумфлекс и доллар
• Полная остановка (точка, точка)
• Соответствие одиночному байту
• Квадратные скобки и классы символов
• Классы символов Posix
• Вертикальная полоса
• Внутренняя настройка параметров
• Подшаблоны
• Именованные подшаблоны
• Повторение
• Атомарная группировка и притяжательные квантификаторы
• Обратные ссылки
• Утверждения
• Условные подшаблоны
• Комментарии
• Рекурсивные шаблоны
• Подшаблоны как подпрограммы
• Выноски
Подробности регулярного выражения PCRE Синтаксис и семантика регулярных выражений, поддерживаемых PCRE, описаны ниже.Регулярные выражения также описаны в документации Perl и в ряде книг, некоторые из которых содержат множество примеров. В книге Джеффри Фридла «Mastering Regular Expressions», опубликованной O’Reilly, регулярные выражения рассматриваются очень подробно. Это описание регулярных выражений PCRE предназначено как справочный материал.
Изначально PCRE выполняла операции со строками однобайтовых символов. Однако теперь также есть поддержка символьных строк UTF-8. Чтобы использовать это, вы должны собрать PCRE, чтобы включить поддержку UTF-8, а затем вызвать pcre_compile () с опцией PCRE_UTF8.Как это влияет на сопоставление с образцом, упоминается в нескольких местах ниже. Также имеется сводка возможностей UTF-8 в разделе о поддержке UTF-8 на главной странице PCRE.
Регулярное выражение — это шаблон, который сопоставляется с предметной строкой слева направо. Большинство символов обозначают себя в шаблоне и соответствуют соответствующим символам в теме. В качестве банального примера выкройка
соответствует части темы
.
group: 111
group: 1111
group: 11111 11111 11111
group: 111111 111 1111 11111 1111
