PHP Email Validation Tutorial

Before we can write a validation function for validating emails, we need to think of a definition of a valid email. Which is not that hard, in general we could say an email should be structured like this:

user@provider.lan

Where 'user' and 'provider' can be any string containing alphabetical characters, numbers and undercores. However we cannot be sure this way whether the 'provider.lan' provided, would be a valid one. For example:

someuser@a4g98si3m.x0a

would match our requirements for a valid email (if we used the definement as mentioned above ). However if we defined that 'provider' should be one out of a list ( for example: "hotmail | live | gmail" ) we might find ourself rejecting a valid email with a provider which we don't have in our list of valid ones but which does exist. Therefore, in this tutorial, I'll show 2 ways to validate an email: the 'rough' way ( which just requires the email to be like the first format ) and the more 'precise' way ( by specifying the providers that are valid ). Let's first create a validation pattern for a simple email validation.

Note: of course it's also a possibility to actually use the php mail function to send an email to the email provided, and this way verify whether the email was correct. But that's probably not the desired method here, and we'll here discuss only the regular expressions matching method.

As we've seen above, a valid email could be (simplified) defined as:

[alphabetical, numeric characters or (under)cores, dots]@[alphabetical, numeric characters or undercores].[alphabetical, numeric characters]

Which is in regular expressions:

^[A-Za-z0-9_\-\.]+\@[A-Za-z0-9_\-]+\.[A-Za-z0-9]+$

Where ^ defines the start and $ the end of the string ( email ). Between brackets we put the characters allowed and behind the brackets we put the amount of times a character from this selection may occur (+ = atleast once). Since a dot is a special regular expression sign, we have to escape it by putting a backslash before it ( this way it's seen as a litteral character and not a sign with any meaning ). The same goes for the - and @ signs.

If we want the extension of the email to be atleast 2 and max 4 characters long, the pattern would be:

^[A-Za-z0-9_\-\.]+\@[A-Za-z0-9_\-]+\.[A-Za-z0-9]{2-4}$

Another posibility for validating the 'extension' of the email (.com/.net/etc.) would be to match it with a list of valid ones. For example:

^[A-Za-z0-9_\-\.]+\@[A-Za-z0-9_\-]+\.(com|net|org|nl|uk)$

which would allow all emails with .com, .net, .org, .nl and .uk extensions, while our previous regular expression would allow any extension ( also invalid ones ).

It's also possible to define a list of valid providers with which the email's provider should match. We can do this the same way as we've done it for the email extensions:

^[A-Za-z0-9_\-\.]+\@[hotmail|live|gmail]+\.(com|net|org|nl|uk)$

However this way the combination of an email provider and extension does not matter. For example: gmail.com would be valid, but also gmail.net. We don't actually want this and therefore we'll combine them (only allowing valid combinations of email provider and extension):

^[A-Za-z0-9_\-\.]+\@(hotmail\.com|live\.nl|gmail\.com)$

Now we've created 2 types of patterns for the email validation (ending up in about 3 or 4 different patterns). We can now use these patterns to match an email using the PHP built-in function called preg_match. In this example we'll use the first pattern we created for validating an email (the simple one) but you can replace it with any of the patterns we created in this tutorial ( up to your preferance ).

<?php
//define the email validation pattern
$pattern = "^[A-Za-z0-9_\-\.]+\@[A-Za-z0-9_\-]+\.[A-Za-z0-9]+$";

//define a test email to validate
$email = "valid-email1@hotmail.com";
//validate the email
if(preg_match("/{$pattern}/", $email)) {
echo "<p>{$email} is a valid email.</p>";
}else{
echo "<p>{$email} is an invalid email.</p>";
}

$email = "invalid'email@abc.com";
if(preg_match("/{$pattern}/", $email)) {
echo "<p>{$email} is a valid email.</p>";
}else{
echo "<p>{$email} is an invalid email.</p>";
}

$email = "anotherinvalidemial@something";
if(preg_match("/{$pattern}/", $email)) {
echo "<p>{$email} is a valid email.</p>";
}else{
echo "<p>{$email} is an invalid email.</p>";
}
?>

This could also be created into a simple small function:

<?php
function validateEmail($email) {
$pattern = "^[A-Za-z0-9_\-\.]+\@[A-Za-z0-9_\-]+\.[A-Za-z0-9]+$";
if(preg_match("/{$pattern}/", $email)) {
return TRUE;
}else{
return FALSE;
}
}
?>

Note: To use one of the other patterns we created in this lens ( the more precise ones ) and edit them to your likes, is also possible. Then just replace the simplefied pattern in the code with the more precise pattern we created last.