Email validation error

Время прочтения
5 мин

Просмотры 118K

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

Если вы знаете, как валидировать email-адрес, поднимите руку. Те из вас, кто поднял руку — опустите её немедленно, пока вас кто-нибудь не увидел: это достаточно глупо — сидеть в одиночестве за клавиатурой с поднятой рукой; я говорил в переносном смысле.

До вчерашнего дня я бы тоже поднял руку (в переносном смысле). Мне нужно было проверить валидность email-адреса на сервере. Я это уже делал несколько сот тысяч раз (не шучу — я считал) при помощи классного регулярного выражения из моей личной библиотеки.

В этот раз меня почему-то потянуло ещё раз осмыслить мои предположения. Я никогда не читал (и даже не пролистывал) RFC по email-адресам. Я попросту основывал мою реализацию на основе того, что я подразумевал под корректным email-адресом. Ну, вы в курсе, что обычно говорят о том, кто подразумевает. [прим. перев. Автор имеет в виду игру слов: «when you assume, you make an ass out of you and me» — «когда вы (что-то) подразумеваете, вы делаете /./удака из себя и из меня»]

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

Оказывается, что локальная часть email-адреса — то, что перед знаком «@» — допускает гораздо более широкое разнообразие символов, чем вы думаете. Согласно разделу 2.3.10 RFC 2821, который определяет SMTP, часть перед знаком «@» называется локальной частью (часть после знака — это домен получателя) и предназначена для интерпретации исключительно сервером получателя.

Следовательно — и благодаря длинной череде проблем, вызванных промежуточными хостами, пытавшимися оптимизировать передачу путём изменения их [адресов — перев.], локальная часть ДОЛЖНА быть интерпретирована (и ей должен быть назначен семантический смысл) исключительно сервером, указанным в доменной части адреса.

Раздел 3.4.1 RFC 2822 описывает дополнительные детали спецификации email-адреса (выделено мной — авт.).

Адресная спецификация представляет собой определённый идентификатор в сети Internet, содержащий локально интерпретируемую строку, за которой следует знак «эт» («@», ASCII-код 64), за которым, в свою очередь, следует домен сети Internet. Локально интерпретируемая строка представляет собой либо обрамлённую кавычками строку, либо точечный атом.

Точечный атом — это набор атомов, разделённых точками. В свою очередь, атом определён в разделе 3.2.4 как набор алфавитно-цифровых символов и может включать в себя любые из нижеследующих символов (знаете, те самые, которыми обычно заменяют мат)…

! $ & * - = ^ ` | ~ # % ' + / ? _ { }

Более того, вполне допустимо (хотя не рекомендуется и редко где применяется) иметь закавыченные локальные части, в которых допустимы почти любые символы. Закавычивание может производится либо при помощи символа обратной черты, либо путём обрамления локальной части двойными кавычками.

RFC 3696, Application Techniques for Checking and Transformation of Names, был написан автором протокола SMTP (RFC 2821) как человекочитаемое руководство по эксплуатации SMTP. В третьем разделе он приводит примеры корректных email-адресов.

Это таки корректные email-адреса!

• "Abc@def"@example.com
• "Fred Bloggs"@example.com
• "Joe\Blow"@example.com
• "Abc@def"@example.com
• customer/department=shipping@example.com
• $A12345@example.com
• !def!xyz%abc@example.com
• _somename@example.com

(Аплодисменты автору RFC за использование моей любимой версии Васи Пупкина — Joe Blow.)

Ну-ка, прогоните их через ваш любимый валидатор. Ну как, много прошло?

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

^(?!.)("([^"r\]|\["r\])*"|([-a-z0-9!#$%&'*+/=?^_`{|}~] |(?@[a-z0-9][w.-]*[a-z0-9].[a-z][a-z.]*[a-z]$

Учтите, что это выражение подразумевает, что чувствительность к регистру выключена (RegexOptions.IgnoreCase в .NET). Согласен, весьма уродливое выражение.

Я написал юнит-тест, чтобы продемонстрировать все случаи, которые оно покрывает. Каждая строка содержит email-адрес и флаг — является он корректным или нет.

[RowTest]
[Row(@"NotAnEmail", false)]
[Row(@"@NotAnEmail", false)]
[Row(@"""test\blah""@example.com", true)]
[Row(@"""testblah""@example.com", false)]
[Row(""test\rblah"@example.com", true)]
[Row(""testrblah"@example.com", false)]
[Row(@"""test""blah""@example.com", true)]
[Row(@"""test""blah""@example.com", false)]
[Row(@"customer/department@example.com", true)]
[Row(@"$A12345@example.com", true)]
[Row(@"!def!xyz%abc@example.com", true)]
[Row(@"_Yosemite.Sam@example.com", true)]
[Row(@"~@example.com", true)]
[Row(@".wooly@example.com", false)]
[Row(@"wo..oly@example.com", false)]
[Row(@"pootietang.@example.com", false)]
[Row(@".@example.com", false)]
[Row(@"""Austin@Powers""@example.com", true)]
[Row(@"Ima.Fool@example.com", true)]
[Row(@"""Ima.Fool""@example.com", true)]
[Row(@"""Ima Fool""@example.com", true)]
[Row(@"Ima Fool@example.com", false)]

public void EmailTests(string email, bool expected)
{
  string pattern = @"^(?!.)(""([^""r\]|\[""r\])*""|" 
    + @"([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!.).)*)(?<!.)" 
    + @"@[a-z0-9][w.-]*[a-z0-9].[a-z][a-z.]*[a-z]$";

  Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
  Assert.AreEqual(expected, regex.IsMatch(email)
    , "Problem with '" + email + "'. Expected "  
    + expected + " but was not that.");
}

Прежде, чем вы назовёте меня жутким занудой и педантом (может, вы и правы, но всё равно погодите), я не думаю, что настолько глубокая проверка email-адресов абсолютно необходима. Большинство email-провайдеров имеют более строгие требования к email-адесам. Например, Yahoo требует, чтобы адрес начинался с буквы. Похоже, что имеется стандартизированный более строгий набор правил, которому следует большинство email-провайдеров, но насколько мне известно, он нигде не задокументирован.

Думаю, я создам email-адрес типа phil.h@@ck@haacked.com и начну жаловаться в техподдержку на сайтах, которые требуют ввода email-адреса, но не позволяют мне создать учётную запись с этим адресом. Люблю шалить!

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

P.S. Исправил несколько ошибок, которые я сделал в моём прочтении RFC. Видите? Даже прочитав RFC, я всё ещё не уверен в том, что же я, блин, делаю! Что ещё раз подтверждает тезис о том, что программисты — не читатели.

It is very difficult to validate Email correctly simply using HTML5 attribute «pattern». If you do not use a «pattern» someone@ will be processed. which is NOT valid email.

Using pattern="[a-zA-Z]{3,}@[a-zA-Z]{3,}[.]{1}[a-zA-Z]{2,}[.]{1}[a-zA-Z]{2,}" will require the format to be someone@email.com however if the sender has a format like someone@email.net.au (or similar) will not be validated to fix this you could put pattern="[a-zA-Z]{3,}@[a-zA-Z]{3,}[.]{1}[a-zA-Z]{2,}[.]{1}[a-zA-Z]{2,}[.]{1}[a-zA-Z]{2,}" this will validate «.com.au or .net.au or alike.

However using this, it will not permit someone@email.com to validate. So as far as simply using HTML5 to validate email addresses is still not totally with us. To Complete this you would use something like this:

<form>
<input id="email" type="text" name="email" pattern="[a-zA-Z]{3,}@[a-zA-Z]{3,}[.]{1}[a-zA-Z]{2,}[.]{1}[a-zA-Z]{2,}" required placeholder="Enter you Email">
<br>
<input type="submit" value="Submit The Form">
</form>

or:

<form>
<input id="email" type="text" name="email" pattern="[a-zA-Z]{3,}@[a-zA-Z]{3,}[.]{1}[a-zA-Z]{2,}[.]{1}[a-zA-Z]{2,}[.]{1}[a-zA-Z]{2,}" required placeholder="Enter you Email">
<br>
<input type="submit" value="Submit The Form">
</form>

However, I do not know how to validate both or all versions of email addresses using HTML5 pattern attribute.

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

Содержание

Необходимость email валидации

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

Купленные базы быстро устаревают и часто содержат некачественные email, большая часть из которых уже не существует. И количество их может достигать 40%, в зависимости от качества базы.

Рассылка по базам без проверки на валидность чревата последствиями — от попадания писем в спам и падения рейтинга домена, до полной его блокировки почтовыми провайдерами.

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

Заказ валидации email

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

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

Существует масса специализированных сервисов проверки email, например: zerobounce, myemailverifier. На мой взгляд — оптимальное соотношение цена / качество.

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

В любом случае, важно получить отчет валидации по каждому email адресу. И чем подробнее он будет, тем лучше.

Самостоятельная валидация

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

Советы валидации email

1. Валидация синтаксиса

Каждый почтовый адрес должен соответствовать определенному формату, содержащему имя, домен и знак «@». Эффективным способом такой проверки является применение регулярных выражений в соответствии с современными стандартами.

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

2. Проверка DEA (одноразовый email)

DEA (Disposable email address) — это временная электронная почта, которая создается для того, чтобы не использовать свой настоящий email-адрес на ресурсах в интернете по разным причинам. Такая почта не требует регистрации, анонимна и удаляется сразу же после использования.

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

Валидация по DEA-критерию заключается в проверке на принадлежность домена email общеизвестным поставщикам одноразовых адресов электронной почты.

3. Проверка записей DNS, MX

Следующим этапом валидации является выполнение запроса, на получение DNS записей.

MX-запись в DNS направляет письма на почтовый сервер и указывает как письма должны маршрутизироваться в соответствии с SMTP или стандартным протоколом передачи почты.

Проверка наличия DNS и MX-записей является первым сигналом того, что сервер работает и обслуживает входящие запросы для домена электронного адреса. Результатом является успешное определение IP-адреса почтового сервера с помощью записей MX.

4. SMTP-сервер

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

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

5. Проверка активности email

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

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

Понять, что email отключен можно по ответам SMTP-сервера. Обычно в ошибках встречаются такие упоминания, как «disabled», «discontinued».

6. Переполнение почтового ящика

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

Методом валидации таких email является анализ ошибочных ответов SMTP-сервера на наличие вхождений «full», «insufficient», «over quota», «too many messages» и т.д.

7. Валидация Catch-all адресов

Catch-all — это email адрес, принимающий все сообщения, адресованные на неправильный адрес электронной почты домена.

Проверить факт того, является ли текущий email catch-all-адресом или нет можно с помощью SMTP-диалога и отправки сообщения на заведомо несуществующий, сгенерированный почтовый адрес в почтовом домене.

8. Ролевой аккаунт

Ролевые учетные записи — это адреса электронной почты, которые не связаны с конкретным человеком, а скорее с компанией, отделом, должностью или группой. Как правило, они не предназначены для личной переписки. Часто они начинаются на info, admin, support и т.д.

Отправка сообщений на такие email ставится под вопрос. Обычно, их не используют для подписок и вероятность того, что кто-то пометит письмо как спам высока. Так же ролевые email используют в качестве «приманки» для поимки спамеров такие сервисы, как Spamhaus.

Проверка email на валидность в этом случае выполняется методом сравнения текущего имени в адресе email со списком часто-встречающихся имен ролевых учетных записей.

9. Проверка наличия в черном списке

Черный список электронной почты — это база email, IP-адресов и доменных имен, которые были зафиксированы в рассылке спама. Одним из самых известных является составной список от Spamhaus.

Для предотвращения спама, черные списки используются многими поставщиками услуг, в число которых входят Google и Microsoft.

Проверка наличия email в черном списке является важнейшей частью определения валидности баз email для рассылок.

10. Повторная валидация

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

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

Заключение

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

С вами был Дмитрий. Успехов!

You will learn how to do email validation in Angular and Typescript applications with input forms.

Email validation is one of the basic validation to avoid invalid emails.

• VueJS Input type url validation
• ReactJS Input type url validation

In Angular, validations can be done using two approaches.
-Reactive forms

• Template Driven Forms
  email pattern validation implemented with multiple approaches

We already have a pre-created angular application — angular-form-validations.

Angular Email Validation reactive forms

Email Validations are implemented in Reactive forms using in-built Angular directives.
For Angular applications to use reactive forms,

In app.module.ts, first import the FormsModule and ReactiveFormsModule modules.

import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { FormsModule, ReactiveFormsModule } from '@angular/forms';

import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';


@NgModule({
  declarations: [
    AppComponent,
  ],
  imports: [
    BrowserModule,
    AppRoutingModule,
    FormsModule,
    ReactiveFormsModule
  ],
  providers: [],
  bootstrap: [AppComponent]
})
export class AppModule { }

Let’s create a new component reactive-email-validation using the ng g component command.

A:workangular-form-validations>ng g component reactive-email-validation
CREATE src/app/reactive-email-validation/reactive-email-validation.component.html (40 bytes)
CREATE src/app/reactive-email-validation/reactive-email-validation.component.spec.ts (747 bytes)
CREATE src/app/reactive-email-validation/reactive-email-validation.component.ts (350 bytes)
CREATE src/app/reactive-email-validation/reactive-email-validation.component.scss (0 bytes)
UPDATE src/app/app.module.ts (973 bytes)

To begin, an HTML template component is constructed in Angular to display the input form with an email field.

• Define the form element with FormGroup directive with emailForm binding
• Inside the form, define the input element with formControlName name email
• validation errors are bound and available with emailForm.controls[email]
• Validation check added for input box is not empty(errors.required) and focus is in it(touched)
• if bound errors contains required, display the error message ‘Email is required
• if errors contain the pattern, display the error message ‘Invalid Email’.

<p>Angular Email Validation with Reactive form!</p>
<div>
    <h2>{{ heading | titlecase }}</h2>
    <form [formGroup]="emailForm">
        <input type="text" formControlName="email" />
        <div *ngIf="!emailForm.controls['email'].valid && emailForm.controls['email'].touched">
            <div *ngIf="emailForm.controls['email'].errors?['required']" style=" background-color: red">
                Email is required
            </div>
            <div *ngIf="emailForm.controls['email'].errors?['required']" style="background-color: red">
                Invalid Email
            </div>
        </div>
    </form>

    <button type="submit ">Submit</button>
</div>

Next, In the application controller component, define the logic for regex pattern validation.

• Declared emailForm of type FormGroup which already has a binding to form element.
• Defined the email regular expression pattern into variable
• In the constructor, initialized emailForm with a new FormControl element ie email
• these email form control will be bound with the input element in the HTML template
• Validators.required added for not empty validation check
• Validators.pattern added for email regular expression
• These validations are checked with blur event `updateOn: blur’ property

import { Component, OnInit } from '@angular/core';
import { FormControl, FormGroup, Validators } from '@angular/forms';

@Component({
  selector: 'app-reactive-email-validation',
  templateUrl: './reactive-email-validation.component.html',
  styleUrls: ['./reactive-email-validation.component.scss']
})
export class ReactiveEmailValidationComponent {
  heading = 'angular Email pattern validation with examples';
  emailForm: FormGroup;

  myusername: string = '';
  emailRegex =
    '^[a-z0-9._%+-][email protected][a-z0-9.-]+.[a-z]{2,4}$';

  constructor() {
    this.emailForm = new FormGroup({
      email: new FormControl('', {
        validators: [Validators.required, Validators.pattern(this.emailRegex)],
        updateOn: 'blur',
      }),
    });
  }
  submit() {
    console.log(this.emailForm.value);
  }
  get validator() {
    return true;
  }

}

Angular email template-driven form validation using html5

In modern browsers, the Easy approach is to do email pattern validation with inbuilt html5 language.

Another way to do email validation is to define the input type=email in the HTML element. However, this supports html5 only and modern browsers.

Input is defined with the following attributes

<input type="email" name="email" id="email" placeholder="[email protected]" [(ngModel)]="email" [ngModelOptions]="{ updateOn: 'blur' }" #emailerror="ngModel" pattern="^[a-z0-9._%+-][email protected][a-z0-9.-]+.[a-z]{2,4}$ "        required />

type=email is an input textbox, that accepts email only
pattern attribute value is a regular expression pattern for email values
NgModel directive is to support two-way binding from view to controller and vice versa
The ngModelOptions directive enables to change of the behavior of the ngModel value, this will be fired with the updateon:blur event.

Following is a complete code

<div>
<input type="email" name="email" id="email" placeholder="[email protected]" [(ngModel)]="email" [ngModelOptions]="{ updateOn: 'blur' }" #emailerror="ngModel" pattern="^[a-z0-9._%+-][email protected][a-z0-9.-]+.[a-z]{2,4}$ "        required />
    <div *ngIf="emailerror.invalid && (emailerror.dirty || emailerror.touched)">
        <div *ngIf="emailerror.errors.required">
            <span style="background-color: red">Email is required </span>
        </div>
        <div *ngIf="emailerror.errors.pattern">
            <span style="background-color: red">Invalid EmailL </span>
        </div>
    </div>
</div>

In the component, just declare the input element’s name here with a default value.

import { Component } from '@angular/core';
import { FormControl, FormGroup, Validators } from '@angular/forms';
@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.scss'],
})
export class AppComponent {
  heading = 'angular html5 Email pattern validation  example';

  email: string = '';
}

Typescript email regexp validation

Sometimes, We want to do a validation typescript file.

• It uses the same above regular expression pattern for email validation
• RegExp object is created with regex
• pattern. test checked against supplied email and return true-valid

  public isValidEmail(emailString: string): boolean {
    try {
      let pattern = new RegExp("^[a-z0-9._%+-][email protected][a-z0-9.-]+.[a-z]{2,4}$");
      let valid = pattern.test(emailString);
      return valid;
    } catch (TypeError) {
      return false;
    }
  }
}
}
console.log(this.isValidEmail('[email protected]')); // true
console.log(this.isValidEmail('abc')); // false
a

Conclusion

In this post, You learned

• Angular email pattern validation example with reactive forms
• HTML 5 input type email form validation
• Typescript email validation

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

Как же выглядит e-mail адрес? Интуитивно можно предположить, что так:

// Пример адреса:
johndoe@example.com
 
// В виде составных частей:
${MAILBOX}@${SUBDOMAIN}.${TLD}
 
// Регулярка, которую можно было бы использовать
[a-zA-Z0-9]+@[a-zA-Z0-9]+.[a-zA-Z0-9]+

Выглядит хорошо, но это совершенно не тот случай, когда стоит доверять интуиции. Доверять следует спецификации. А спецификация говорит нам следующее:

// Пропущен домен? Всё нормально, письмо уйдёт на локаль!
john-doe
 
// Да, это тоже валидно, но такого ящика не существует с вероятностью 99%
john-doe@com
 
// И это валидно, но доменов из одной буквы не существует
john-doe@example.c
 
// Оу, мы кажется забыли про субдомены. Мы же не можем просто забыть про .co.uk?
john@doe.example.com
 
 
// Да, IP адрес в качестве сервера это тоже нормально
john@[192.168.1.1]
 
// По спецификации подходит, но такой домен не может быть зарегистрирован
john@-doe.com
 
// А ещё можно делать так:
john.doe@example.com
 
// Но нельзя так:
john..doe@eaxmple.com
.john@example.com
john.@example.com

Конечно, и тут можно обойтись с помощью регулярного выражения:

(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[x01-x08x0bx0cx0e-x1fx21x23-x5bx5d-x7f]|\[x01-x09x0bx0cx0e-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-x08x0bx0cx0e-x1fx21-x5ax53-x7f]|\[x01-x09x0bx0cx0e-x7f])+)])

Но с этим есть несколько проблем:

• Как вы будете проверять правильность этого монстра? Такие регулярные выражения переходят «из уст в уста» на форумах, и каждый добавляет в них функциональность до тех пор, пока работа с выражением становится невозможной. И это именно тот случай.
• Я бы не сказал, что регулярные выражения такой длины эффективнее, чем другие методы. Чем длиннее выражение, тем дольше оно будет компилироваться (сравнение всегда происходит за O(n)).
• С помощью регулярного выражения можно сделать только проверку на соответствие. Выполнить проверку на то, находится ли домен в чёрном списке, у вас уже, увы, не получится.

Давайте пойдём другим путём

Вот основа нашей проверки:

char[] input; // Строка, которую нужно проверить
int index = 0; // Итератор для input
char ch; // Текущий символ (input[index])
int state = 0; // Состояние проверки (-1 для ошибки)
 
while (index <= input.length && state != -1) {
 
	if (index == input.length) {
		ch = ''; // Символ, по которому проверка прекращается
	}
	else {
		ch = input[index];
	}
 
	switch (state) {
		// case 0: {...
	}
 
	index++;
}

А вот диаграмма, описывающая алгоритм, по которому наша программа будет работать:

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

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

case 0: {
	if (ch >= 'a' && ch <= 'z') {
		count++; 
		break; // State stays the same
	}
	if (ch == '') {
		state = 1; // EOL
		break;
	}
	state = -1; // Error
	break;
}

Теперь о проверках, которые мы сделаем, после того, как код пройдёт по этой диаграмме:

public class Validator {
 
	public static boolean isValid(final char[] input) {
		int state = 0;
		char ch;
		int index = 0;
		String local = null;
		ArrayList<String> domain = new ArrayList<String>();
 
		// Код проверки по диаграмме
		// [..]
 
		// Не прошло валидацию
		if (state != 6)
			return false;
 
		// Домен должен быть по меньшей мере второго уровня
		if (domain.size() < 2)
			return false;
 
		// RFC 5321 ограничивает длину имени ящика до 64 символов
		if (local.length() > 64)
			return false;
 
		// RFC 5321 ограничивает длину адреса до 254 символов
		if (input.length > 254)
			return false;
 
		// Доменная зона должна состоять только из букв и быть по меньше мере два символо длинной
		index = input.length - 1;
		while (index > 0) {
			ch = input[index];
			if (ch == '.' && input.length - index > 2) {
				return true;
			}
			if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))) {
				return false;
			}
			index--;
		}
 
		return true;
	}
}

Собираем всё вместе

public class EmailValidator {
 
	public static boolean isValid(final char[] input) {
		if (input == null) {
			return false;
		}
 
		int state = 0;
		char ch;
		int index = 0;
		int mark = 0;
		String local = null;
		ArrayList<String> domain = new ArrayList<String>();
 
		while (index <= input.length && state != -1) {
			
			if (index == input.length) {
				ch = ''; // Так мы обозначаем конец нашей работы
			}
			else {
				ch = input[index];
				if (ch == '') {
					// символ, которым мы кодируем конец работы, не может быть частью ввода
					return false;
				}
			}
 
			switch (state) {
 
				case 0: {
					// Первый символ {atext} -- текстовой части локального имени
					if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
							|| (ch >= '0' && ch <= '9') || ch == '_' || ch == '-'
							|| ch == '+') {
						state = 1;
						break;
					}
					// Если встретили неправильный символ -> отмечаемся в state об ошибке
					state = -1;
					break;
				}
 
				case 1: {
					// Остальные символы {atext} -- текстовой части локального имени
					if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
							|| (ch >= '0' && ch <= '9') || ch == '_' || ch == '-'
							|| ch == '+') {
						break;
					}
					if (ch == '.') {
						state = 2;
						break;
					}
					if (ch == '@') { // Конец локальной части
						local = new String(input, 0, index - mark);
						mark = index + 1;
						state = 3;
						break;
					}
					// Если встретили неправильный символ -> отмечаемся в state об ошибке
					state = -1;
					break;
				}
 
				case 2: {
					// Переход к {atext} (текстовой части) после точки
					if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')
							|| (ch >= '0' && ch <= '9') || ch == '_' || ch == '-'
							|| ch == '+') {
						state = 1;
						break;
					}
					// Если встретили неправильный символ -> отмечаемся в state об ошибке
					state = -1;
					break;
				}
 
				case 3: {
					// Переходим {alnum} (домену), проверяем первый символ
					if ((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')
							|| (ch >= 'A' && ch <= 'Z')) {
						state = 4;
						break;
					}
					// Если встретили неправильный символ -> отмечаемся в state об ошибке
					state = -1;
					break;
				}
 
				case 4: {
					// Собираем {alnum} --- домен
					if ((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')
							|| (ch >= 'A' && ch <= 'Z')) {
						break;
					}
					if (ch == '-') {
						state = 5;
						break;
					}
					if (ch == '.') {
						domain.add(new String(input, mark, index - mark));
						mark = index + 1;
						state = 5;
						break;
					}
					// Проверка на конец строки
					if (ch == '') {
						domain.add(new String(input, mark, index - mark));
						state = 6;
						break; // Дошли до конца строки -> заканчиваем работу
					}
					// Если встретили неправильный символ -> отмечаемся в state об ошибке
					state = -1;
					break;
				}
 
				case 5: {
					if ((ch >= 'a' && ch <= 'z') || (ch >= '0' && ch <= '9')
							|| (ch >= 'A' && ch <= 'Z')) {
						state = 4;
						break;
					}
					if (ch == '-') {
						break;
					}
					// Если встретили неправильный символ -> отмечаемся в state об ошибке
					state = -1;
					break;
				}
 
				case 6: {
					// Успех! (На самом деле, мы сюда никогда не попадём)
					break;
				}
			}
			index++;
		}
 
		// Остальные проверки
 
		// Не прошли проверку выше? Возвращаем false!
		if (state != 6)
			return false;
 
		// Нам нужен домен как минимум второго уровня
		if (domain.size() < 2)
			return false;
 
		// Ограничения длины по спецификации RFC 5321
		if (local.length() > 64)
			return false;
 
		// Ограничения длины по спецификации RFC 5321
		if (input.length > 254)
			return false;
 
		// Домен верхнего уровня должен состоять только из букв и быть не короче двух символов
		index = input.length - 1;
		while (index > 0) {
			ch = input[index];
			if (ch == '.' && input.length - index > 2) {
				return true;
			}
			if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z'))) {
				return false;
			}
			index--;
		}
 
		return true;
	}
}

Перевод статьи «Validating Email Addresses with a Regex? Do yourself a favor and don’t»

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

Задача:

Есть текстовое поле, куда пользователь должен вводить E-mail.

• Если поле проходит валидацию — оно должно иметь зеленую подсветку;
• Если нет — красную.

Первым делом добавляем input в HTML. Здесь все просто:

input(type='email' placeholder='E-mail')

Для простоты восприятия предположим, что больше на странице ничего нет, поэтому не станем добавлять лишние атрибуты.

Так как подсветка должна меняться в реальном времени, добавим «слушатель» на input:

const input = document.querySelector('input');
input.addEventListener('input', onInput);

Функция onInput будет менять цвет css-свойства border на зеленый, если введенный в input текст валиден, или на красный — если нет.

const EMAIL_REGEXP = /^(([^<>()[].,;:s@"]+(.[^<>()[].,;:s@"]+)*)|(".+"))@(([^<>()[].,;:s@"]+.)+[^<>()[].,;:s@"]{2,})$/iu;

const input = document.querySelector('input');

function onInput() {
  if (isEmailValid(input.value)) {
    input.style.borderColor = 'green';
  } else {
    input.style.borderColor = 'red';
  }
}

input.addEventListener('input', onInput);

function isEmailValid(value) {
return EMAIL_REGEXP.test(value);

Функция isEmailValid будет сравнивать введенное пользователем значение с регулярным выражением. В успешном случае функция вернет true, иначе — false.

Вот и все! Скрипт готов. Его работу вы можете проверить в моем Codepen.

ПОДПИСКА НА РАССЫЛКУ СРЕДСТВАМИ PHP – часть2.

Валидация имени и email адреса пользователя.

В предыдущей статье, размещенной по ссылке, мы создали html-файл c формой подписки на рассылку и организовали передачу данных из html-формы в php-скрипт, который размещает в таблице «subscribe» введенные пользователем данные (имя и email-адрес). Функцию подключения к базе данных мы вынесли в отдельный файл. В итоге у нас получилось 3 файла:

• «subscribe.html» содержит форму подписки на рассылку;
• «config.php» устанавливает соединение с базой данных;
• «subscribe.php» принимает данные из html-формы и после соединения с БД вносит полученные данные в таблицу «subscribe»

Потерянным звеном этой цепочки оказалась проверка введенных пользователем данных. Восполним этот пробел и напишем функцию валидации email и имени пользователя. При проверке будем руководствоваться следующими критериями соответствия:

Имя пользователя:

1. Содержит от 2 до 50 символов.
2. Может состоять из букв русского и латинского алфавита, чисел, символа подчеркивания и пробела.

Email пользователя:

1. Содержит от 3 до 50 символов.
2. Соответствует структуре логин@доменное-имя.доменная-зона. При этом логин, доменное имя и доменная зона содержат только цифры и буквы латинского алфавита.

Руководствуясь перечисленными критериями соответствия дополним файл «subscribe.php» двумя функциями:

1. Функция валидации имени пользователя:

function validate_name($data) {
    $err=""; /* присваиваем переменной $err пустую строку */
    if(strlen($data)<2 || strlen($data)>50) /* если длина переменной $data меньше 2 или больше 50 символов*/
        $err = "Длина имени должна быть от 2 до 50 символов"; 
    if (preg_match("/[^(w)|(x7F-xFF)|(s)]/",$data)) /* если в имени содержатся недопустимые символы */
        $err = $err . "<p>В написании имени допустимы только буквы латинского и русского алфавита,цифры, символ подчеркивания и пробел</p>";
    if(!empty($err))
        return($err);
    else
    	return 0;
}

Переменная $err, презентованная в начале функции, предназначена для хранения текста ошибок. Для проверки количества символов используется функция strlen($data). Корректно ли введенное пользователем имя мы проверяем с помощью регулярного выражения.

2. Функция валидации email-адреса пользователя:

function validate_email($data){
    $err ="";
    if(strlen($data)<3 || strlen($data)>50) /* если длина email меньше 3 и больше 50 */
        $err = "Email должен быть от 3 до 50 символов"; /*записываем в переменную $err сообщение об ошибке */
     if(!preg_match('#^([w]+.?)+(?<!.)@(?!.)[a-zа-я0-9ё.-]+.?[a-zа-яё]{2,}$#ui', $data)) /* если введенный адрес недопустимого формата */
	   $err = $err . "<p>Недопустимый формат email-адреса</p>";  /*записываем в переменную $err сообщение об ошибке */	
	if(!empty($err)) 
		return($err);
	else
		return 0;
}

По аналогии с предыдущей функцией, в переменной $err мы будем хранить текст ошибок, количество символов проверим с помощью функции strlen($data), а в корректности email-адреса убедимся посредством регулярного выражения.

Если вы знакомы с функцией filter_var(), у вас может возникнуть вопрос: зачем городить регулярку, если можно решить вопрос простой функцией? Дело в том, что функция filter_var() «дискредитирует» email-адреса, содержащие кириллические символы. Приходится выбирать между дополнительным числом подписчиков в базе данных и компактной функцией с небольшим изъяном.

Функция валидации инпутов из формы подписки на рассылку

А теперь неплохо было бы объединить описанные выше функции в единую функцию валидации полученных из формы данных validate_inputs():

function validate_inputs($data_name,$data_email){
    $err="";
    $err_name = validate_name($data_name); /* вызываем функцию валидации имени пользователя */
    $error_email = validate_email($data_email); /* вызываем функцию валидации email-адреса пользователя */
    if(!empty($err_name))
    	$err = $err_name;
    if(!empty($error_email))
    	$err = $err . $error_email;
    return $err;
}

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

Функция валидации готова! Осталось произвести вызов этой функции в php-скрипте сразу после получения переменных:

...
if(isset($_POST['submit_form']))
{
    $name=$_POST["user_name"];
    $email=$_POST["email"];
    $error_form = validate_inputs($name, $email); /* вызываем функцию валидации формы*/
    if(!empty($error_form)) { /* если найдена ошибка */
        echo $error_form; /* выводим сообщение об ошибке */
    }
    else { /* иначе - вызываем подготовленный запрос */
        $name=$_POST["user_name"]; /* извлекаем имя пользователя из массива $_POST в переменную $name */
        $email=$_POST["email"]; /* извлекаем email пользователя из массива $_POST в переменную $email */
        $prepared = $mysqli->prepare("insert into subscribe values('',?,?)"); /* формируем запрос, в котором вместо параметров записаны символы вопросительного знака */
        $prepared->bind_param("ss",$name, $email); /* привязываем переменные имени и emaila параметрам запроса */
        if($prepared->execute()) /* если запрос выполнен, сообщаем об успехе */
            echo "Поздравляем! Подписка успешно оформлена! ";
        else /*иначе - сообщаем об ошибке*/
            echo "Ошибка запроса";
        $prepared->close();
    }
}
?>

Таким образом, размещение новой строки в таблице БД происходит только в том случае, если введенные пользователем данные удовлетворяют прописанным в функции validate_inputs() условиям.

Проверяем, содержится ли уже в таблице subscribe введенный пользователем email-адрес.

Чтобы не плодить в таблице записи с одинаковыми email-адресами, предлагаю после вызова функции validate_inputs() выполнить подготавливаемый mysqli-запрос на поиск в таблице «subscribe» строк с введенным пользователем email-адресом в ячейке email. Запрос будет выглядеть следующим образом:

    $prepared = $mysqli->prepare("select id, name, email from subscribe where email = ?"); /* подготавливаем запрос - выбрать из таблицы строки с введенным пользователем email-адресом */
    $prepared->bind_param("s", $email); /* привязываем переменную emaila к параметру запроса */
    $prepared->execute(); /* выполняем запрос */
    $prepared->store_result(); /* сохраняем результат запроса */
    if($prepared->num_rows === 0) { /* если не найдена ни одна строка с таким email-адресом */
       /* здесь будет находиться запрос для добавления пользовательских данных в  
           таблицу БД */
    }

Таким образом, файл subscribe.php после внесенных изменений будет выглядеть следующим образом: скопировать файл с пояснениями

Скачать архив файлов с кодом подписки на рассылку можно по ссылке: subscribe_form2.zip. Не забудьте файле «config.php» поменять значения переменных на корректные для вашей базы данных!

Для тех, кто решил написать простую (или сложную) программу, получающую данные от пользователя в процессе работы обязательно придётся столкнуться с вопросом валидации данных, введённых пользователем у себя в браузере. Эти данные можно как угодно обрабатывать на стороне клиента, используя навороченные проверки с помощью JavaScript. Но все эти проверки легко обходятся и всегда есть шанс того, что на сервер прилетит не то, что задумано и должно быть заранее проверено на ошибки. В этой статье расскажу, к какому решению по валидации адреса электронной почты (email) я пришёл.

В общем случае задача о валидации адреса электронной почты (email) на сервере стоит таким образом, что нужно проверить соответствие полученной строки на соблюдение стандартов. И при ближайшем рассмотрении получается, что email — это не просто куски текста, цифр и определённых спец.символов, разделённых @ и .. После внедрения IDN (Internationalized Domain Names — интернационализованные доменные имена) нужно по-хорошему ещё пытаться переводить полученные данные в Punycode, если вдруг окажется, что пользователь решил завести себе мыло с использованием национального алфавита. При этом нужно учесть ещё тот факт, что есть не просто пользователи и злоумышленники (или просто экспериментаторы), которые могут отправить винегрет ланитицы и кирилицы…

В общем, зарывшись в этот вопрос с головой я решил не влазить в эти дебри, тем более, что они куда более извилисты и тернисты. В итоге решил использовать использовать стандартные средства, предлагаемые разработчиками php. Как только они внесут какие-то доработки в язык программирования, так пользователи моих сервисов смогут использовать то, что в текущей версии для них недоступно. Для тех, кто боится потерять своих пользователей, лучше ищите другое решение. В данном вопросе я решил быть консерватором и не поддаваться тем веяниям моды, которые пока не вошли в стандарт языка. Мне так проще. Как быть с пользователями, которые используют нестандартизованные решения — это на их усмотрение. Хотят получить доступ к моим разработкам — зарегистрируют бесплатный ящик на нормальном почтовом сервисе. Хотят выпендрёжа, — это их право.

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

Валидация адреса электронной почты (email) на сервере стандартными средствами php

В php есть встроенная функция фильтрации данных для обработки данных форм. Это функция filter_var(), которая фильтрует переменную с помощью определенного фильтра. У неё есть ряд фильтров, которые можно применять для обработки переменной. Я выбрал две, которые должны обеспечить защиту от злоумышленников и не отсекать пользователей, которые совершают какие-то совсем дурацкие ошибки.

• Фильтр FILTER_SANITIZE_EMAIL, который удаляет все символы, кроме букв, цифр и !#$%&'*+-=?^_`{|}~@.[]. Использую его именно из-за пробелов, так как был не раз свидетелем того, как пользователи упорно ставили пробелы там, где их не должно быть. Зачем они это делают, так и не получилось выяснить при опросе — работа подсознания не поддаётся логическому анализу. =)
• Фильтр FILTER_VALIDATE_EMAIL , который проверяет, что значение является корректным e-mail. В целом, происходит проверка синтаксиса адреса в соответствии с RFC 822, за исключением того, что не поддерживаются комментарии, схлопывание пробельных символов и доменные имена без точек.

Программа на php валидации адреса электронной почты (email) на сервере стандартными фильтрами

Собственно, как всё это работает, можно проверить, написав простую программу:

<?php
if (isset($_POST['email'])) {$email = $_POST['email'];} else {$email = '';}
$sanitized_email = filter_var($email, FILTER_SANITIZE_EMAIL);
if (filter_var($sanitized_email, FILTER_VALIDATE_EMAIL)) {
    echo "E-mail адрес <font color=green><b>" . $sanitized_email . "</b></font> указан верно<br>n";
} else {
    echo "E-mail адрес <font color=red><b>" . $sanitized_email . "</b></font> указан неверно<br>n";
}
?>

<form method="post" action="">
<input type="text" name="email" placeholder="введите email">
<input class="enter" type="submit" value="Enter!">
</form>

Последние четыре строчки — это HTML-код вывода формы для ввода email’а.

Первая строчка if (isset($_POST['email'])) {$email = $_POST['email'];} else {$email = '';} — проверка на то, что поле email было заполнено. Но, при первом обращении к этому скрипту, поле не заполнено. Поэтому, чтобы не сыпались предупреджения, для этого случая, если переменная $_POST['email'] не задана, принудительно объявляем переменную $email с пустым значением ''. После этого интерпретатор php не будет выдавать никаких сообщений, даже, если включен режим отладки.

Во второй строчке $sanitized_email = filter_var($email, FILTER_SANITIZE_EMAIL); применяем фильтр FILTER_SANITIZE_EMAIL. к прилетевшей переменной $email и записываем отфильтрованное в переменную $sanitized_email.

Ну и проверяем полученную переменную фильтром FILTER_VALIDATE_EMAIL. Если проверка проходит filter_var($sanitized_email, FILTER_VALIDATE_EMAIL), выдаём сообщение, что всё хорошо. Если проверка не проходит — всё плохо.

Резюме

Если нет нужны хранить неотфильтрованную переменную, то код можно упростить до:

<?php
if (isset($_POST['email'])) {$email = $_POST['email'];} else {$email = '';}
$email = filter_var($email, FILTER_SANITIZE_EMAIL);
if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
    echo "E-mail адрес <font color=green><b>" . $email . "</b></font> указан верно<br>n";
} else {
    echo "E-mail адрес <font color=red><b>" . $email . "</b></font> указан неверно<br>n";
}
?>

<form method="post" action="">
<input type="text" name="email" placeholder="введите email">
<input class="enter" type="submit" value="Enter!">
</form>

Просто перепрописав значение переменной $email после применения фильтра: $email = filter_var($email, FILTER_SANITIZE_EMAIL);. Так будет работать наверное чуть быстрее. =)

Таким образом я решил для себя вопрос о том, как сделать валидацию электронной почты (email) из данных формы на стороне сервера с помощью php.

Решает ли это 100% задачи? — Нет!

Но в моём случае этого достаточно.

P.S.

Есть мнение, что валидация email вообще не нужна. Нужно просто послать письмо пользователю на то, что он ввёл с кодом подтверждения. В моём случае — это следующий этап. Но оставлять без проверки того, что прилетело от пользователя в качестве его почты я пока не намерен. Мало ли кто что решит послать на вход моим программам. Да и хранить весь этот хлам в ожидании, пока пользователь (может быть) решит подтвердить свою почту, тоже не хочется. Повторюсь: неадекватные пользователи лично мне не нужны.

Заберите ссылку на статью к себе, чтобы потом легко её найти!
Выберите, то, чем пользуетесь чаще всего: