Regular expressions are nothing more than a sequence or pattern of
characters itself. They provide the foundation for pattern-matching
functionality.
Using regular expression you can search a particular string inside a
another string, you can replace one string by another string and you
can split a string into many chunks.
PHP offers functions specific to two sets of regular expression
functions, each corresponding to a certain type of regular expression.
You can use any of them based on your comfort.
- POSIX Regular Expressions
- PERL Style Regular Expressions
POSIX Regular Expressions:
The structure of a POSIX regular expression is not dissimilar to
that of a typical arithmetic expression: various elements (operators)
are combined to form more complex expressions.
The simplest regular expression is one that matches a single character, such as g, inside strings such as g, haggle, or bag.
Lets give explaination for few concepts being used in POSIX regular
expression. After that we will introduce you wih regular expression
related functions.
Brackets
Brackets ([]) have a special meaning when used in the context of
regular expressions. They are used to find a range of characters.
| Expression | Description |
| [0-9]
|
It matches any decimal digit from 0 through 9.
|
| [a-z]
|
It matches any character from lowercase a through lowercase z.
|
| [A-Z]
|
It matches any character from uppercase A through uppercase Z.
|
| [a-Z]
|
It matches any character from lowercase a through uppercase Z.
|
The ranges shown above are general; you could also use the range
[0-3] to match any decimal digit ranging from 0 through 3, or the range
[b-v] to match any lowercase character ranging from b through v.
Quantifiers:
The frequency or position of bracketed character sequences and
single characters can be denoted by a special character. Each pecial
character having a specific connotation. The +, *, ?, {int. range}, and
$ flags all follow a character sequence.
| Expression | Description |
| p+
|
It matches any string containing at least one p.
|
| p*
|
It matches any string containing zero or more p's.
|
| p?
|
It matches any string containing zero or more p's. This is just an alternative way to use p*.
|
| p{N}
|
It matches any string containing a sequence of N p's
|
| p{2,3}
|
It matches any string containing a sequence of two or three p's.
|
| p{2, }
|
It matches any string containing a sequence of at least two p's.
|
| p$
|
It matches any string with p at the end of it.
|
| ^p
|
It matches any string with p at the beginning of it.
|
Examples:
Following examples will clear your concepts about matching chracters.
| Expression | Description |
| [^a-zA-Z]
|
It matches any string not containing any of the characters ranging from a through z and A through Z.
|
| p.p
|
It matches any string containing p, followed by any character, in turn followed by another p.
|
| ^.{2}$
|
It matches any string containing exactly two characters.
|
| <b>(.*)</b>
|
It matches any string enclosed within <b> and </b>.
|
| p(hp)*
|
It matches any string containing a p followed by zero or more instances of the sequence hp.
|
Predefined Character Ranges
For your programming convenience several predefined character
ranges, also known as character classes, are available. Character
classes specify an entire range of characters, for example, the
alphabet or an integer set:
| Expression | Description |
| [[:alpha:]]
|
It matches any string containing alphabetic characters aA through zZ.
|
| [[:digit:]]
|
It matches any string containing numerical digits 0 through 9.
|
| [[:alnum:]]
|
It matches any string containing alphanumeric characters aA through zZ and 0 through 9.
|
| [[:space:]]
|
It matches any string containing a space.
|
PHP's Regexp POSIX Functions
PHP currently offers seven functions for searching strings using POSIX-style regular expressions:
| Function | Description |
| ereg()
|
The ereg() function searches a string specified by string for a string
specified by pattern, returning true if the pattern is found, and false
otherwise.
|
| ereg_replace()
|
The ereg_replace() function searches for string specified by pattern and replaces pattern with replacement if found.
|
| eregi()
|
The eregi() function searches throughout a string specified by
pattern for a string specified by string. The search is not case
sensitive.
|
| eregi_replace()
|
The eregi_replace() function operates exactly like ereg_replace(),
except that the search for pattern in string is not case sensitive.
|
| split()
|
The split() function will divide a string into various elements,
the boundaries of each element based on the occurrence of pattern in
string.
|
| spliti()
|
The spliti() function operates exactly in the same manner as its sibling split(), except that it is not case sensitive.
|
| sql_regcase()
|
The sql_regcase() function can be thought of as a utility function,
converting each character in the input parameter string into a
bracketed expression containing two characters.
|
PERL Style Regular Expressions:
Perl-style regular expressions are similar to their POSIX
counterparts. The POSIX syntax can be used almost interchangeably with
the Perl-style regular expression functions. In fact, you can use any
of the quantifiers introduced in the previous POSIX section.
Lets give explaination for few concepts being used in PERL regular
expressions. After that we will introduce you wih regular expression
related functions.
Metacharacters
A metacharacter is simply an alphabetical character preceded by a backslash that acts to give the combination a special meaning.
For instance, you can search for large money sums using the '\d' metacharacter:
/([\d]+)000/, Here
\d will search for any string of numerical character.
Following is the list of metacharacters which can be used in PERL Style Regular Expressions.
Character Description
. a single character
\s a whitespace character (space, tab, newline)
\S non-whitespace character
\d a digit (0-9)
\D a non-digit
\w a word character (a-z, A-Z, 0-9, _)
\W a non-word character
[aeiou] matches a single character in the given set
[^aeiou] matches a single character outside the given set
(foo|bar|baz) matches any of the alternatives specified
|
Modifiers
Several modifiers are available that can make your work with regexps
much easier, like case sensitivity, searching in multiple lines etc.
Modifier Description
i Makes the match case insensitive
m Specifies that if the string has newline or carriage
return characters, the ^ and $ operators will now
match against a newline boundary, instead of a
string boundary
o Evaluates the expression only once
s Allows use of . to match a newline character
x Allows you to use white space in the expression for clarity
g Globally finds all matches
cg Allows a search to continue even after a global match fails
Error handling is the process of catching errors raised by your
program and then taking appropriate action. If you would handle errors
properly then it may lead to many unforeseen consequences.
Its very simple in PHP to handle an errors.
Using die() function:
While wirting your PHP program you should check all possible error
condition before going ahead and take appropriate action when required.
Try following example without having /tmp/test.xt file and with this file.
<?php
if(!file_exists("/tmp/test.txt"))
{
die("File not found");
}
else
{
$file=fopen("/tmp/test.txt","r");
print "Opend file sucessfully";
}
// Test of the code here.
?>
|
This way you can write an efficient code. Using abive technique you
can stop your program whenever it errors out and display more
meaningful and user friendly meassage.
Defining Custom Error Handling Function:
You can write your own function to handling any error. PHP provides you a framwork to define error handling function.
This function must be able to handle a minimum of two parameters (error
level and error message) but can accept up to five parameters (optionally: file,
line-number, and the error context):
Syntax
| error_function(error_level,error_message, error_file,error_line,error_context);
|
| Parameter |
Description |
| error_level |
Required - Specifies the error report level for the user-defined error. Must be a value number. |
| error_message |
Required - Specifies the error message for the user-defined error |
| error_file |
Optional - Specifies the filename in which the error occurred |
| error_line |
Optional - Specifies the line number in which the error occurred |
| error_context |
Optional - Specifies an array containing every variable and their values in use when the error occurred |
Possible Error levels
These error report levels are the different types of error the
user-defined error handler can be used for. These values cab used in
combination using | operator
| Value |
Constant |
Description |
| 1 |
E_ERROR |
Fatal run-time errors. Execution of the script is halted |
| 2 |
E_WARNING |
Non-fatal run-time errors. Execution of the script is not halted |
| 4 |
E_PARSE |
Compile-time parse errors. Parse errors should only be generated by the parser. |
| 8 |
E_NOTICE |
Run-time notices. The script found something that might be
an error, but could also happen when running a script normally |
| 16 |
E_CORE_ERROR |
Fatal errors that occur during PHP's initial startup. |
| 32 |
E_CORE_WARNING |
Non-fatal run-time errors. This occurs during PHP's initial startup. |
| 256 |
E_USER_ERROR |
Fatal user-generated error. This is like an E_ERROR set by
the programmer using the PHP function trigger_error() |
| 512 |
E_USER_WARNING |
Non-fatal user-generated warning. This is like an E_WARNING
set by the programmer using the PHP function trigger_error() |
| 1024 |
E_USER_NOTICE |
User-generated notice. This is like an E_NOTICE set by the
programmer using the PHP function trigger_error() |
| 2048 |
E_STRICT |
Run-time
notices. Enable to have PHP suggest changes to your code which will
ensure the best interoperability and forward compatibility of your code. |
| 4096 |
E_RECOVERABLE_ERROR |
Catchable fatal error. This is like an E_ERROR but can be
caught by a user defined handle (see also set_error_handler()) |
| 8191 |
E_ALL |
All errors and warnings, except level E_STRICT (E_STRICT
will be part of E_ALL as of PHP 6.0) |
All the above error level can be set using following PHP built-in
library function where level cab be any of the value defined in above
table.
int error_reporting ( [int $level] )
|
Following is the way you can create one error handling function:
<?php
function handleError($errno, $errstr,$error_file,$error_line)
{
echo "<b>Error:</b> [$errno] $errstr - $error_file:$error_line";
echo "<br />";
echo "Terminating PHP Script";
die();
}
?>
|
Once you define your custom error handler you need to set it using PHP built-in library set_error_handler function. Now lets examine our example by calling a function which does not exist.
<?php
error_reporting( E_ERROR );
function handleError($errno, $errstr,$error_file,$error_line)
{
echo "<b>Error:</b> [$errno] $errstr - $error_file:$error_line";
echo "<br />";
echo "Terminating PHP Script";
die();
}
//set error handler
set_error_handler("handleError");
//trigger error
myFunction();
?>
|
Exceptions Handling:
PHP 5 has an exception model similar to that of other programming
languages. Exceptions are important and provides a better control over
error handling.
Lets explain thre new keyword related to exceptions.
- Try - A function using an exception should be in a "try"
block. If the exception does not trigger, the code will continue as
normal. However if the exception triggers, an exception is "thrown".
- Throw - This is how you trigger an exception. Each "throw" must have at least one "catch".
- Catch - - A "catch" block retrieves an exception and creates an object containing the exception information.
When an exception is thrown, code following the statement will not
be executed, and PHP will attempt to find the first matching catch
block. If an exception is not caught, a PHP Fatal Error will be issued
with an "Uncaught Exception ...
- An exception can be thrown, and caught ("catched") within PHP. Code may be surrounded in a try block.
- Each try must have at least one corresponding catch block.
Multiple catch blocks can be used to catch different classes of
exeptions.
- Exceptions can be thrown (or re-thrown) within a catch block.
Example:
Following is the piece of code, copy and paste this code into a file and verify the result.
<?php
try {
$error = 'Always throw this error';
throw new Exception($error);
// Code following an exception is not executed.
echo 'Never executed';
} catch (Exception $e) {
echo 'Caught exception: ', $e->getMessage(), "\n";
}
// Continue execution
echo 'Hello World';
?>
|
In the above example $e->getMessage function is uded to get error
message. There are following functions which can be used from Exception class.
- getMessage()- message of exception
- getCode() - code of exception
- getFile() - source filename
- getLine() - source line
- getTrace() - n array of the backtrace()
- getTraceAsString() - formated string of trace
Creating Custom Exception Handler:
You can define your own custome excpetion handler. Use following function to set a user-defined exception handler function.
string set_exception_handler ( callback $exception_handler )
|
Here exception_handler is the name of the function to be
called when an uncaught exception occurs. This function must be defined
before calling set_exception_handler().
Example:
<?php
function exception_handler($exception) {
echo "Uncaught exception: " , $exception->getMessage(), "\n";
}
set_exception_handler('exception_handler');
throw new Exception('Uncaught Exception');
echo "Not Executed\n";
?>
|
Check complete set of error handling functions at PHP Error Handling Functions
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
|
No comments:
Post a Comment