.RICOH

Use filter_var() with FILTER_VALIDATE_EMAIL. This follows the RFC spec and does not restrict TLD length or format.

$valid = filter_var($email, FILTER_VALIDATE_EMAIL) !== false;

Use the email-validator package for robust validation with optional DNS checks. For basic parsing, the standard library's email.utils.parseaddr() also works.

from email_validator import validate_email
result = validate_email("[email protected]")

Avoid writing a custom regex. Use the browser's built-in <input type="email"> constraint validation, or use validator.js on the server.

import validator from 'validator';
validator.isEmail('[email protected]'); // true

Use the built-in URI::MailTo::EMAIL_REGEXP constant which follows the RFC spec and accepts all valid TLDs.

valid = email.match?(URI::MailTo::EMAIL_REGEXP)

Use jakarta.mail.internet.InternetAddress which parses per RFC 822, or the @Email annotation from Hibernate Validator.

import jakarta.mail.internet.InternetAddress;
InternetAddress addr = new InternetAddress(email);
addr.validate();

Use System.Net.Mail.MailAddress which parses per RFC spec, or the [EmailAddress] data annotation for model validation.

try {
    var addr = new System.Net.Mail.MailAddress(email);
    bool valid = addr.Address == email;
} catch (FormatException) {
    // invalid
}

Use the standard library's net/mail.ParseAddress() which parses addresses per RFC 5322.

import "net/mail"
_, err := mail.ParseAddress(email)
valid := err == nil

Use NSDataDetector with the .link checking type to validate email addresses without restrictive regex.

import Foundation
let detector = try NSDataDetector(
    types: NSTextCheckingResult.CheckingType.link.rawValue
)
let range = NSRange(email.startIndex..<email.endIndex, in: email)
let match = detector.firstMatch(in: email, options: [], range: range)
let valid = match?.url?.scheme == "mailto"

On Android use Patterns.EMAIL_ADDRESS. On the JVM, use InternetAddress from Jakarta Mail.

// Android
val valid = android.util.Patterns.EMAIL_ADDRESS
    .matcher(email).matches()

// JVM
val addr = jakarta.mail.internet.InternetAddress(email)
addr.validate()

Use the email_address crate which validates against RFC 5321.

use email_address::EmailAddress;
let valid = EmailAddress::is_valid("[email protected]");

Use the email_checker package or Ecto changeset validation.

# Ecto changeset
validate_format(changeset, :email, ~r/^[^\s]+@[^\s]+\.[^\s]+$/)

Use the Email constraint with the desired validation mode.

use Symfony\Component\Validator\Constraints as Assert;

#[Assert\Email(mode: 'strict')]
private string $email;

Use the built-in EmailValidator or EmailField on forms and models.

# In a model
from django.db import models
email = models.EmailField()

# In a form
from django.core.validators import validate_email
validate_email('[email protected]')

Use the Email validator from WTForms which checks RFC compliance.

from wtforms import StringField
from wtforms.validators import Email

class MyForm(FlaskForm):
    email = StringField('Email', validators=[Email()])

Use the built-in URI::MailTo::EMAIL_REGEXP with a model validation.

class User < ApplicationRecord
  validates :email, format: { with: URI::MailTo::EMAIL_REGEXP }
end

Use the @Email annotation from Jakarta Bean Validation (Hibernate Validator).

import jakarta.validation.constraints.Email;

public class UserDTO {
    @Email
    private String email;
}

Use the [EmailAddress] data annotation on your model properties.

using System.ComponentModel.DataAnnotations;

public class UserModel {
    [Required]
    [EmailAddress]
    public string Email { get; set; }
}

Use express-validator which wraps validator.js for RFC-compliant checks.

import { body } from 'express-validator';

app.post('/register',
  body('email').isEmail(),
  (req, res) => { /* ... */ }
);

Use the built-in Validators.email which follows the HTML5 email spec.

import { Validators } from '@angular/forms';

this.form = this.fb.group({
  email: ['', [Validators.required, Validators.email]]
});

Use Ecto changeset validations to check email format.

def changeset(user, attrs) do
  user
  |> cast(attrs, [:email])
  |> validate_required([:email])
  |> validate_format(:email, ~r/^[^\s]+@[^\s]+\.[^\s]+$/)
end

Use native HTML5 email input for client-side validation. For API routes, use validator.js.

// Client-side (React component)
<input type="email" name="email" required />

// Server-side (API route)
import validator from 'validator';
if (!validator.isEmail(req.body.email)) {
  return res.status(400).json({ error: 'Invalid email' });
}

Use Vuelidate's built-in email validator.

import { required, email } from '@vuelidate/validators';

const rules = {
  email: { required, email }
};

Use the binding:"email" struct tag which validates using the go-playground/validator package.

type RegisterInput struct {
    Email string `json:"email" binding:"required,email"`
}