Regular Expressions
Полезная Regex Витрина

Совпадение даты

Вы должны помнить, что регулярное выражение предназначено для сопоставления даты (или нет). Утверждение о том, что дата действительна, является гораздо более сложной борьбой, поскольку для этого потребуется много обработки исключений (см. Условия високосного года ).

Начнем с сопоставления месяца (1 - 12) с необязательным ведущим 0:

0?[1-9]|1[0-2]

Чтобы сопоставить день, также с необязательным ведущим 0:

0?[1-9]|[12][0-9]|3[01]

И чтобы соответствовать году (давайте просто предположим, что диапазон 1900 - 2999):

(?:19|20)[0-9]{2}

Сепаратор может быть пространством, тире, косой чертой, пустым и т. Д. Не стесняйтесь добавлять все, что, по вашему мнению, можно использовать в качестве разделителя:

[-\\/ ]?

Теперь вы соедините все это и получите:

(0?[1-9]|1[0-2])[-\\/ ]?(0?[1-9]|[12][0-9]|3[01])[-/ ]?(?:19|20)[0-9]{2} // MMDDYYYY
(0?[1-9]|[12][0-9]|3[01])[-\\/ ]?(0?[1-9]|1[0-2])[-/ ]?(?:19|20)[0-9]{2} // DDMMYYYY
(?:19|20)[0-9]{2}[-\\/ ]?(0?[1-9]|1[0-2])[-/ ]?(0?[1-9]|[12][0-9]|3[01]) // YYYYMMDD

Если вы хотите быть немного более педантичным, вы можете использовать обратную ссылку, чтобы быть уверенным, что два разделителя будут одинаковыми:

(0?[1-9]|1[0-2])([-\\/ ]?)(0?[1-9]|[12][0-9]|3[01])\2(?:19|20)[0-9]{2} // MMDDYYYY
                                                 ^ refer to [-/ ]
(0?[1-9]|[12][0-9]|3[01])([-\\/ ]?)(0?[1-9]|1[0-2])\2(?:19|20)[0-9]{2} // DDMMYYYY
(?:19|20)[0-9]{2}([-\\/ ]?)(0?[1-9]|1[0-2])\2(0?[1-9]|[12][0-9]|3[01]) // YYYYMMDD

Сопоставьте адрес электронной почты

Согласование адреса электронной почты внутри строки является трудной задачей, поскольку спецификация, определяющая ее, RFC2822 , сложна, что трудно реализовать в качестве регулярного выражения. Более подробную информацию о том, почему не рекомендуется сопоставлять электронную почту с регулярным выражением, см. Пример антипаттера, если вы не используете регулярное выражение: для сопоставления писем . Лучшим советом, который следует учитывать на этой странице, является использование экспертной оценки и широкой библиотеки на вашем любимом языке для ее реализации.

Подтвердить формат адреса электронной почты

Когда вам нужно быстро проверить запись, чтобы убедиться, что она похожа на электронную почту, лучшим вариантом является ее простота:

^\S{1,}@\S{2,}\.\S{2,}$

Это регулярное выражение будет проверять, что почтовый адрес представляет собой не пространственную разделяемую последовательность символов длиной больше единицы, за которой следует @ , за которой следуют две последовательности символов без пробелов длиной две или более, разделенные символом a . , Это не идеально, и может проверять недействительные адреса (в соответствии с форматом), но самое главное, это не является недействительным действительные адреса.

Проверить адрес

Единственный надежный способ проверить правильность электронного письма - проверить его существование. Раньше была команда VRFY SMTP, которая была разработана для этой цели, но, к сожалению, после злоупотребления спамерами она теперь больше не доступна .

Таким образом, единственный способ, которым вы остались, проверить, что почта действительна и существует, - это фактически отправить электронное письмо на этот адрес.

Огромные альтернативы Regex

Хотя, это не невозможно проверить адрес электронной почты с помощью регулярных выражений. Единственные проблемы в том, что чем ближе к спецификации эти регулярные выражения будут, тем больше они будут и, как следствие, их невозможно прочитать и сохранить. Ниже вы найдете пример такого более точного регулярного выражения, которое используется в некоторых библиотеках.

⚠️ Следующее регулярное выражение дается для документации и целей обучения, скопировать их в свой код - плохая идея. Вместо этого используйте эту библиотеку напрямую, поэтому вы можете полагаться на вышеперечисленных разработчиков кода и разработчиков сверстников, чтобы обновлять и обновлять код анализа электронной почты.

Модуль согласования адресов Perl

Лучшие примеры такого регулярного выражения находятся в некоторых языках стандартных библиотек. Например, есть один из модуля RFC::RFC822::Address в библиотеке Perl, который пытается быть максимально точным в соответствии с RFC. Для вашего любопытства вы можете найти версию этого регулярного выражения по этому URL-адресу , которое было создано из грамматики, и если у вас есть соблазн скопировать его, вот цитата из автора регулярного выражения:

« Я не поддерживаю регулярное выражение [связанное]. В нем могут быть ошибки, которые уже были исправлены в модуле Perl».

.Net-адресный модуль соответствия

Другой, более короткий вариант - тот, который используется стандартной библиотекой .Net в модуле EmailAddressAttribute :

^((([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+(\.([a-z]|\d|[!#\$%&'\*\+\-\/=\?\^_`{\|}~]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])+)*)|((\x22)((((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(([\x01-\x08\x0b\x0c\x0e-\x1f\x7f]|\x21|[\x23-\x5b]|[\x5d-\x7e]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(\\([\x01-\x09\x0b\x0c\x0d-\x7f]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]))))*(((\x20|\x09)*(\x0d\x0a))?(\x20|\x09)+)?(\x22)))@((([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|\d|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.)+(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])|(([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])([a-z]|\d|-|\.|_|~|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])*([a-z]|[\u00A0-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF])))\.?$

Но даже если он короче, он все еще слишком велик, чтобы быть читаемым и легко ремонтируемым.

Модуль согласования адресов Ruby

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

Модуль согласования адресов Python

В качестве встречного примера модуль синтаксического анализа электронной почты python не использует регулярное выражение, а вместо него реализует его с помощью синтаксического анализатора.

Сопоставьте номер телефона

Вот как сопоставить префиксный код (a + или (00), а затем число от 1 до 1939 с дополнительным пространством):
^{Это не ищет допустимый префикс, а может быть префиксом. Полный список префиксов}

(?:00|\+)?[0-9]{4}

Тогда, поскольку длина всего номера телефона составляет, самое большее, 15, мы можем искать до 14 цифр:
^{Для префикса тратится не менее 1 разряда}

[0-9]{1,14}

Номера могут содержать пробелы, точки или тире и могут быть сгруппированы по 2 или 3.

(?:[ .-][0-9]{3}){1,5}

С дополнительным префиксом:

(?:(?:00|\+)?[0-9]{4})?(?:[ .-][0-9]{3}){1,5}

Если вы хотите сопоставить определенный формат страны, вы можете использовать этот поисковый запрос и добавить страну, вопрос уже задан.

Соответствие IP-адресу

IPv4

Чтобы соответствовать формату адреса IPv4, вам нужно проверить номера [0-9]{1,3} три раза {3} разделенные точками \. и заканчивается другим номером.

^(?:[0-9]{1,3}\.){3}[0-9]{1,3}$

Это регулярное выражение слишком простое - если вы хотите, чтобы он был точным, вам нужно проверить, что числа находятся в диапазоне от 0 до 255 , причем регулярное выражение выше принимает 444 в любой позиции. Вы хотите проверить 250-255 с 25[0-5] или любым другим значением 200 2[0-4][0-9] или любым значением 100 или менее с [01]?[0-9][0-9] . Вы хотите проверить, что за ним следует период \. три раза {3} а затем один раз без периода.

^(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$

IPv6

IPv6 - адрес принимает форму 8 16-битовых слов , разделенных шестигранных с двоеточием ( : ) характером. В этом случае мы проверяем 7 слов, за которыми следуют двоеточия, а затем один, который не является. Если слово имеет ведущие нули, они могут быть усечены, то есть каждое слово может содержать от 1 до 4 шестнадцатеричных цифр.

^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$

Этого, однако, недостаточно. Поскольку адреса IPv6 могут стать довольно «многословными», стандарт указывает, что слова с нулевым значением могут быть заменены на :: . Это может быть сделано только один раз в адресе (где-то между 1 и 7 последовательными словами), поскольку в противном случае это было бы неопределенным. Это приводит к ряду (довольно неприятных) вариаций:

^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$
^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$
^[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:)?[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}::[0-9a-fA-F]{1,4}$
^(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}::$

Теперь, соединяя все вместе (используя чередование), получается:

^(?:[0-9a-fA-F]{1,4}:){7}[0-9a-fA-F]{1,4}$|
^::(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}$|
^[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}$|
^[0-9a-fA-F]{1,4}:[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,3}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:){0,2}[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,4}[0-9a-fA-F]{1,4}::(?:[0-9a-fA-F]{1,4}:)?[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,5}[0-9a-fA-F]{1,4}::[0-9a-fA-F]{1,4}$|
^(?:[0-9a-fA-F]{1,4}:){0,6}[0-9a-fA-F]{1,4}::$

Не забудьте записать его в многострочном режиме и с кучей комментариев, чтобы тот, кому неизбежно поставили задачу выяснить, что это значит, не приходит после вас с тупым объектом.

Подтвердить строчку времени 12 часов и 24 часа

Для формата времени в 12 часов можно использовать:

^(?:0?[0-9]|1[0-2])[-:][0-5][0-9]\s*[ap]m$

куда

• (?:0?[0-9]|1[0-2]) - это час
• [-:] - это разделитель, который можно настроить в соответствии с вашими потребностями
• [0-5][0-9] - это минута
• \s*[ap]m следует за любым количеством пробельных символов, а am или pm

Если вам нужны секунды:

^(?:0?[0-9]|1[0-2])[-:][0-5][0-9][-:][0-5][0-9]\s*[ap]m$

Для 24-часовой формат времени:

^(?:[01][0-9]|2[0-3])[-:h][0-5][0-9]$

Куда:

• (?:[01][0-9]|2[0-3]) - это час
• [-:h] разделитель, который можно настроить в соответствии с вашими потребностями
• [0-5][0-9] - это минута

С секундами:

^(?:[01][0-9]|2[0-3])[-:h][0-5][0-9][-:m][0-5][0-9]$

Где [-:m] - второй разделитель, заменяющий h часами на m за минуты, а [0-5][0-9] является вторым.

Соответствующий британский почтовый индекс

Regex соответствует почтовым индексам в Великобритании.

Формат выглядит следующим образом, где A означает букву и цифру 9:

(GIR 0AA)|((([A-Z-[QVX]][0-9][0-9]?)|(([A-Z-[QVX]][A-Z-[IJZ]][0-9][0-9]?)|(([A-Z-[QVX]][0-9][A-HJKPSTUW])|([A-Z-[QVX]][A-Z-[IJZ]][0-9][ABEHMNPRVWXY])))) [0-9][A-Z-[CIKMOV]]{2})

Где первая часть:

 (GIR 0AA)|((([A-Z-[QVX]][0-9][0-9]?)|(([A-Z-[QVX]][A-Z-[IJZ]][0-9][0-9]?)|(([A-Z-[QVX]][0-9][A-HJKPSTUW])|([A-Z-[QVX]][A-Z-[IJZ]][0-9][ABEHMNPRVWXY]))))

Во-вторых:

[0-9][A-Z-[CIKMOV]]{2})