LanguagesPHPDebugging PHP

Debugging PHP

If you have ever written your own scripts in PHP or another programming language, you know the frustration that comes from debugging your work.

Write an HTML page and leave off a closing </table> tag, or even something vital like the <body> tag, and most of the browsers in use today will display the page as you intended, even with the errors. But programming languages in general – and PHP specifically – are not nearly as forgiving; leaving off even a single semi-colon can stop the execution of the entire script.

In this article, you’ll learn more about programming errors and the types of core error handling features PHP offers. You’ll also learn a few tips and tricks for troubleshooting common errors in your own scripts.

Types of Errors

Generally speaking, there are two types of errors in programming: Syntax Errors and Logical Errors.

A syntax error is a lot like a grammatical error in a sentence; something that you have written (or omitted) has broken the rules of the language. Common mistakes such as missing semi-colons, mismatched or un-escaped quotes are all good examples. Because a statement is either formed correctly or incorrectly, syntax errors are objective, and the easiest to troubleshoot.

Logical errors, on the other hand, are far more insidious. These occur when the flow of the application has been incorrectly conceived or programmed. It is easy to see when one exists because the script does not produce the desired results, but hard to isolate and fix because no error messages are produced (at least not directly).

Preventing and Resolving Errors

Prevention of logical errors should begin before a single line of code is written, especially on larger projects that have more contingent programming. By outlining each of your scripts using pseudo code, much like you might outline a speech or essay you were planning to write, you can develop a framework to follow when you begin scripting.

For example, if you were writing a script that accepts input from a user in a form and then emails the information, the pseudo code might look something like this:

If the form has been submitted, then
   Check to see if all the fields are filled out. If they are, then
      Email the form contents
      Display a thank you page
      Exit the script
   If they aren’t
      Create an error message

Display the form

As you can see, though written in such a way that even a layman could follow, this pseudo code bares strong resemblance to a standard PHP if statement.

Because a framework like this addresses all the logical aspects of the script’s program flow in advance, following it during the programming process helps you stay on track and naturally minimizes logical errors. When you become more familiar with the logical apsects of programming, you can rely less on an outline process in advance. For large projects, it typically becomes necessary only to outline which scripts you plan to write, and what their functions should be.

Unlike logical errors, syntax errors seem to stubbornly defy prevention, even for the most experienced programmer. They pop up as typos, misnamed variables and accidental omissions. The trick to handling them is being able to quickly isolate and fix them. Generally, this is easy to do because PHP terminates with an error message citing the line number and type of error; most times it’s just a matter of knowing what to look for. Below are a few common PHP error messages:

General Parse Errors

Parse error: parse error, unexpected T_… in /home/httpd/www/index.php on line 3
Parse error
: parse error, unexpected T_… in /home/httpd/www/index.php on line 4

Parse errors usually offer little clue to the exact problem (although error messages in the latest versions of PHP are becoming more specific), but do give you the correct line number to look at most times. Check for missing semi-colons, quotes and parentheses as well as mismatched quotes on the line specified in the error, as well as those directly before it.

If the parse error message references the last line of the file or a line where there is no PHP, it usually means that you have forgotten a closing bracket ( }) on a loop or if-else statement.

Header Errors

Warning: Cannot send . – headers already sent (output started at /home/httpd/www/index.php:2) in /home/httpd/www/index.php on line 5

This type of error occurs when you attempt to send header information after you have already outputted information to the browser through PHP or with HTML. This applies not only to the header() function, but also to cookie and session functions.

Paremeter Count Errors (functions)

Warning: Wrong parameter count for explode() in /home/httpd/www/index.php on line 5

Unless specifically set up to accept a variable number of arguments, functions in PHP require that the number of arguments being passed to them match the number specificed in the function declaration. Especially in PHP’s pre-defined functions, be sure that you have not left off or added an additional argument.


PHP’s Error Handling Features

In the development phase of creating an application, having notices and errors displayed in the browser is vital. When the project is live, though, displaying errors to users is frequently undesirable, especially since error messages can contain run-time information about the server and script. Depending on what it is, this information can be a boon to potential hackers. This is just one of the reasons that PHP provides flexible options for controlling when, how, and which errors messages are displayed.

As you may have noticed from the sample error messages in the previous section, PHP divides syntax errors into three separate groups: Parse Errors, Notices and Warnings. Parse Errors are classified irrecoverable errors which stop the execution of the script, while Notices and Warnings are less serious and do not stop the script.

To allow the internal settings and functions to control how errors are reported, PHP assigns constants and values to each of the various types of errrors. The following have been available since PHP3:

1 E_ERROR Irrecoverable Error (script terminates)
2 E_WARNING Run time Error (script will not terminate)
4 E_PARSE Parse errors at the time of complition
8 E_NOTICE Notices, less serious than a warning.
  E_ALL All error messages.

And these were added in PHP4:

16 E_CORE_ERROR A fatal error during PHP’s startup.
32 E_CORE_WARNING Warning during PHP’s initial startup.
64 E_COMPILE_ERROR Irrecoverable error during compliation
128 E_COMPILE_WARNING Warning during compilation
256 E_USER_ERROR User error message
512 E_USER_WARNING User warning
1024 E_USER_NOTICE User notice

The PHP.ini is the primary location for controlling error reporting options and contains several settings to manage them; including error_reporting, display_errors, and error_log.

The first, error_reporting, uses the constants listed above, and several logical operators (“|”,”~”, “!” and “&”) to build up an expression describing which errors should be displayed. For example, the default setting in PHP4 is: E_ALL & ~E_NOTICE. This indicates that all error messages should be shown, except for notices.

When set to “off”, the display_errors suppresses all Parse Errors, Warnings, and Notices that would normally be sent to the browser. This setting works in conjunction with error_log, which allows you to specify that errors should be saved to the server’s error log.

Errors reporting settings can also be set on a script-by-script basis using the error_reporting() function. The rules defined by this function are only in affect for as long as the script runs. This is especially useful in situations where you may want to display errors in a particular script for development and debugging, but suppress them once the script is ready to go live without making global changes in your PHP.ini. error_reporting() accepts constant names (the encouraged method) in combination, as in the PHP.ini, as well as their integer values:

error_reporting(0); – turns off all error reporting.
error_reporting(E_ALL); – turns on all error reporting.
error_reporting(E_ERROR | E_WARNING); – shows critical errors and warnings only.

You can also suppress errors generated by a particular expression within a script by including the proceeding it with the @ symbol. For example: @unlink($file);

Keep in mind that even if you supress errors through any of the above methods, a script will still stop executing should the PHP processor encounter a critical error.

A Note on Creating Your Own Error Messages

You may have noticed that some of the error constants in the previous section referred to user created errors. Though beyond the scope of this article (and the needs of most new PHP programmers), keep in mind that PHP also provides advanced functions which allow you to create and impliment your own error messages. For simple scripts the need to add custom error handling is questionable, but in full-fledged applications the benefits become more apparent. By creating your own error handling functions, you can control the output; for example, you could provide contact information for the adminstrator of the server, or redirect the user to another location. You could also send out an email to notify you if a critical error had occured.

The set_error_handler() function allows you to build in this functionability to your own scripts.


Hopefully, this article has armed you with the knowledge to intelligently manage and combat errors in your own scripts. Avoiding, and understanding how to quickly troubleshoot errors in your work will greatly decrease the time it takes to get a script from the development phase to afinished product.

In the next article, we will be taking a look at some more theory of programming with PHP, covering aspects of coding style.

Stay Tuned!

Things to remember:

  • Generally, there are two types of errors: syntax errors and logical errors.
  • You can help prevent logical errors by outlining your project with pseudo code before you begin
  • Syntax errors are frequently accidental, and thus more difficult to prevent.
  • PHP has core error handling features that allow you to control error message output.
  • For the purposes of error reporting, PHP divides syntax errors into three groups: Errors, warnings, and notices.
  • Error handling can be set up in the PHP.ini and in the running script.
  • @ before an expression in a script supresses any errors, notices or warnings that might otherwise appear.

Liz Fulghum currently lives in Annapolis, MD where she works as a web designer for a custom shirt retailer. Liz was convinced to try PHP as an alternative to Perl; she has been a fan ever since and frequently works as a freelance developer.

# # #

Get the Free Newsletter!

Subscribe to Developer Insider for top news, trends & analysis

Latest Posts

Related Stories