This tutorial will show you how to create a very simple form validation class using PHP. It is by no means meant to be exhaustive but it should give you a good grounding to build upon.
End result: Full form validation class using PHP
Take a look below for the entire validation class. If you don’t understand it at first glance don’t worry, an explanation of each function is presented further down the page.
class formValidate {
/**
* FormValidate Class by www.weebtutorials.com
* Written by John Richardson.
**/
//Returns true if empty, else returns false.
public static function isEmpty($string) {
//Check string length, if 0 then return empty
if ( strlen($string) === 0 ) {
return true;
}
//Otherwise the string is valid, return true
else {
return false;
}
}
//Returns true if $char in $string, otherwise returns false.
public static function containsChar($string, $char) {
//First of all check the datatype to confirm a string has been passed in
if ( is_string( $string ) ) {
//If so use string type to locate the character provided, returns false if it doesnt exist
if ( strpos($string, $char) ) {
return true;
}
else {
return false;
}
}
else {
return false;
}
}
//Checks that the string provided is a valid email address.
public static function validEmail($string) {
//First of all check the datatype to confirm a string has been passed in
if ( is_string( $string ) ) {
//Regular expression pattern.
//Pattern breakdown:
//** [a-zA-Z0-9_] - any character between a-z, A-Z or 0-9
//** + - require one or more of the preceeding item.
//** @{1} - Simply means 1 '@' symbol required.
//** [a-zA-Z]+ - any character between a-z, A-Z (1 or more required).
//** \.{1} - Single '.' required. Backslash escapes the '.'
//** [a-zA-Z]+ - One or more of the these characters required.
$pattern = "/^[a-zA-Z0-9_]+@{1}[a-zA-Z]+\.{1}[a-zA-Z]+/";
//If the pattern matches then return true, else email is invalid, return false.
if ( preg_match($pattern, $string) ){
return true;
}
else {
return false;
}
}
else {
return false;
}
}
//Takes a single allowed file type, or an array of values and checks against $filename
public static function validFileType($filename, $whitelist) {
//Check if array of values or single value
if ( is_array($whitelist) ) {
//string to hold allowed filetypes
$allowed ='';
//add each item in array to the string
foreach ( $whitelist as $filetype ) {
$allowed.= $filetype . "|";
}
}
else {
$allowed = $filename;
}
//Pattern breakdown:
//** \.{1} - single '.' required
//** [" . $allowed . "]+ - check for filetypes passed into parameter, 1 or more required.
//** $- String must end with this.
$pattern = "!\.{1}[" . $allowed . "]+$!";
//Valid file, return true.
if ( preg_match($pattern, $filename) ) {
return true;
}
//else invalid file type.
else {
return false;
}
}
//Checks if $string is as long, or longer than $minLength. IF $exact is passed
//in, then function looks for exact match in length.
public static function validLength($string, $minLength, $exact = 0) {
//Looking for exact match
if ($exact) {
if ( strlen($string) == $minLength ) {
return true;
}
else {
return false;
}
}
//Minimum length
if ( strlen($string) >= $minLength ) {
return true;
}
else {
return false;
}
}
}
Method 1: Use PHP toCheck if the string is empty
//Returns true if empty, else returns false.
public static function isEmpty($string) {
//Check string length, if 0 then return empty
if ( strlen($string) === 0 ) {
return true;
}
//Otherwise the string is valid, return true
else {
return false;
}
}The way in which this method is built should become familiar fairly quickly.Why? It’s used throughout the rest of the tutorial. The first thing to note is that the function has been declared with a static access modifier. This means that the method can be accessed or called without its parent class ever being instantiated.
The function body consists of a simple ‘if’ statement which checks if the string passed in has a length of 0. If so it returns true as the string is empty. If not it returns false. The code below shows this function can be used.
if ( !formValidate::isEmpty("a") ) {
echo "<p> Not empty </p>";
}
Method 2: Use PHP to check if the string contains a specific character.
//Returns true if $char in $string, otherwise returns false.
public static function containsChar($string, $char) {
//First of all check the datatype to confirm a string has been passed in
if ( is_string( $string ) ) {
//If so use string type to locate the character provided, returns false if it doesnt exist
if ( strpos($string, $char) ) {
return true;
}
else {
return false;
}
}
else {
return false;
}
}This method accepts 2 parameters, a String and a Character. The first conditional statement confirms that the data passed in is a String, the second checks for the existance of a character and returns true or false based on this. To do this, the function uses the ‘strpos’ function. This function is normally used to locate the numerical position (of the first occurance) of a character within a given string. However, if the character is not found it returns false.
An example of how this function can be used:
if ( formValidate::containsChar("ball", "a" ) ) {
echo "<p> Valid </p>";
}
Method 3: Create PHP function that uses regular expression to confirm if an e-mail address is valid.
//Checks that the string provided is a valid email address.
public static function validEmail($string) {
//First of all check the datatype to confirm a string has been passed in
if ( is_string( $string ) ) {
//Regular expression pattern.
//Pattern breakdown:
//** [a-zA-Z0-9_] - any character between a-z, A-Z or 0-9
//** + - require one or more of the preceeding item.
//** @{1} - Simply means 1 '@' symbol required.
//** [a-zA-Z]+ - any character between a-z, A-Z (1 or more required).
//** \.{1} - Single '.' required. Backslash escapes the '.'
//** [a-zA-Z]+ - One or more of the these characters required.
$pattern = "/^[a-zA-Z0-9_]+@{1}[a-zA-Z]+\.{1}[a-zA-Z]+/";
//If the pattern matches then return true, else email is invalid, return false.
if ( preg_match($pattern, $string) ){
return true;
}
else {
return false;
}
}
else {
return false;
}
}The key to understanding this function is regular expression, the rest is very straight forward – the function simply checks if the data provided is a string and then uses regular expression to do the rest.
In computing, a regular expression provides a concise and flexible means to “match” (specify and recognize) strings of text, such as particular characters, words, or patterns of characters. Common abbreviations for “regular expression” include regex and regexp.
The ‘preg_match’ function accepts 2 parameters, the first being the pattern for which to search. The second being the subject to look upon. If you’re new to regular expression you will probably need to go read some beginner tutorials related to the subject, that is outside the scope of this tutorial. For some immediate guidance though, check out the comments in the source code and take a look at this regular expression cheat sheet.
An example of how you could use this function:
//valid
if ( formValidate::validEmail("johnrich5@mail.com") ) {
echo "<p> Valid Email</p>";
}
//invalid
if ( formValidate::validEmail("johnrich5mail.com") ) {
echo "<p> Invalid Email</p>";
}
Method 4: Create PHP function that checks a file against a whitelist of accepted file types.
//Takes a single allowed file type, or an array of values and checks against $filename
public static function validFileType($filename, $whitelist) {
//Check if array of values or single value
if ( is_array($whitelist) ) {
//string to hold allowed filetypes
$allowed ='';
//add each item in array to the string
foreach ( $whitelist as $filetype ) {
$allowed.= $filetype . "|";
}
}
else {
$allowed = $filename;
}
//Pattern breakdown:
//** \.{1} - single '.' required
//** [" . $allowed . "]+ - check for filetypes passed into parameter ($allowed), 1 or more required.
//** $- String must end with this.
$pattern = "!\.{1}[" . $allowed . "]+$!";
//Valid file, return true.
if ( preg_match($pattern, $filename) ) {
return true;
}
//else invalid file type.
else {
return false;
}
}This function is somewhat flexible in that it will either accept a single file type, for example ‘jpg’, or an array of filetypes. To make this possible the function first checks if the variable passed into it is an array. If so, it loops through the array saving the filetypes to a string; each item separated by the ‘|’ character. The reason behind separating the file types this way is so it string can be used within a regular expression pattern – ‘|’ being interpreted as ‘or’ within a regular expression pattern.
Again, refer to the comments within the code to get an understanding of the pattern used. An example of how the function can be used is below:
//Using array
if ( formValidate::validFileType( "test_jpg.jpg", array("png", "jpg", "gif") ) ) {
echo "<p> Valid Filetype</p>";
}
//Single value
if ( formValidate::validFileType( "test_jpg.gif", "gif" ) ) {
echo "<p> Valid Filetype</p>";
}
Method 5: Create PHP function that checks if a given string is long enough.
/Checks if $string is as long, or longer than $minLength. IF $exact is passed
//in, then function looks for exact match in length.
public static function validLength($string, $minLength, $exact = 0) {
//Looking for exact match
if ($exact) {
if ( strlen($string) == $minLength ) {
return true;
}
else {
return false;
}
}
//Minimum length
if ( strlen($string) >= $minLength ) {
return true;
}
else {
return false;
}
}This function does two things. First of all, it can check if a string is a specific length – useful if you need a password with exactly 7 characters for example. Secondly, it can be used to enforce a minimum length upon a string. This is achieved through use of an optional parameter, namely the ‘$exact’ parameter.
Notice in the function definition the ‘exact’ parameter is set to 0. Assigning a value to a parameter in this way makes it optional, and basically assigns a default value to the parameter. So, if no 3rd value is passed into the function then ‘$exact’ will have a value of 0.
As demonstrated in the function, it is then possible to use a conditional statement to run different code depending on the value of ‘$exact’.
How this function could be used:
if ( formValidate::validLength("johnsasd", "4") ) {
echo "<p> Long enough</p>";
}
if ( formValidate::validLength("john", "4", true) ) {
echo "<p> Exact match</p>";
}
Conclusion
The end result is a very simple form validation class using PHP. As mentioned at the start of the tutorial it is not meant to be an exhaustive class, but it should give you something to build upon and work with. Hope this was helpful and thanks for reading.
The post Make a simple form validation class using PHP. appeared first on Weebtutorials.