15
PHP & Regular Expressions
What is a Regular Expression?
What do you think it is that separates programs like BBEdit and notepad from the good old console-based text editors? Both support text input and let you save that text into a file, however modern text editors also support other functionality including find & replace tools, which makes editing a text file so much easier.
Regular expressions are similar to this functionality, only better. Think of a regular expression as an extremely advanced find & replace tool that saves us the pain of having to write custom data validation routines to check e-mail addresses, make sure phone numbers are in the correct format, etc.
One of the most common functions of any program is data validation, and PHP comes bundled with several text validation functions that allow us to match a string using regular expressions, making sure there’s a space in a particular spot, a question mark in another spot, etc.
What you may not know however, is that regular expressions are simple to implement, and once you’ve mastered a few regular expressions (which are specially formatted strings that we can use to tell the regular expression engine the portion of a string we want to match) you’ll be asking yourself why you left regular expressions in the corner for so long.
PHP has two sets of functions for dealing with the two types of regular expression patterns: Perl 5 compatible patterns, and Posix standard compatible patterns. In this article we will be looking at the ereg function and working with search expressions that conform to the Posix standard. Although they don’t offer as much power as Perl 5 patterns, they’re a great way to start learning regular expressions. If you’re interested in PHP’s support for Perl 5 compatible regular expressions, then see the PHP.net site for details on the preg set of PHP functions.
PHP has six functions that Why Use Regular Expressions?
If you’re constantly creating functions to validate or manipulate portions of a string, then you might be able to scrap all of these functions and use regular expressions instead. If you answer yes to any of the questions shown below, then you should definitely consider using regular expressions:
- Are you writing custom functions to make sure form data contains valid information (such as an @ and a dot in an e-mail address)?
- Do you write custom functions to loop through each character in a string and replace it if it matches a certain criteria (such as if it’s upper case, or if it’s a space)?
Besides being unfavored methods for string validation and manipulation, the two points shown above can also slow your program down if coded inefficiently. Would you rather use this code to validate an e-mail address:
<?php
function validateEmail($email)
{
$hasAtSymbol = strpos($email, “@”);
$hasDot = strpos($email, “.”);
if($hasAtSymbol && $hasDot)
return true;
else
return false;
}echo validateEmail(“mitchell@interspire.com”);
?>
… or this code:
<?php
function validateEmail($email)
{
return ereg(“^[a-zA-Z]+@[a-zA-Z]+.[a-zA-Z]+$”, $email);
}
echo validateEmail(“mitchell@interspire.com”);
?>
Sure, the first function looks easier and seems well structured, but wouldn’t it be easier if we could validate an e-mail address using the one-lined version of the validateEmail function shown above?
The second function shown above uses regular expressions only, and contains one call to the ereg function. The ereg function always returns only true or false, indicating whether its string argument matched the regular expression or not
Many programmers steer clear of regular expressions because they are (in
The Regular Expression Syntax
Before you can match a string to a regular expression, you have to <?php echo ereg(“^hello”, “hello world!”); ?>
Would return true, however
<?php echo ereg(“^hello”, “i say hello world”); ?>
would return false, because hello wasn’t at the beginning of the string.
End of string:
To search at the end of a string, use $. For example,
<?php echo ereg(“bye$”, “goodbye”); ?>
Would return true, however
<?php echo ereg(“bye$”, “goodbye my friend”); ?>
would return false, because bye wasn’t at the very end of the string.
Any single character:
To search for any character, use the dot. For example,
<?php echo ereg(“.”, “cat”); ?>
would return true, however
<?php echo ereg(“.”, “”); ?>
would return false, because our search string contains no characters. You can optionally tell the regular expression engine how many single characters it should match using curly braces. If I wanted a match on five characters only, then I would use ereg like this:
<?php echo ereg(“.{5}$”, “12345″); ?>
The code above tells the regular expression engine to return true if and only if at least five successive characters appear at the end of the string. We can also limit the number of characters that can appear in successive order:
<?php echo ereg(“a{1,3}$”, “aaa”); ?>
In the example above, we have told the regular expression engine that in order for our search string to match the expression, it should have between one and three ‘a’ characters at the end.
<?php echo ereg(“a{1,3}$”, “aaab”); ?>
The example above wouldn’t return true, because there are three ‘a’ characters in the search string, however they are not at the end of the string. If we took the end-of-string match $ out of the regular expression, then the string would match.
We can also tell the regular expression engine to match at least a certain amount of characters in a row, and more if they exist. We can do so like this:
<?php echo ereg(“a{3,}$”, “aaaa”); ?>
Repeat character zero or more times
To tell the regular expression engine that a character may exist, and can be repeated, we use the * character. Here are two examples that would return true:
<?php echo ereg(“t*”, “tom”); ?>
<?php echo ereg(“t*”, “fom”); ?>
Even though the second example doesn’t contain the ‘t’ character, it still returns true because the * indicates that the character may appear, and that it doesn’t have to. In fact, any normal string pattern would cause the second call to ereg above to return true, because the ‘t’ character is optional.
Repeat character one or more times
To tell the regular expression engine that a character must exist and that it can be repeated more than once, we use the + character, like this:
<?php echo ereg(“z+”, “i like the zoo”); ?>
The following example would also return true:
<?php echo ereg(“z+”, “i like the zzzzzzoo!”); ?>
Repeat character zero or one times
We can also tell the regular expression engine that a character must either exist just once, or not at all. We use the ? character to do so, like this:
<?php echo ereg(“c?”, “cats are fuzzy”); ?>
If we wanted to, we could even entirely remove the ‘c’ from the search string shown above, and this expression would still return true. The ‘?’ means that a ‘c’ may appear anywhere in the search string, but doesn’t have to.
The space character
To match the space character in a search string, we use the predefined Posix class, [[:space:]]. The square brackets indicate a related set of sequential characters, and “:space:” is the actual class to match (which, in this case, is any white space character). White spaces include the tab character, the new line character, and the space character. Alternatively, you could use one space character (” “) if the search string must contain just one space and not a tab or new line character. In most circumstances I prefer to use “:space:” because it signifies my intentions a bit better than a single space character, which can easy be overlooked. There are several Posix-standard predefined classes that we can match as part of a regular expression, including [:alnum:], [:digit:], [:lower:], etc. A complete list is available here.
We can match a single space character like this:
<?php echo ereg(“Mitchell[[:space:]]Harper”, “Mitchell Harper”); ?>
We could also tell the regular expression engine to match either no spaces or one space by using the ? character after the expression, like this:
<?php echo ereg(“Mitchell[[:space:]]?Harper”, “MitchellHarper”); ?>
Grouping patterns
Related patterns can be grouped together between square brackets. It’s really easy to specify that a lower case only or upper case only sequence of characters should exist as part of the search string using [a-z] and [A-Z], like this:
<?php
// Require all lower case characters from first to last
echo ereg(“^[a-z]+$”, “johndoe”); // Returns true
?>
or like this:
<?php
// Require all upper case characters from first to last
ereg(“^[A-Z]+$”, “JOHNDOE”); // Returns true
?>
We can also tell the regular expression engine that we expect either lower case or upper case characters. We do this by joining the [a-z] and [A-Z] patterns:
<?php echo ereg(“^[a-zA-Z]+$”, “JohnDoe”); ?>
In the example above, it would make sense if we could match “John Doe,” and not “JohnDoe.” We can use the following regular expression to do so:
^[a-zA-Z]+[[:space:]]{1}[a-zA-Z]+$
It’s just as easy to search for a numerical string of characters:
<?php echo ereg(“^[0-9]+$”, “12345″); ?>
Grouping terms
It’s not only search patterns that can be grouped together. We can also group related search terms together using parentheses:
<?php echo ereg(“^(John|Jane).+$”, “John Doe”); ?>
In the example above, we have a beginning of string character, followed by “John” or “Jane”, at least one other character, and then the end of string character. So …
<?php echo ereg(“^(John|Jane).+$”, “Jane Doe”); ?>
… would also match our search pattern.
Special character circumstances
Because several characters are used to actually specify the grouping or syntax of a search pattern, such as the parentheses in (John|Jane), we need a way to tell the regular expression engine to ignore these characters and to process them as if they were part of the string being searched and not part of the search expression. The method we use to do this is called “character escaping” and involves propending any “special symbols” with a backslash. So, for example, if I wanted to include the or symbol ‘|’ in my search, then I could do so like this:
<?php echo ereg(“^[a-zA-z]+|[a-zA-z]+$”, “John|Jane”); ?>
There are only a handful of symbols that you have to escape. You must escape ^, $, (, ), ., [, |, *, ?, +, and {.
Hopefully you've now gotten a bit of a feel for just how powerful regular expressions actually are. Let's now take a look at two examples of using regular expressions to validate a string of data.
Regular Expression Examples
Example One
Let's keep the first example fairly simple, and validate a standard URL. A standard URL (with no port number) consists of three parts:
[protocol]://[domain name]
Let’s start by matching the protocol part of the URL. Let’s make it so that only http or ftp can be used. We would use the following regular expression to do so:
^(http|ftp)
The ^ character specifies the beginning of the string, and by enclosing http and ftp in brackets and separating them with the or character (|), we are telling the regular expression engine that either the characters http or ftp must be at the beginning of the string.
A domain name usually consists of www.somesite.com, but can optionally be specified without the www part. To keep our example simple, we will only allow .com, .net, and .org domain names to be considered valid. We’d represent the search term for the domain name part of our regular expression like this:
(www.)?.+.(com|net|org)$
Putting everything together, our regular expression could be used to validate a domain name, like this:
<?php
function isValidDomain($domainName)
{
return ereg(“^(http|ftp)://(www.)?.+.(com|net|org)$”, $domainName);
}
//true
echo isValidDomain(“http://www.somesite.com”);
//true
echo isValidDomain(“ftp://somesite.com”);
//false
echo isValidDomain(“ftp://www.somesite.fr”);
//false
echo isValidDomain(“www.somesite.com”);
?>
Example Two
Because I reside in Sydney Australia, let’s validate a typical international Australian phone number. The format of an international Australian phone number looks like this:
+61x xxxx-xxxx
The first ‘x’ is the area code, and the rest is the phone number. To validate that the start of the phone number is ‘+61′ and that it is followed by an area code between two and nine, we use the following regular expression:
^+61[2-9][[:space:]]
Notice in the search pattern above that the ” escapes the ‘+’ symbol so that it is [0-9]{4}-[0-9]{4}$
Nothing out of the ordinary here, we’re just telling the regular expression engine that for the phone number to be valid, it must have a group of four digits, followed by a hyphen, followed by another group of four digits and then an end of string character.
Putting the entire regular expreesion together into a function, we can use the code to validate <?php
function isValidPhone($phoneNum)
{
echo ereg(“^+61[2-9][[:space:]][0-9]{4}-[0-9]{4}$”, $phoneNum);
}
// true
echo isValidPhone(“+619 0000-0000″);
// false
echo isValidPhone(“+61 00000000″);
// false
echo isValidPhone(“+611 00000000″);
?>
Conclusion
Regular expressions take a lot of the hassle out of writing lines and lines of repetitive code to validate a string. Over the last few pages we’ve covered all of the basics of Posix standard regular expression patterns including symbols, grouping and the PHP ereg function.
We’ve also seen how to use the regular expression engine to validate some simple strings in PHP.