wwwoldi.ru

About Me

Dashy

Hello word I am dashy Guy

Разное

Регулярные выражения js email: Как проверить адрес email в JavaScript

alexxlab
No Comments

[ 0-9]+$Любое число.[0-9]{6}Почтовый индекс.\d+(,\d{2})?Число в формате 1,34 (разделитель запятая).\d+(\.\d{2})?Число в формате 2.10 (разделитель точка).\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}IP-адрес

Пример

HTML5IECrOpSaFx

<!DOCTYPE html>
<html>
 <head>
  <meta charset="utf-8">
  <title>Атрибут pattern</title>
 </head>
  <body>
   <form>
    <p>Введите телефон в формате 2-xxx-xxx, где вместо x 
    должна быть цифра:</p>
    <p><input type="tel" pattern="2-[0-9]{3}-[0-9]{3}"></p>
    <p><input type="submit" value="Отправить"></p>
   </form>
  </body>
</html>

Содержание

[ELMA3] Пример применения регулярных выражений для строковых полей

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

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

В настройках свойства типа Строка на вкладке Дополнительно есть возможность указать регулярное выражение и сообщение об ошибке.

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

Сообщение об ошибке – текст сообщения, который будет отображаться при вводе строки, не отвечающей требованиям введенного регулярного выражения.

В каждом примере, приведенном ниже, содержится:

‘^’ – начало строки,

‘$’ – конец строки,

‘?’ в ‘()?’ означает, что все, что находится в (), может повторяться 0 или 1 раз. ([1-9]{1}[0-9]{9})?$

Разберем выражение:

  1. [1-9]{1} – указывает на то, что первым символом будет любая цифра, кроме 0.

  2. [0-9]{9} – позволяет ввести 9 цифр.

Пример: 4951234567

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

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

Регулярное выражения для проверки email:

Разберем выражение по частям:

  1. ([a-z0-9_-]+\.)* — позволяет ввести:
    1. в [] указан допустимый диапазон символов: символы латинского алфавита от a до z в нижнем регистре, цифры и символы ‘_’ и ‘-’.

    2. квантор ‘+’ после [] означает, что должен быть введен хотя бы один символ из диапазона, указанного в [].

    3. в выражении ‘\.’ ‘\’ является экранирующим символом, и указывает на то, что ‘.’ является не диапазоном любых символов, а метасимволом (т.е. в конце выражения должна присутствовать точка).

    4. ‘*’ в ‘()*’ означает, что все, что находится в () может повторяться 0 или более раз.

Пример: ivan19.ivanovich.

  1. [a-z0-9_-]+@[a-z0-9-]+ — позволяет ввести:
    1. символы латинского алфавита от a до z в нижнем регистре, цифры и символы ‘_’ и ‘-’.

    2. квантор ‘+’ после [] означает, что должен быть введен хотя бы один символ из диапазона, указанного в [].

    3. символ ‘@’.

    4. символы латинского алфавита от a до z в нижнем регистре, цифры и символ ‘-’.

    5. квантор ‘+’ после [] означает, что должен быть введен хотя бы один символ из диапазона, указанного в [].

Пример: ivanov2000@example_2000

  1. (\.[a-z0-9-]+)* — позволяет ввести:
    1. в выражении ‘\.’ ‘\’ является экранирующим символом, и указывает на то, что ‘.’ является не диапазоном любых символов, а метасимволом (т. .{8,}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$

      пароль (Строчные и прописные латинские буквы, цифры, спецсимволы. Минимум 8 символов)


      Ограничение количества вводимых символов

      Атрибут maxlength устанавливает ограничение на максимальное количество символов, которые можно ввести в поле:


      <input type=»text» maxlength=»любое положительное число»>



      <input type=»text» maxlength=»любое положительное число»>

      Обязательное поле

      Для того чтобы сделать поле обязательным,нужно добавить ему атрибут required. Пока поле с таким атрибутом не заполнено — форма на сервер не отправится:


      <input name=»login» required>



      <input name=»login» required>

      Специальные типы полей

      В HTML5 появились новые типы для полей ввода:


      <input type=»url»>
      <input type=»email»>
      <input type=»tel»>
      <input type=»search»>



      <input type=»url»>

      <input type=»email»>

      <input type=»tel»>

      <input type=»search»>

      Поля url и email осуществляют валидацию в соответствии с предназначением поля.

      Автофокус на поле

      Аттрибут autofocus устанавливает фокус на определенный элемент при загрузке страницы:


      <input autofocus=»autofocus»>



      <input autofocus=»autofocus»>

      Подсказки для текстовых полей

      Используя элемент datalist можно создать текстовое поле с подсказками и автозаполнением. [\d]{1,}$’)

      RegExp = CreateObject(«VBScript.RegExp»)
      RegExp.IgnoreCase = TRUE
      RegExp.Global = TRUE
      RegExp.Pattern = reType.ValueByName(RegExpType)

      if RegExp.Test(InputString)
      Result = TRUE
      else
      Result = FALSE
      endif

      // ———————————
      // проверка корреспондентского счета
      // ———————————
      if Result and RegExpType == ‘корсчет’
      InputString = Replace(InputString; ‘.’; »)
      InputString = Replace(InputString; ‘ ‘; »)
      RegExp.Pattern = reType.ValueByName(‘БИК’)
      // если задан БИК и задан верно
      if not (BIC == ‘000000000’)
      if RegExp.Test(BIC)
      InputString = ‘0’ & Copy(BIC; 5; 2) & InputString
      accountK = ArrayOf(7;1;3;7;1;3;7;1;3;7;1;3;7;1;3;7;1;3;7;1;3;7;1)
      i = 1
      sum = 0
      while i 0
      Result = FALSE
      endif
      else
      Result = FALSE
      endif
      endif
      endif

      // —————————
      // проверка расчетного счета
      // —————————
      if Result and RegExpType == ‘рассчет’
      InputString = Replace(InputString; ‘.’; »)
      InputString = Replace(InputString; ‘ ‘; »)
      RegExp.Pattern = reType.ValueByName(‘БИК’)
      // если задан БИК и задан верно
      if not (BIC == ‘000000000’)
      if RegExp.Test(BIC)
      // Для кредитных учреждений, БИК которых оканчивается на 000 и 001 (РКЦ и ГРКЦ)
      // алгоритм как у корр.счета
      if Copy(BIC; 7; 3) == ‘000’ or Copy(BIC; 7; 3) == ‘001’
      InputString = ‘0’ & Copy(BIC; 5; 2) & InputString
      else
      InputString = Copy(BIC; 7; 3) & InputString
      endif
      accountK = ArrayOf(7;1;3;7;1;3;7;1;3;7;1;3;7;1;3;7;1;3;7;1;3;7;1)
      i = 1
      sum = 0
      while i 0
      Result = FALSE
      endif
      else
      Result = FALSE
      endif
      endif
      endif

      // ———————————
      // проверка контрольного числа ОГРН
      // ———————————
      if Result and RegExpType == ‘ОГРН’
      InputString = Replace(InputString; ‘ ‘; »)
      if Length(InputString) = 13
      Remainder = SQL(‘select ‘ & Copy(InputString; 1; 12) & ‘ % 11’)
      if Remainder > 9
      Remainder = Remainder — 10
      endif
      if Remainder Copy(InputString; 13; 1)
      Result = FALSE
      endif
      else
      Remainder = SQL(‘select ‘ & Copy(InputString; 1; 14) & ‘ % 13’)
      if Remainder > 9
      Remainder = Remainder — 10
      endif
      if Remainder Copy(InputString; 15; 1)
      Result = FALSE
      endif
      endif
      endif

      // ——————————-
      // проверка контрольного числа ИНН
      // ——————————-
      if Result and RegExpType == ‘ИНН’
      kINN10_n1 = ArrayOf(2; 4; 10; 3; 5; 9; 4; 6; 8; 0)
      kINN12_n1 = ArrayOf(3; 7; 2; 4; 10; 3; 5; 9; 4; 6; 8; 0)
      kINN12_n2 = ArrayOf(7; 2; 4; 10; 3; 5; 9; 4; 6; 8; 0; 0)

      // Вычисление контрольных цифр 12-значного ИНН
      if Length(InputString) = 12
      // Вычисление контрольной цифры n2
      i = 1
      sum = 0
      while i Copy(InputString; 11; 1)
      Result = FALSE
      endif
      // Вычисление контрольной цифры n1
      if Result
      i = 1
      sum = 0
      while i Copy(InputString; 12; 1)
      Result = FALSE
      endif
      endif
      // Вычисление контрольных цифр 10-значного ИНН
      else
      // Вычисление контрольной цифры n1
      i = 1
      sum = 0
      while i Copy(InputString; 10; 1)
      Result = FALSE
      endif
      endif
      endif

      // ———————————
      // проверка контрольного числа СНИЛС
      // ———————————
      if Result and RegExpType == ‘СНИЛС’
      InputString = Replace(InputString; ‘-‘; »)
      InputString = Replace(InputString; ‘ ‘; »)
      i = 1
      sum = 0
      while i > ’00’
      Result = FALSE
      endif
      else
      if Remainder Copy(InputString; 10; 2)
      Result = FALSE
      endif
      endif
      endif

      RegExp = nil
      reType = nil

      isMatch. zip (6,63 Кб)

       

      Извлечение адресов электронной почты с использованием регулярных выражений в Python

      Давайте предположим, что вам нужно прочитать некоторые конкретные данные, такие как номера телефонов, адреса электронной почты, даты, набор слов и т. Д. Как вы можете сделать это очень эффективным способом? Лучший способ сделать это с помощью регулярных выражений.

      Давайте возьмем пример, в котором мы должны узнать только электронную почту из заданного ввода регулярным выражением.
      Примеры:

      Input  : Hello [email protected] Rohit [email protected]
Output : [email protected] [email protected]
Here we have only selected email from the given input string.

Input : My 2 favourite numbers are 7 and 10
Output :2 7 10
Here we have selected only digits.

      Регулярное выражение —
      Регулярное выражение — это последовательность символов, в основном используемая для поиска и замены шаблонов в строке или файле.
      Таким образом, мы можем сказать, что задача поиска и извлечения настолько распространена, что в Python есть очень мощная библиотека, называемая регулярными выражениями, которая довольно элегантно выполняет многие из этих задач.

      SymbolUsage
      $Matches the end of the line
      \sMatches whitespace
      \SMatches any non-whitespace character
      * Repeats a character zero or more times
      \SMatches any non-whitespace character
      *? Repeats a character zero or more times (non-greedy)
      +Repeats a character one or more times
      +?Repeats a character one or more times (non-greedy)
      [aeiou]Matches a single character in the listed set
      [^XYZ]Matches a single character not in the listed set
      [a-z0-9]The set of characters can include a range
      (Indicates where string extraction is to start
      )Indicates where string extraction is to end

        

      import re  

        

      s = 'My 2 favourite numbers are 7 and 10'

        

      lst = re. findall('[0-9]+', s)    

        

      print(lst)

      Выход:

      ['2', '7', '10']

        

      import re 

        

      s = 'Hello from [email protected] to [email protected] about the meeting @2PM'

        

      lst = re.findall('\S+@\S+', s)    

        

      print(lst)

      Выход:

      ['[email protected]', '[email protected]']

      Больше подробностей:

      Рекомендуемые посты:

      Извлечение адресов электронной почты с использованием регулярных выражений в Python

      0.00 (0%) 0 votes

      Проверка ввода формы с использованием только HTML5 и Regex

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

      Поскольку проверка важна, имеет смысл наличие инструментов и библиотек для проверки и очистки данных как на переднем, так и на внутреннем уровнях.

      В этом руководстве основное внимание будет уделено использованию встроенных функций HTML5 для проверки различных типов ввода без использования каких-либо внешних библиотек. Очевидно, что вам не следует останавливаться только на проверке на основе HTML5, но это было бы хорошим началом для повышения безопасности форм на веб-сайте.

      Элемент ввода формы

      Всякий раз, когда вы хотите получить какую-то информацию от ваших пользователей, вы, скорее всего, будете использовать элемент input HTML. Неважно, хотите ли вы знать их имя, фамилию, адрес электронной почты, город, в котором они живут в данный момент, номер телефона или любимую спортивную команду. Элемент input — это очень удобный способ получения информации от наших посетителей.

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

      Обе эти проблемы можно легко решить, используя некоторые атрибуты HTML5 с элементами формы.

      Атрибут типа

      Атрибут type будет определять, какой тип ввода считается допустимым для данного элемента. Если для атрибута типа значение не указано, по умолчанию для типа устанавливается text . Это в основном означает, что все виды ввода текста будут считаться действительными для этого конкретного элемента.

      Это хорошо, когда вы хотите, чтобы пользователи вводили свои имена. Однако, когда вы хотите, чтобы они вводили свой адрес электронной почты или номера, такие как их возраст и вес, гораздо лучше установить значение атрибута type на что-то подходящее.

      Вот несколько значений, которые вы можете выбрать:

      • email : это попросит пользователей ввести свой адрес электронной почты в допустимом формате. Например, они не могут просто написать myemail.com или что-то @ или @ кое-что . Им нужно будет ввести значение, аналогичное [email protected] . Конечно, они все еще могут вводить несуществующие электронные письма, но это другая проблема!
      • number : это позволит убедиться, что только цифры считаются допустимыми ввода. Например, когда вы спрашиваете кого-то о его возрасте в форме, он не сможет предоставить данные в виде картофеля или тридцать шесть . Им нужно будет написать фактическое число, например, 36 или 15 .
      • url : Вы можете установить атрибут type в url если хотите, чтобы пользователи вводили действительный URL-адрес в элемент ввода. Это предотвратит их вход в нечто вроде tutsplus . Однако tutsplus.com также будет считаться недействительным — пользователям придется ввести полный URL-адрес, например https://tutsplus.com .
      • tel : использование этого значения не так полезно, как другие, потому что формат телефонного номера варьируется во всем мире. Нет просто никакого стандартного шаблона, который браузеры могли бы сопоставить с вводом, чтобы определить, является ли число действительным. Тем не менее, установка типа tel может быть полезна на более позднем этапе, когда вы делаете свою собственную пользовательскую проверку.

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

      Следующая демонстрационная программа CodePen показывает, как мы можем использовать атрибут type для управления тем, что разрешено в различных полях ввода.

      Атрибуты минимальной и максимальной длины

      Еще один способ ограничить то, что считается допустимым входным элементом для элемента, — это использовать minlength и maxlength . Они устанавливают минимальное и максимальное количество символов, которые необходимо ввести в элемент ввода, чтобы сделать его действительным.

      Правильные значения для обоих этих атрибутов будут варьироваться в зависимости от конкретного случая. Например, некоторые веб-сайты могут хотеть, чтобы имя пользователя было длиной от 4 до 15 символов, в то время как другие могут ограничивать максимальную длину до 12. Аналогично, люди в некоторых странах будут иметь необычно короткие или длинные имена по сравнению с другими.

      Использование регулярных выражений для проверки формы

      Установка значения атрибута type безусловно, помогает нам ограничить то, что считается допустимым вводом. Однако вы можете пойти еще дальше и указать шаблон, которому должны следовать имя пользователя или адрес электронной почты, чтобы считаться действительными.

      Допустим, вы хотите убедиться, что имена пользователей только буквенно-цифровые. Это можно легко сделать с помощью атрибута pattern . Вам просто нужно установить его значение в выражение регулярного выражения, которое будет действовать как ориентир, чтобы определить, какие входные данные действительны, а какие нет.

      Вот несколько примеров использования регулярных выражений с атрибутом pattern .

      1

      <input type=»text» id=»uname» name=»uname» pattern=»[a-zA-Z0-9]+» minlength=»4″ maxlength=»10″>

      Приведенный выше шаблон будет постоянно проверять, что все имена пользователей содержат только символы от az, AZ или 0-9. Например, monty42 , 42monty , MON42ty и mon42ty являются допустимыми именами пользователей в этом случае, но monty_42 недействителен.

      minlength и maxlength гарантируют, что имя пользователя не будет слишком маленьким или слишком большим.

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

      1

      <input type=»text» id=»uname» name=»uname» pattern=»_[a-zA-Z0-9]+» minlength=»4″ maxlength=»10″>

      Теперь каждое имя пользователя, которое не начинается с _ и содержит какие-либо символы, кроме az, AZ или 0-9, после этого будет считаться недействительным.

      Я надеюсь, что это поможет прояснить, как мы можем использовать атрибут pattern и некоторые регулярные выражения для ограничения того, что считается допустимым вводом, даже когда атрибут type установлен в text .

      Расширенная проверка с помощью шаблонов регулярных выражений

      Вы также можете использовать атрибут pattern вместе с другими типами элементов ввода, такими как email и url чтобы ограничить то, что считается допустимым. Например, допустим, вы хотите, чтобы пользователи вводили только URL-адрес, который является поддоменом tutsplus.com . Вы можете просто установить значение атрибута шаблона в https://.*\.tutsplus.com . Теперь любой ввод, такой как https://google.com или https://envato.com, будет считаться недействительным. Даже если вы используете URL-адрес tutsplus.com , начинающийся с https: // , это   будет недействительным, потому что URL должен начинаться с https: // .

      То же самое можно сделать с электронными письмами. Если вы хотите, чтобы электронные письма заканчивались чем-то конкретным, вы можете просто использовать для этого атрибут pattern. Вот пример:

      1

      <input type=»email» id=»email» pattern=».+@tutsplus\.com|.+@envato\.com»>

      Если вышеуказанный элемент ввода используется в форме, пользователи смогут ввести только адрес электронной почты, который заканчивается на tutsplus.com или envato.com . Это означает, что [email protected] или [email protected] будут недействительными.

      Ознакомьтесь с нашей таблицей JavaScript Regex, чтобы узнать больше примеров регулярных выражений и советов по их использованию.

      • Регулярные выражения

        Шпаргалка по регулярным выражениям JavaScript

      Обязательные поля и заполнитель текста

      Хотя required атрибуты и атрибуты- placeholder не обязательно связаны с проверкой, их можно использовать для улучшения взаимодействия с пользователем при заполнении формы.

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

      Вы можете пометить определенные поля ввода как обязательные, используя required атрибут, оставив необязательные поля без изменений. Это позволит пользователям знать абсолютный минимум информации, которую они должны предоставить при заполнении формы. Это также может увеличить количество людей, которые заполняют форму, потому что они будут заранее знать, что заполнение всех полей не является абсолютно необходимым.

      Атрибут placeholder также имеет большое значение для того, чтобы сделать форму более удобной для пользователя. Например, если вы не дадите пользователям знать, что им нужно вводить URL-адреса, начинающиеся с https: // и являющиеся поддоменами tutsplus.com , они могут просто сдаться после неудачной записи поля URL-адреса с кодомthing.com или кодом .tutsplus.com .

      В следующем примере мы использовали атрибуты pattern, required и placeholder для более детального управления проверкой и лучшего взаимодействия с пользователем.

      01

      02

      03

      04

      05

      06

      07

      08

      09

      10

      11

      12

      13

      <form>

        <label for=»name»>Name: *</label>

        <input type=»text» id=»name» name=»name» pattern=»[a-zA-Z]+» placeholder=»Monty» required>

        <br>

        <label for=»name»>Company Email Address: *</label>

        <input type=»email» id=»email» name=»email» placeholder=»joe@company. com» pattern=».+@company\.com» required>

        <br>

        <label for=»name»>Age: </label>

        <input type=»number» id=»age» name=»age» min=»10″ max=»80″ placeholder=»30″>

        <br>

        <label for=»name»>Favorite Tuts+ Website: *</label>

        <input type=»url» id=»website» name=»website» pattern=»https://.*\.tutsplus\.com» placeholder=»https://code.tutsplus.com» required>

      </form>

      Последние мысли

      В этом руководстве мы узнали, как добавить базовую проверку к нашим формам, просто используя HTML и регулярные выражения. Использование правильного значения для атрибута type заставит пользователей вводить информацию в поле ввода в определенном формате. Использование регулярных выражений с атрибутом pattern может помочь нам ограничить допустимый ввод.

      Наконец, мы узнали, как использовать атрибут placeholder чтобы убедиться, что формы, которые мы создаем, удобны для пользователя, и люди, заполняющие информацию, не расстраиваются, потому что они не знают формат ввода, который мы считаем допустимым.

      Проверка формы, конечно, не заканчивается здесь. В следующем уроке вы узнаете о различных событиях форм в jQuery и о том, как проверять формы с помощью плагина jQuery.

      • JavaScript

        Лучшие JavaScript-формы 2019 года

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

      Проверка электронной почты — очень важный момент при проверке HTML-формы. На этой странице мы обсудили, как проверить электронную почту с помощью JavaScript:

      .

      Электронное письмо — это строка (подмножество символов ASCII), разделенная на две части символом @. «personal_info» и домен, то есть personal_info @ domain. Длина части personal_info может составлять до 64 символов, а имя домена — до 253 символов.
      Часть personal_info содержит следующие символы ASCII. _ `{| } ~

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

    Часть имени домена [например, com, org, net, in, us, info] содержит буквы, цифры, дефисы и точки.

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

    [email protected]

    [email protected]

    [email protected]

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

    mysite.ourearth.com [@ нет]

    mysite @ .com.my [tld (домен верхнего уровня) не может начинаться с точки «.» ]

    @ you.me.net [Без символов перед @]

    [email protected] [«.b» не является допустимым tld]

    mysite @ .org.org [tld не может начинаться с точки «.» ]

    .mysite @ mysite.org [письмо не должно начинаться с «.» ]

    mysite () * @ gmail.com [здесь регулярное выражение допускает только
    символ, цифра, подчеркивание и тире]

    mysite.\ [\] \ r \\] | \\.) * \] (?: (?: \ r \ n)? [\ t]) *)) * \> (? 🙁

    ?: \ r \ n)? [\ t]) *)) *)?; \ s *)

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

    Всего несколько дней до открытия 2021 JavaScript Full-Stack Bootcamp .
    Записывайтесь в лист ожидания!

    Проверка адреса электронной почты — одна из распространенных операций, выполняемых при обработке формы.

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

    Некоторые люди предлагают вообще не проверять электронную почту._ {|} ~

  2. точка . , если это не первый или последний символ. Также нельзя повторить

    3. Доменная часть может содержать

    • любые буквенно-цифровые символы: a-zA-Z0-9
    • дефис –, если это не первый или последний символ. Можно повторить

    Использовать регулярное выражение

    Лучший способ проверить адрес электронной почты — использовать регулярное выражение .

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

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

    Я сделал этот пример на Glitch, который проверяет список адресов электронной почты, считающихся действительными, на соответствие регулярному выражению. Вы можете изменить регулярное выражение и сравнить его с другими, которые хотите использовать._` {|} ~ \ u00A0- \ uD7FF \ uF900- \ uFDCF \ uFDF0- \ uFFEF] +) * | «((([\ t] * \ r \ n)? [\ t] +)? ([ \ 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])) * (([\ t] * \ r \ n)? [\ t] +) ? «) @ (([az \ d \ u00A0- \ uD7FF \ uF900- \ uFDCF \ uFDF0- \ uFFEF] | [az \ d \ u00A0- \ uD7FF \ uF900- \ uFDCF \ uFDF0- \ uFFEF] [az \ d \ -._ ~ \ u00A0- \ uD7FF \ uF900- \ uFDCF \ uFDF0- \ uFFEF] * [az \ d \ u00A0- \ uD7FF \ uF900- \ uFDCF \ uFDF0- \ uFFEF]) \.) + ([ az \ u00A0- \ uD7FF \ uF900- \ uFDCF \ uFDF0- \ uFFEF] | [az \ u00A0- \ uD7FF \ uF900- \ uFDCF \ uFDF0- \ uFFEF] [az \ d \ -._ ~ \ u00A0- \ uD7FF \ uF900- \ uFDCF \ uFDF0- \ uFFEF] * [a-z \ u00A0- \ uD7FF \ uF900- \ uFDCF \ uFDF0- \ uFFEF]) \.? $ / i

    return expression.test (String (электронная почта) .toLowerCase ())
    }

    Все распространенные случаи удовлетворены, можно предположить, что 99,9% адресов электронной почты, которые люди будут добавлять, подтверждены успешно.

    Код этого сбоя содержит другие регулярные выражения, которые вы легко можете попробовать, ремиксировав проект.

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

    Ложноотрицательный для странных адресов, например

      "very. (),:; <> []". VERY. "Very @ \" very ".unusual" @ unknown.example.com

one. "more \ long" @ example.website.place

    Ложноотрицательный для локальных адресов:

      админ @ mailserver1
пользователь @ localserver

    малоиспользуемых на общедоступных веб-сайтах (на самом деле плюс на общедоступных веб-сайтах, чтобы те были запрещены)

    Также ложноотрицательный для электронных писем на основе IP:

      пользователь @ [2001: DB8 :: 1]
пользователь @ 128.0.0.1

    Имеется ложное срабатывание для адресов со слишком длинной локальной частью:

      12345678
    45678
    45678
    45678
    45678
    45678
    [email protected]

    Хотите более простое регулярное выражение?

    Вышеупомянутое регулярное выражение очень сложно, до такой степени, что я даже не буду пытаться его понять. Мастера регулярных выражений создали его, и оно распространилось по Интернету, пока я не нашел его.

    Использование его на этом этапе — это вопрос его копирования / вставки.

    Гораздо более простое решение — просто проверить, что введенный адрес содержит что-то, затем символ @ , а затем что-то еще.

    В этом случае это регулярное выражение поможет:

      const выражение = / \ S + @ \ S + /
выражение.test (Строка ('[email protected] '). toLowerCase ())

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

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

    Проверить поле HTML напрямую

    HTML5 предоставил нам тип поля email , поэтому не забывайте, что вы также можете проверять электронные письма, используя это:

    В зависимости от реализации браузера эта проверка также даст разные результаты.

    Этот сбой показывает те же электронные письма, с которыми я тестировал регулярное выражение, и их результат при проверке через HTML-форму.

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

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

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

    Используя Node.js, вы можете повторно использовать код внешнего интерфейса как есть.В этом случае функция, которая проверяет, может работать как на стороне клиента, так и на стороне сервера.

    Вы также можете использовать готовые пакеты, такие как isemail, но и в этом случае результаты могут отличаться. Вот эталон isemail для тех же писем, которые мы использовали выше: https://glitch.com/edit/#!/flavio-email-validation-node-isemail

    Учебный курс 2021 JavaScript Full-Stack Bootcamp начнется в конце марта 2021 года. Не упустите эту возможность, подпишитесь на лист ожидания!

    Больше руководств по js:

    4.1. Проверка адресов электронной почты — Поваренная книга регулярных выражений, 2-е издание [Книга]

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

    [email protected] действительно согласно
    RFC 5322, определяющий синтаксис адресов электронной почты.
    Но это недействительно, если в вашем определении указано, что действительный адрес электронной почты
    адрес — это тот, который принимает почту. Отсутствует домен верхнего уровня asdf .

    Короткий ответ на вопрос о действительности: вы не можете знать
    является ли [email protected] адресом электронной почты
    адрес, который действительно может получать электронную почту, пока вы не попытаетесь отправить электронное письмо на
    Это.И даже тогда вы не можете быть уверены, что отсутствие ответных сигналов
    что домен where.com
    молча отбрасывать почту, отправленную в несуществующие почтовые ящики, или если Джон Доу
    нажмите кнопку «Удалить» на его клавиатуре, или если его спам-фильтр побьет его
    к нему.

    Потому что в конечном итоге вам нужно проверить, существует ли адрес
    отправив на него электронное письмо, вы можете решить использовать более простой или
    более расслабленное регулярное выражение. Разрешение проскальзывать недействительным адресам
    может быть предпочтительнее, чем надоедать людям, блокируя действительные
    адреса.По этой причине вы можете выбрать «простой»
    регулярное выражение. Хотя он, очевидно, позволяет многое,
    адреса электронной почты, такие как # $% @ .- , регулярное выражение выполняется быстро и просто,
    и никогда не заблокирует действующий адрес электронной почты.

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

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

    Наконец, вы должны подумать о том, насколько перспективным вы хотите, чтобы ваш
    регулярное выражение быть.В прошлом имело смысл ограничить
    домен верхнего уровня — только двухбуквенные комбинации для страны
    коды и исчерпывающий список общих доменов верхнего уровня, т. е.
    ‹ com | net | org | mil | edu ›.
    Поскольку новые домены верхнего уровня добавляются постоянно, такие регулярные
    выражения теперь быстро устаревают.

    Синтаксис регулярных выражений

    Регулярные выражения, представленные в этом рецепте, показывают все
    основные части синтаксиса регулярных выражений в действии.Если вы прочитаете
    по этим частям в Главе 2 вы уже можете сделать 90%
    задач, которые лучше всего решаются с помощью регулярных выражений.

    Все регулярные выражения, кроме «простого», требуют
    должна быть включена опция сопоставления без учета регистра. В противном случае только
    Допускаются символы верхнего регистра. Включение этой опции позволяет
    наберите ‹ [A-Z] ›
    вместо ‹ [A-Za-z] ›,
    экономия нескольких нажатий клавиш.

    ‹ \ S › — это
    сокращенный класс символов, как в рецепте 2.3
    объясняет. ‹ \ S › совпадения
    любой символ, не являющийся пробельным. .-] ›. Этот класс
    соответствует символу слова, а также любой из 19 перечисленных знаков препинания
    символы.

    ‹ + › и
    ‹ * ›, когда
    используются вне классов символов, являются квантификаторами. Знак плюс повторяется
    предыдущий токен регулярного выражения один или несколько раз, тогда как звездочка
    повторяет ноль или более раз. В этих регулярных выражениях
    квантифицированный токен обычно представляет собой класс символов, а иногда и группу.
    Следовательно, ‹ [A-Z0-9.-] + ›
    соответствует одной или нескольким буквам, цифрам, точкам и / или дефисам.

    В качестве примера использования группы ‹ (?: [A-Z0-9 -] + \.) + › соответствует одной или нескольким буквам,
    цифры и / или дефисы, за которыми следует одна буквальная точка. Знак плюс
    повторяет эту группу один или несколько раз. Группа должна соответствовать как минимум
    один раз, но может совпадать столько раз, сколько возможно. Рецепт 2.12 объясняет механику знака плюс
    и другие кванторы подробно.

    ‹ (?: ⋯) › не захватывает
    группа.Группа захвата ‹ (⋯) › делает то же самое с очистителем.
    синтаксис, поэтому вы можете заменить ‹ (?: › на
    ‹ (› во всех
    регулярные выражения, которые мы использовали до сих пор, не меняя общих
    результаты матча. Но поскольку мы не заинтересованы в отдельном захвате
    части адреса электронной почты, группа без захвата несколько больше
    эффективен, хотя из-за этого регулярное выражение несколько сложнее
    читать. Рецепт 2. ›и
    ‹ $ › форсировать обычный
    выражение, чтобы найти совпадение в начале и конце текста темы,
    соответственно. Размещение всего регулярного выражения между этими
    фактически требует, чтобы регулярное выражение соответствовало
    весь предмет.

    Это важно при проверке ввода данных пользователем. Ты не хочешь
    принять отбросить базу данных;
     - [email protected] ха-ха! как
    Действующий электронный адрес. ›и‹ $ ›будут соответствовать адресу электронной почты.
    в базе дропов ; -
    LF [email protected] LF ха-ха!     , где LF представляет разрыв строки.

    Чтобы этого избежать, используйте анкеры ‹ \ A › и ‹ \ Z ›
    вместо. Они соответствуют только началу и концу строки,
    независимо от каких-либо вариантов, во всех вариантах, обсуждаемых в этой книге,
    кроме JavaScript. JavaScript вообще не поддерживает ‹ \ A › и ‹ \ Z ›. ›и
    ‹ $ › против ‹ \ A › и ‹ \ Z › применяется ко всем обычным
    выражения, подтверждающие ввод. Их много в этом
    книга. Хотя время от времени мы будем предлагать напоминания, мы не будем
    постоянно повторяйте этот совет или показывайте отдельные решения для
    JavaScript и Ruby для каждого рецепта. Во многих случаях мы
    показать только одно решение, используя курсор и доллар, и указать Ruby как
    совместимый аромат.Если вы используете Ruby, не забудьте использовать ‹ \ A › и ‹ \ Z ›, если вы хотите избежать
    соответствие одной строке в многострочной строке.

    Пошаговое построение регулярного выражения

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

    Сначала загрузите в
    инструмент. В этом случае это будет список действительных адресов электронной почты и
    список недействительных адресов электронной почты.\ S + @ \ S + $ ›уже определяет
    базовая структура адреса электронной почты: локальная часть, знак at и
    доменное имя.

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

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

    Регулярное выражение, о котором я получаю больше всего отзывов, не говоря уже об отчетах об ошибках, вы найдете прямо на главной странице этого сайта: \ b [A-Z0-9 ._% + -] + @ [ A-Z0-9 .-] + \. [AZ] {2,} \ b. Я утверждаю, что это регулярное выражение соответствует любому адресу электронной почты. Большинство отзывов, которые я получаю, опровергают это утверждение, показывая один адрес электронной почты, которому не соответствует это регулярное выражение. Обычно отчет «об ошибке» также включает предложение сделать регулярное выражение «идеальным».

    Как я объясню ниже, мое утверждение справедливо только в том случае, если человек принимает мое определение того, что такое действительный адрес электронной почты, а какой — нет. Если вы хотите использовать другое определение, вам придется адаптировать регулярное выражение. Сопоставление действительного адреса электронной почты — прекрасный пример, показывающий, что (1) перед написанием регулярного выражения вы должны точно знать, что вы пытаетесь сопоставить, а что нет; и (2) часто приходится выбирать между точным и практическим.

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

    Если вы хотите использовать указанное выше регулярное выражение, вам нужно понять две вещи. Во-первых, длинные регулярные выражения затрудняют правильное форматирование абзацев. Поэтому я не включил буквы a-z ни в один из трех классов символов.[A-Z0-9 ._% + -] + @ [A-Z0-9 .-] + \. [A-Z] {2,} $.

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

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

    До того, как ICANN предоставила возможность любой хорошо финансируемой компании создавать собственные домены верхнего уровня, самыми длинными доменами верхнего уровня были редко используемые .museum и.путешествия длиной 6 букв. Наиболее распространенные домены верхнего уровня имели длину 2 буквы для доменов для конкретной страны и 3 или 4 буквы для доменов общего назначения, таких как .com и .info. Многие регулярные выражения для проверки адресов электронной почты, которые вы найдете в различных руководствах и справочниках по регулярным выражениям, по-прежнему предполагают, что домен верхнего уровня довольно короткий. В более ранних версиях этого руководства по регулярным выражениям в качестве регулярного выражения для электронной почты упоминалось \ b [A-Z0-9 ._% + -] + @ [A-Z0-9 .-] + \. [AZ] {2,4} \ b. обращается во введении. Есть только одно небольшое различие между этим регулярным выражением и тем, что в верхней части этой страницы.[A-Z0-9 ._% + -] + @ [A-Z0-9 .-] + \. [A-Z] {2,63} $ — это так далеко, насколько вы практически можете зайти. Каждая часть доменного имени не может быть длиннее 63 символов. Нет однозначных доменов верхнего уровня и ни один из них не содержит цифр. Не похоже, что ICANN одобрит такие домены.

    Адреса электронной почты могут находиться на серверах в субдомене, например, [email protected]. Все вышеперечисленные регулярные выражения соответствуют этому адресу электронной почты, потому что я включил точку в классе символов после символа @. Но приведенные выше регулярные выражения также соответствуют john @ aol.[A-Z0-9 ._% + -] {1,64} @ (?: [A-Z0-9 -] {1,63} \.) {1,125} [AZ] {2,63} $ дублей примите во внимание, что локальная часть (перед @) ограничена 64 символами и что каждая часть имени домена ограничена 63 символами. Нет прямого ограничения на количество субдоменов. Но максимальная длина адреса электронной почты, который может обрабатывать SMTP, составляет 254 символа. Таким образом, для односимвольной локальной части, двухбуквенного домена верхнего уровня и односимвольных субдоменов 125 — это максимальное количество субдоменов.

    Предыдущее регулярное выражение фактически не ограничивало адреса электронной почты 254 символами.Если каждая часть имеет максимальную длину, регулярное выражение может соответствовать строкам длиной до 8129 символов. Вы можете уменьшить это, уменьшив количество разрешенных субдоменов со 125 до более реалистичного, например 8. Я никогда не видел адреса электронной почты с более чем четырьмя субдоменами. Если вы хотите установить ограничение в 254 символа, лучшим решением будет проверить длину входной строки, прежде чем вы даже используете регулярное выражение. Хотя для этого требуется несколько строк процедурного кода, проверка длины строки происходит практически мгновенно.(? = [A-Z0-9 @ ._% + -] {6,254} $) [A-Z0-9 ._% + -] {1,64} @ (?: [A-Z0-9-] {1,63} \.) {1,8} [AZ] {2,63} $ использует просмотр вперед, чтобы сначала проверить, что строка не содержит недопустимые символы, не слишком ли короткая или слишком длинная. Когда просмотр вперед завершается успешно, оставшаяся часть регулярного выражения выполняет второй проход по строке, чтобы проверить правильность размещения знака @ и точек.

    Все эти регулярные выражения позволяют использовать символы . [A-Z0-9] [A-Z0-9.(? = [A-Z0-9] [A-Z0-9 @ ._% + -] {5,253} $)
    [A-Z0-9 ._% + -] {1,64} @ (?: [A-Z0-9 -] {1,63} \.) {1,8} [AZ] {2,63} $

    Доменные имена могут содержать дефисы. Но они не могут начинаться или заканчиваться дефисом. [A-Z0-9] (?: [A-Z0-9 -] {0,62} [A-Z0-9])? соответствует доменному имени длиной от 1 до 63 символов, которое начинается и заканчивается буквой или цифрой. Группа без захвата делает середину домена и последнюю букву или цифру необязательными в целом, чтобы гарантировать, что мы разрешаем односимвольные домены, в то же время гарантируя, что домены с двумя или более символами не заканчиваются дефисом.[A-Z0-9] [A-Z0-9 ._% + -] {0,63} @
    (?: [A-Z0-9] (?: [A-Z0-9 -] {0, 62} [A-Z0-9])? \.) {1,8} [AZ] {2,63} $

    Доменные имена не могут содержать последовательные дефисы. [A-Z0-9] + (?: — [A-Z0-9] +) * соответствует имени домена, которое начинается и заканчивается буквой или цифрой и содержит любое количество непоследовательных дефисов. Это наиболее эффективный способ. Это регулярное выражение не выполняет никакого поиска с возвратом для соответствия действительному доменному имени. Он соответствует всем буквам и цифрам в начале имени домена. Если дефисов нет, необязательная группа, следующая за ней, сразу же не работает.Если есть дефисы, группа соответствует каждому дефису, за которым следуют все буквы и цифры до следующего дефиса или конца имени домена. Мы не можем установить максимальную длину, когда дефисы должны сочетаться с буквой или цифрой, но буквы и цифры могут стоять сами по себе. Но мы можем использовать технику просмотра вперед, которую мы использовали для обеспечения общей длины адреса электронной почты, чтобы обеспечить длину имени домена, не допуская последовательных дефисов: (? = [A-Z0-9 -] {1,63} \. ) [A-Z0-9] + (?: — [A-Z0-9] +) *.(? = [A-Z0-9] [A-Z0-9 @ ._% + -] {5,253} $) [A-Z0-9 ._% + -] {1,64} @
    (?: (? = [A-Z0-9 -] {1,63} \.) [A-Z0-9] + (?: — [A-Z0-9] +) * \.) {1,8} [ AZ] {2,63} $

    На современном ПК или сервере это регулярное выражение отлично работает при проверке одного 254-значного адреса электронной почты. Отклонение более длинного ввода будет даже быстрее, потому что регулярное выражение не сработает, если упреждающий просмотр не удастся во время первого прохода. Но я бы не рекомендовал использовать такое сложное регулярное выражение для поиска адресов электронной почты в большом архиве документов или переписки.Лучше использовать простое регулярное выражение в верхней части этой страницы, чтобы быстро собрать все, что похоже на адрес электронной почты. Дедублируйте результаты, а затем используйте более строгое регулярное выражение, если вы хотите дополнительно отфильтровать недопустимые адреса.

    И, говоря об обратном отслеживании, ни одно из регулярных выражений на этой странице не выполняет обратного отслеживания для сопоставления действительных адресов электронной почты. Но, в частности, последние могут изрядно вернуться к тому, что не совсем верный адрес электронной почты. Если ваш вариант регулярного выражения поддерживает притяжательные квантификаторы, вы можете исключить любой возврат с возвратом, сделав все кванторы притяжательными.(? = [A-Z0-9] [A-Z0-9 @ ._% + -] {5,253} + $) [A-Z0-9 ._% + -] {1,64} + @
    ( ?: (? = [A-Z0-9 -] {1,63} + \.) [A-Z0-9] ++ (?: — [A-Z0-9] ++) * + \.) {1,8} + [AZ] {2,63} + $

    Важным компромиссом во всех этих регулярных выражениях является то, что они допускают только английские буквы, цифры и наиболее часто используемые специальные символы. Основная причина в том, что я не верю, что все мои почтовые программы способны справиться с остальным. Несмотря на то, что John.O’[email protected] является синтаксически допустимым адресом электронной почты, существует риск того, что какое-то программное обеспечение неверно интерпретирует апостроф как ограничивающую цитату.Например, слепая вставка этого адреса электронной почты в SQL-запрос в лучшем случае приведет к его сбою, когда строки разделены одинарными кавычками, а в худшем — откроет ваш сайт для атак с использованием SQL-инъекций.

    И, конечно же, уже много лет доменные имена могут содержать неанглийские символы. Но большая часть программного обеспечения по-прежнему придерживается 37 символов, к которым привыкли западные программисты. Поддержка интернационализированных доменов открывает множество червей в отношении того, как должны кодироваться символы, отличные от ASCII.Поэтому, если вы используете какое-либо из регулярных выражений на этой странице, кому-то с адресом @ ที เอ ช นิ ค. Не повезет. Но, возможно, это говорит о том, что http: // ที เอ ช นิ ค. ไทย просто перенаправляет на http://thnic.co.th, даже если они занимаются продажей доменов..

    Вывод таков: чтобы решить, какое регулярное выражение использовать, пытаетесь ли вы сопоставить адрес электронной почты или что-то еще, что неопределенно определено, вам нужно начать с рассмотрения всех компромиссов. Насколько плохо сопоставить что-то недействительное? Насколько плохо не совпадать с чем-то действительным? Насколько сложным может быть ваше регулярное выражение? Насколько дорого было бы, если бы вам пришлось изменить регулярное выражение позже, потому что оно оказалось слишком широким или слишком узким? Для разных ответов на эти вопросы потребуется другое регулярное выражение в качестве решения.Регулярное выражение моей электронной почты делает то, что я хочу, но может не делать того, что вы хотите.

    Регулярные выражения не отправлять электронную почту

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

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

    Официальный стандарт: RFC 5322

    Может быть, вам интересно, почему нет «официального» надежного регулярного выражения для сопоставления адресов электронной почты. Что ж, есть официальное определение, но вряд ли оно надежное.

    Официальный стандарт известен как RFC 5322. Он описывает синтаксис, которому должны соответствовать действующие адреса электронной почты. Вы можете (но не должны — читайте дальше) реализовать его с помощью следующего регулярного выражения._ ‘{|} ~ -] +) *
    | «(?: [\ x01- \ x08 \ x0b \ x0c \ x0e- \ x1f \ x21 \ x23- \ x5b \ x5d- \ x7f]
    | \\ [\ x01- \ x09 \ x0b \ x0c \ x0e- \ x7f]) * «)
    @ (?: (?: [a-z0-9] (?: [a-z0-9 -] * [a-z0-9])? \.) + [a-z0 -9] (?: [A-z0-9 -] * [a-z0-9])?
    | \ [(? 🙁 ?: 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]? | [A-z0-9 -] * [a-z0-9]:
    (?: [\ X01- \ x08 \ x0b \ x0c \ x0e- \ x1f \ x21- \ x5a \ x53- \ x7f]
    | \\ [\ x01- \ x09 \ x0b \ x0c \ x0e- \ x7f]) +)
    \]) \ z

    Это регулярное выражение состоит из двух частей: части перед @ и часть после @.Для части перед @ есть два альтернативных варианта. Первая альтернатива позволяет ему состоять из серии букв, цифр и определенных символов, включая одну или несколько точек. Однако точки могут не появляться последовательно или в начале или в конце адреса электронной почты. Другой вариант требует, чтобы часть перед @ была заключена в двойные кавычки, что позволяет использовать любую строку символов ASCII между кавычками. Пробелы, двойные кавычки и обратная косая черта должны быть экранированы обратной косой чертой.

    Часть после @ также имеет две альтернативы.Это может быть либо полное доменное имя (например, regular-expressions.info), либо буквальный интернет-адрес в квадратных скобках. Буквальный адрес в Интернете может быть либо IP-адресом, либо адресом маршрутизации для конкретного домена.

    Причина, по которой вы не должны использовать это регулярное выражение, заключается в том, что оно слишком широкое. Ваше приложение может не обрабатывать все адреса электронной почты, которые позволяет это регулярное выражение. Адреса маршрутизации, зависящие от домена, могут содержать непечатаемые управляющие символы ASCII, что может вызвать проблемы, если вашему приложению необходимо отображать адреса._ ‘{|} ~ -] +) * @
    (?: [A-z0-9] (?: [A-z0-9 -] * [a-z0-9])? \.) + [A -z0-9] (?: [a-z0-9 -] * [a-z0-9])? \ z

    Ни одно из этих регулярных выражений не ограничивает длину общего адреса электронной почты, локальной части или доменных имен. . RFC 5322 не устанавливает никаких ограничений по длине. Это связано с ограничениями других протоколов, таких как протокол SMTP для фактической отправки электронной почты. RFC 1035 утверждает, что домены должны состоять из 63 символов или меньше, но не включает это в свою спецификацию синтаксиса. Причина в том, что настоящий регулярный язык не может одновременно устанавливать ограничение длины и запрещать следующие друг за другом дефисы._ ‘{|} ~ -] +) *
    @ (?: (? = [A-z0-9 -] {1,63} \.) [A-z0-9] (?: [A-z0- 9 -] * [a-z0-9])? \.) +
    (? = [A-z0-9 -] {1,63} \ z) [a-z0-9] (?: [A- z0-9 -] * [a-z0-9])? \ z

    Таким образом, даже если следовать официальным стандартам, все равно придется идти на компромиссы. Не копируйте слепо регулярные выражения из онлайн-библиотек или дискуссионных форумов. Всегда проверяйте их на своих данных и в собственных приложениях.

    Сделайте пожертвование

    Этот веб-сайт только что сэкономил вам поездку в книжный магазин? Сделайте пожертвование на поддержку этого сайта, и вы получите неограниченного доступа к этому сайту без рекламы!

    Соответствие адресу электронной почты — тестер / отладчик регулярных выражений

    Классы символов
    .abc $ начало / конец строки
    \ b граница слова
    Экранированные символы
    \. \ * \\ экранированных специальных символов
    \ t \ n \ r табуляция, перевод строки, возврат каретки
    \ u00A9 экранированный код Юникода ©
    Группы и поиск
    (abc) группа захвата
    \ 1 обратная ссылка на группу №1
    (?: Abc) группа без захвата
    (? = Abc) положительный прогноз
    (?! Abc) негативный прогноз
    Квантификаторы и чередование
    а * а + а? 0 или более, 1 или более, 0 или 1
    а {5} а {2,} ровно пять, два или больше
    a {1,3} между одним и тремя
    а +? а {2,}? совпадений как можно меньше
    ab | cd соответствует ab или cd

    Regex в JS — как ВЫ можете изучить его и научиться любить его

    Я пишу это себе в будущем.Фактически, многие мои статьи предназначены для моего будущего, которое забыло все о том, как что-то делать. RegEx, регулярные выражения — действительно мощный инструмент в нашем наборе инструментов. К сожалению, мы называем это черной магией, дьяволом и прочими очаровательными вещами. Так не должно быть. RegEx, безусловно, отличается от обычного программирования, но это также действительно мощное средство. Давайте узнаем, как это работает и как на самом деле использовать его и применять к повседневным проблемам, которые вы узнаете.

    TLDR; Это долго? Да, но он проходит через основные конструкции в RegEx.Кроме того, в конце у меня есть несколько хороших рецептов о том, как делать такие вещи, как RegEx для электронной почты, пароли, преобразование формата даты и как обрабатывать URL-адреса. Если вы никогда раньше не работали с RegEx или изо всех сил пытаетесь разглядеть всю эту странную магию — это для вас. Приятного чтения 😃

    Ссылки

    Есть несколько отличных ресурсов по RegEx, к которым я регулярно обращаюсь. Найдите время, чтобы прочитать их. Иногда они объясняют, как обрабатывается RegEx, и могут объяснить, почему происходит волшебство :

    Как практиковать

    • Node.js REPL , если у вас установлен Node.js, я рекомендую просто набрать node в терминале. Это запустит REPL, это отличный способ проверить шаблоны

    • JavaScript REPL , это расширение VS Code, которое оценивает то, что вы вводите. Вы получите мгновенную обратную связь о результатах.

    • Браузер , запуск инструментов разработчика в браузере и использование консоли также будет работать нормально

    • RegEx 101
      Отличная песочница.Спасибо за подсказку Лукаш 😃

    Регулярные выражения

    Регулярные выражения или RegEx предназначены для сопоставления с образцом. Если задуматься, многое из того, что мы делаем, действительно связано с сопоставлением с образцом. RegEx действительно хорош в сопоставлении шаблонов и извлечении значений из найденных шаблонов. Итак, какие проблемы мы можем решить?

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

    Регулярное выражение создается либо следующим образом:

    Оно начинается и заканчивается на /.

    Или вот так, где мы создаем объект из класса RegEx :

    Методы

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

    • exec () , Выполняет поиск совпадения в строке.Он возвращает массив информации или null при несоответствии.
    • test () , проверяет соответствие в строке, отвечает с true или false
    • match () , возвращает массив, содержащий все совпадения, включая группы захвата, или null , если совпадений не найдено.
    • matchAll () , возвращает итератор, содержащий все совпадения, включая группы захвата.
    • search () , Проверяет соответствие в строке.Он возвращает индекс совпадения или -1, если поиск не удался.
    • replace () , Выполняет поиск совпадения в строке и заменяет совпавшую подстроку замещающей подстрокой.
    • split () , использует регулярное выражение или фиксированную строку для разбиения строки на массив подстрок.

    Приведем несколько примеров приведенных выше методов.

    test () , тестовая строка для истинности / ложности

    Давайте посмотрим на пример с использованием test () :

    Выше мы тестируем строку abc123 для всех буквенных символов \ w + , и мы отвечая на вопрос, есть ли у вас буквенные символы.

    match () , найти совпадения

    Давайте посмотрим на пример:

      'orders / items'.match (/ \ w + /)

    1

    Приведенный выше ответ массива сообщает нам, что мы можем сопоставить заказов с нашим шаблоном \ w + . Мы не захватили никакие группы, как указано в группах: undefined , и наше совпадение было найдено по индексу : 0 . Если бы мы хотели сопоставить все буквенные символы в строке, нам потребовалось бы использовать флаг g . g указывает глобальное совпадение , например:

      'orders / items'.match (/ \ w + / g)

    1

    Группы

    У нас также есть понятие групп. Чтобы начать использовать группы, нам нужно заключить наш шаблон в круглые скобки следующим образом:

      const matchedGroup = 'orders / 114'.match (/ (?  \ d +) /)

    1

    Использование конструкции ? создает так называемую именованную группу.

    Флаги

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

      var re = / pattern / flags;

    1

    • g , вы говорите, что хотите сопоставить всю строку, а не только первое вхождение
    • i , это означает, что нам нужно сопоставление без учета регистра

    Утверждения

    Существуют разные типы утверждений:

    • Граница , это для сопоставления вещей в начале и конце слова
    • Другие утверждения , здесь мы говорим о взглядах вперед, взглядах назад и условных утверждениях

    Давайте рассмотрим несколько примеров:

      / ^ test /. слово  тест . 
     
     Обратное будет выглядеть так: 
     
      /test$/.test('123test ')
  
     1
     Классы символов 
     Классы символов относятся к различным типам символов, таким как буквы и цифры. Перечислим некоторые из них:
    •  . , соответствует любому одиночному символу, кроме разделителей строки, например  \ n  или  \ r 
    •   \ d , соответствует цифрам, эквивалентно  [0-9] 
    •   \ D , это отрицание соответствия цифры.[0-9] 
    •   \ w , соответствует любому буквенному символу, включая  _ . Эквивалент  [a-zA-Z0-9_] 
    •   \ W , что является отрицанием вышеизложенного. Соответствует % , например
    •   \ s , соответствует пробелам
    •   \ t , соответствует табуляции
    •   \ r , соответствует возврату каретки
    •   \ n , соответствует переводу строки
    •   \ , escape-символ.Его можно использовать для сопоставления /, например /. Также используется для придания символам особого значения
     Квантификаторы 
     Квантификаторы - это количество символов для сопоставления:
    •   * , от 0 до многих символов
    •   + , от 1 до многих символов
    •   {n} , соответствие n символов
    •   {n,} , соответствие> = n символов
    •   {n, m} , соответствие> = n && = 
    •  ? , нежадное сопоставление
     Давайте рассмотрим несколько примеров
      / \ w * /.тест ('abc123')
/ \ w * /. тест ('')
  
     1 
     2
     В следующем примере мы используем ? :
      /\/products\/?/.test('/products ')
/\/products\/?/.test('/products/ ')
  
     1 
     2
     Выше мы видим, как используется ?  делает окончание / необязательным, когда мы используем этот тип сопоставления  \ /? .
     DEMO 
     Хорошо, это много теории, смешанной с некоторыми примерами.Давайте теперь посмотрим на некоторые реалистичные сопоставления, сопоставления, которые мы действительно будем использовать в производстве.
     Если вы используете JavaScript на бэкэнде, вы, вероятно, уже пользуетесь фреймворками вроде Express, Koa или, возможно, Nest.js. Знаете ли вы, что эти фреймворки делают для вас с точки зрения сопоставления маршрутов, параметров и многого другого? Что ж, пора узнать.
     Сопоставление маршрута 
     Такой простой маршрут, как  / продукты , как нам сопоставить его ?. Что ж, мы знаем, что наш URL-адрес должен содержать эту часть, поэтому написать для этого RegEx довольно просто.Давайте также учтем, что некоторые будут вводить  / products , а некоторые другие будут вводить  / products / :
      /\products\/?$/.test('/products ')
  
     1
     Приведенный выше RegEx удовлетворяет все наши потребности от сопоставления / с  \ /  до сопоставления необязательного / в конце с  \ /? .
     Хорошо, возьмем аналогичный случай.  / продукты / 112 . Маршрут  / товары  с номером в конце.Начнем смотреть, совпадает ли входящий маршрут:
      /\/products\/\d+$/.test('/products/112 ')
/\/products\/\d+$/.test('/products/ ')
  
     1 
     2
     Чтобы извлечь параметр маршрута, мы можем ввести следующее:
      const [, productId] = '/products/112'.match(/\/products\/(\d+)/)

  
     1 
     2
     Хорошо, допустим, у вас есть такой маршрут  / orders / 113 / items / 55 . Это примерно соответствует порядку с идентификатором  113  и идентификатором позиции заказа  55 .Сначала мы хотим убедиться, что наш входящий URL-адрес совпадает, поэтому давайте посмотрим на RegEx для этого:
      /\orders\/\d+\/items\/\d+\/?/.test('/orders/99/items / 22 ')
  
     1
     Приведенное выше RegEx читается следующим образом: соответствие  / orders / [1-n цифр] / items / [1-n цифр] [необязательно /] 
     Теперь мы знаем, что можем сопоставить вышеуказанный маршрут. Давайте теперь возьмем эти параметры. Мы можем сделать это с помощью именованных групп:
      var {groups: {orderId, itemId}} = '/ orders / 99 / items / 22'.совпадение (/ (?  \ d +) \ / items \ / (?  \ d +) \ /? /)


  
     1 
     2 
     3
     Вышеупомянутое выражение вводит группы путем создания именованных групп  orderId  и  itemId  с конструкциями  (?  \ d +)  и  (?  \ d +)  соответственно. Шаблон очень похож на тот, который используется в методе  test () .
     Классификатор маршрутов 
     Я уверен, что вы видели, как маршрут был разделен на несколько частей, таких как протокол  , хост  , маршрут  , порт   и параметры запроса  .
     Это довольно просто сделать. Предположим, мы смотрим на URL-адрес вида  http: // localhost: 8000 / products? Page = 1 & pageSize = 20 . Мы хотим проанализировать этот URL и в идеале получить что-нибудь приятное для работы, например:
      {
  протокол: 'http',
  хост: 'localhost',
  маршрут: '/ products? page = 1 & pageSize = 20',
  порт: 8000
}
  
     1 
     2 
     3 
     4 
     5 
     6
     Как мы туда попали? Что ж, то, что вы видите, следует очень предсказуемому шаблону, и RegEx - это  Mjolnir из Hammers , когда дело доходит до сопоставления с образцом.Давайте сделаем это 😃
      var http = 'http: // localhost: 8000 / products? Page = 1 & pageSize = 20'
.match (/ (? <протокол> \ w +): \ / {2} (?  \ w +) :(?  \ d +) (? . *) /)


  
     1 
     2 
     3 
     4
     Давайте разберем вышеприведенное:
    •   (?  \ w +): , это соответствует количеству n буквенных символов, которые заканчиваются на : . Кроме того, он помещается в протокол именованной группы  
    •   \ / {2} , это просто говорит о том, что у нас есть  // , обычно после  http: // .
    •   (?  \ w +): , это соответствует количеству n буквенных символов, которое заканчивается на : , поэтому в этом случае он соответствует  localhost . Кроме того, он помещается в именованную группу  host .
    •   (?  \ d +) , это соответствует некоторым цифрам, которые следуют после хоста, который будет портом. Кроме того, он помещается в названную группу  порт .
    •   (? . *) , наконец, у нас есть сопоставление маршрутов, которое соответствует любым символам, что гарантирует получение части ? Page = 1 & pageSize = 20 .Кроме того, он помещается в названную группу , маршрут .
     Для анализа параметров запроса нам просто нужен RegEx и один вызов  reduce () , например:
      const queryMatches = http.groups.route.match (/ (\ w + = \ w +) / грамм)
const queryParams = queryMatches.reduce ((acc, curr) => {
  const [ключ, значение] = curr.split ('=')
  arr [... arr, [ключ]: значение]
}, {})

  
     1 
     2 
     3 
     4 
     5 
     6
     Выше мы работаем с ответом от нашего первого сопоставления с образцом  http.группы. маршрут . Сейчас мы создаем шаблон, который будет соответствовать следующему  [любой алфавитный символ] = [любой алфавитный символ] . Кроме того, поскольку у нас есть глобальное совпадение  g , мы получаем массив ответов. Это соответствует всем параметрам нашего запроса. Наконец, мы вызываем  reduce ()  и превращаем массив в объект.
     Сложность пароля 
     Сложность пароля заключается в том, что он имеет разные критерии, например:
    •   длина , он должен быть более n символов и, возможно, менее m символов
    •   чисел , должен содержать число
    •   специальный символ , должен содержать специальные символы
     Тогда ли мы в безопасности? Что ж, безопаснее, не забывайте 2FA в приложении, а не на своем номере телефона.
     Давайте посмотрим на RegEx для этого:
     
вар pwd = /\d+/.test('password1 ')


var pwdNCharacters = /\w{8,}/.test('password1 ')


var specialCharacters = /&|\?|\!|\-+/.test('password1- ')

  
     1 
     2 
     3 
     4 
     5 
     6 
     7 
     8 
     9
     Как вы можете видеть, я конструирую каждое требование как собственное сопоставление с образцом. Вам необходимо пройти свой пароль через каждое сопоставление, чтобы убедиться, что он действителен.
     Идеальная дата 
     На моей нынешней работе я сталкиваюсь с коллегами, которые все думают, что их формат даты - это то, что должны использовать все мы.В настоящее время это означает, что моему бедному мозгу приходится иметь дело с:
     Итак, вы можете себе представить, что мне нужно знать национальность того, кто отправил мне электронное письмо, каждый раз, когда я получаю электронное письмо с датой в нем. Это больно 😃. Итак, давайте создадим RegEx, чтобы мы могли легко поменять его местами по мере необходимости.
     Допустим, мы получили дату в США, например,  ММ / ДД / ГГ . Мы хотим извлечь важные части и поменять местами дату, чтобы кто-то из европейцев или британцев мог это понять. Предположим также, что приведенные ниже данные являются американскими:
      var toBritish = '12 / 22/20 '.replace (/ (? <месяц> \ d {2}) \ / (? <день> \ d {2}) \ / (? <год> \ d {2}) /, '$ 2 / $ 1 / $ 3')
var toEuropeanISO = '12 /22/20'.replace (/ (?  \ d {2}) \ / (?  \ d {2}) \ / (?  \ d {2} ) /, '3 доллара США / 1 доллар США / 2 доллара США')
  
     1 
     2
     Выше мы можем это сделать. В нашем первом параметре для  replace ()  мы даем ему наш RegEx. Наш второй параметр - это то, как мы хотим его поменять местами. Для британского свидания мы просто меняем месяц и день, и все довольны. Для европейской даты нам нужно сделать немного больше, так как мы хотим, чтобы она начиналась с года, за которым следовали месяц, а затем день.
     Электронная почта 
     Хорошо, поэтому для электронной почты нам нужно подумать о нескольких вещах
    •   @ , должен иметь символ  @  где-то посередине
    •   имя , люди могут иметь длинные имена, с и без тире / дефиса. Это означает, что людям можно звонить:  на ,  на альбин  и так далее
    •   фамилия , им нужна фамилия или адрес электронной почты - это просто фамилия или имя
    •   домен , нам нужно внести в белый список несколько доменов, например ., это означает, что он начинается с.
    •   (\ w + \ -? \ W + \.) * , это означает слово с нашим без -, так как у нас есть шаблон  -?  и заканчивая . , т. Е.  пер. ,  на альбин. . Кроме того, мы заканчиваем на  * , так что 0 для многих из них.
    •   (\ w +) {1} , это означает ровно одно слово, такое как электронное письмо, состоящее только из фамилии или только имени. Это открывается для комбинации 1) + 2), так что  на альбина.hansson  или  per.hansson  или 2) отдельно, что соответствует или  hansson .
    •   @ , нам нужно сопоставить один символ  @ 
    •   \ w + \. , здесь мы сопоставляем имя, которое заканчивается на., Например  sweden. 
    •   (\ w + \.) * , здесь мы открываем несколько поддоменов или никого, учитывая  * , например sthlm.region. и т. д.
    •   (edu | gov | com) , доменное имя, здесь мы перечисляем разрешенные домены:  edu ,  gov  или  com 
    •   $ , нужно закончить, это означает, что мы убедитесь, что кто-то не вводит какую-то чушь после доменного имени

Резюме

Здесь вы все прошли.Мы действительно много говорили по теме RegEx.

No related posts.

Share :

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *