Errors in PHP: Types, Examples

In this tutorial, we will learn about common errors in PHP. Errors are an integral part of the programming and in many cases, they often act as our best teacher. They provide valuable insights into what went wrong in our code and help us to improve the quality of our programs.

When you write code in PHP, errors may occur if you violate the rules of the PHP language. These errors can arise due to several reasons, such as:

  • Incorrect syntax
  • Undefined variables, constants, or functions
  • Logical mistakes that produce unexpected results
  • Runtime issues, such as missing files, incorrect file paths, or database connection failures

Such issues may produce warnings, notices, or fatal errors. In some cases, they may simply display incorrect output, while in others, they may completely stop the execution of the script.

For example, if you mistakenly use a right parenthesis ) instead of a right brace } in PHP program, a syntax error will occur. In this case, the rules of the PHP language have been violated. The PHP interpreter will not execute the script because it cannot understand the structure of the code.

Therefore, it is extremely important to identify, debug, and fix all errors properly so that a PHP program runs smoothly without unexpected termination. Understanding different types of errors in PHP and how to handle them is essential for developing efficient, secure, and bug-free applications.

Why Error Handling Is Important in PHP

Proper error handling in PHP is important for several reasons:

  • It helps identify bugs quickly during the development phase.
  • It prevents unexpected application crashes.
  • It improves application security by avoiding the exposure of sensitive information.
  • It provides a better and more user-friendly experience to the users.
  • It helps log errors for future analysis and debugging.

Types of Errors in PHP

PHP errors are mainly divided into the following types:

  • Parse Errors (Syntax Errors)
  • Fatal Errors
  • Warning Errors
  • Notice Errors
  • Deprecated Errors
  • User-Generated Errors

Let’s discuss each one in detail.
[blocksy-content-block id=”12371″]

1. Parse Errors (Syntax Errors)

Parse errors, also known as Syntax errors, are the most common types of errors in PHP. They occur when PHP encounters invalid syntax in a script. These errors are caused by incorrect usage of PHP’s syntax rules and are detected before the script is executed. Syntax errors can occur due to variety of reasons such as:

  • Missing semicolons
  • Unmatched braces or parentheses
  • Incorrect use of quotes
  • Incorrect use of operators
  • Typographical mistakes and so on.

Example 1:

<?php
echo "Hello World"
?>

Output:

Parse error: syntax error, unexpected end of file

In this example:

  • The semicolon (;) is missing at the end of the echo statement, which causes a syntax error.
  • PHP will not parse this script and display am error message.

2. Fatal Errors

Fatal errors are critical errors in PHP that occur during the execution of a PHP script. When a fatal error occurs, PHP immediately stops the execution of the script, and no further code is executed. These errors usually occur when you attempt to:

  • Call an undefined function or method.
  • Access unavailable or invalid resources.
  • Access a non-existent class or interface.
  • Include or require missing files.

Example 2:

<?php
function greet(){
   echo "Hello World!";
}
greetWorld();
?>

Output:

PHP Fatal error:  Uncaught Error: Call to undefined function greetWorld()

In this example:

  • We have defined a function greet() but tried to call a non existing function greetWorld().
  • PHP cannot find this function and stops the execution immediately, resulting a fatal error.

[blocksy-content-block id=”12121″]

3. Warning Errors

Warning errors are non-fatal errors in PHP. When a warning is generated, PHP displays a warning message, but the execution of the script continues. Such errors are commonly caused by:

  • Including a missing file (for example, using include() with a non-existent file).
  • Incorrect or invalid file paths.
  • Passing invalid or incorrect arguments to functions.

Example 3:

<?php
include("missingfile.php");
echo "Script continues...";
?>

Output:

Warning: include(missingfile.php): Failed to open stream: No such file or directory

In this example:

  • When you write the above script, PHP warns about the missing file.
  • However, PHP continues the execution of script and shows the warning message.

4. Notice Errors

Notice errors are minor errors in PHP that inform you about potential issues in a script. They are non-fatal warnings that do not stop script execution but highlight problems that may lead to bugs or unexpected behavior.

Such errors are commonly caused by:

  • Using undefined variables.
  • Using undefined constants.
  • Using undefined array keys.
  • Accessing undefined array indexes.
  • Accessing properties of non-object variables.

Example 4:

<?php
// Undefined variable username.
echo $username;

// Proper way:
$username = 'John'; // Initialize first
echo $username;
?>

Output:

Warning: Undefined variable $username
John

In this example, we have defined a variable named $name, which is used without being defined. Therefore, PHP shows a warning message.
[blocksy-content-block id=”12153″]

5. Deprecated Errors

Deprecated errors in PHP are warning messages that indicate a feature, function, or syntax is outdated and may be removed in future versions of PHP. These errors do not stop script execution, but they warn you that the code they are using is no longer recommended.

Deprecated errors occur in PHP when you are using:

  • Old or obsolete PHP functions.
  • Outdated syntax in the code.

If you ignore deprecated errors, they may cause your application to break in future PHP releases.

Example 5:

<?php
// Deprecated function in modern PHP versions
mysql_connect("localhost", "root", "password");
?>

Output:

Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in future PHP versions

In this example, the mysql_connect() function belongs to the old MySQL extension, which has been deprecated and removed in modern PHP versions. You should use MySQLi or PDO instead.

6. User-Generated Errors

User-generated errors in PHP are custom error messages that are generated by users or programmers to handle specific conditions in an application. Unlike built-in PHP errors, these errors are intentionally triggered using PHP functions when certain rules or validations fail.

User-generated errors help programmers to

  • Control program flow
  • Validate input
  • Provide meaningful error messages instead of allowing unexpected behavior.

To generate custom errors, you can use the trigger_error() function provided by PHP. The general syntax to define trigger_error() function in PHP is:

trigger_error(message, error_type);

Some common user-generated error types include:

  • E_USER_NOTICE
  • E_USER_WARNING
  • E_USER_ERROR
  • E_USER_DEPRECATED

Example 6:

<?php
$age = 16;
if ($age < 18) {
   trigger_error("Access denied: User must be at least 18 years old.", E_USER_WARNING);
}
echo "Program continues execution.";
?>

Output:

Warning: Access denied: User must be at least 18 years old.
Program continues execution.

In this example:

  • The program checks the user’s age.
  • If the conditional expression $age < 18 fails, a custom warning message is generated using trigger_error() function.
  • Since E_USER_WARNING is non-fatal, PHP continues the execution of script.

PHP Error Levels

PHP provides a set of predefined integer constants to represent error levels. These constants are used to identify and manage different types of errors and warnings. They help us control how errors are reported, displayed, or logged during the execution of script.

Error levels are mainly used with functions such as error_reporting() and set_error_handler(), which handle different types of errors.

Common PHP Error Level Constants

Below are the most important PHP error levels used in modern PHP versions:

1. E_ERROR

  • Represents fatal run-time errors.
  • Execution of script stops immediately.
  • Example: calling an undefined function

2. E_WARNING

  • Represents run-time warnings.
  • Execution of script continues.
  • Example: including a missing file using include().

3. E_NOTICE

  • Represents run-time notices.
  • Indicates minor issues or potential bugs.
  • Example: using an undefined variable.

4. E_PARSE

  • Represents compile-time syntax errors.
  • Occurs when PHP cannot parse the script.
  • Script does not execute.

5. E_DEPRECATED

  • Indicates the use of deprecated features.
  • Script continues execution.
  • Warns that a feature might disappear in later PHP releases.

6. E_USER_ERROR

  • Represents user-generated fatal error.
  • Created using trigger_error() function.
  • Execution of script stops immediately.

7. E_USER_WARNING

  • User-generated non-fatal warning
  • Script continues execution.

8. E_USER_NOTICE

  • User-generated notice message.
  • Used for minor custom warnings.

9. E_ALL

  • Represents all errors and warnings.
  • Commonly used during development for debugging.
  • Example: error_reporting(E_ALL);

Why Error Levels Matter in PHP?

PHP error levels allow us to:

  • Detect bugs early in the development phase.
  • Control which errors are displayed or logged.
  • Improve application security.
  • Maintain compatibility with future versions of PHP.
  • Customize error handling behavior.

Best Practices for Handling Errors in PHP

There are some key points to handle errors in PHP that you should remember. They are:

  • Always enable error reporting during the development phase.
  • Disable error display in production environment.
  • Use error logging instead of displaying errors to users.
  • Handle exceptions properly using try, catch, and finally blocks.
  • Avoid using deprecated functions and outdated features.
  • Validate and sanitize user input before processing it.
  • Write clean, readable, and well-structured code
  • Do not ignore warnings and notices, as they may indicate hidden issues.
  • Never display detailed error messages in live applications.
DEEPAK GUPTA

DEEPAK GUPTA

Deepak Gupta is the Founder of Scientech Easy, a Full Stack Developer, and a passionate coding educator with 8+ years of professional experience in Java, Python, web development, and core computer science subjects. With strong expertise in full-stack development, he provides hands-on training in programming languages and in-demand technologies at the Scientech Easy Institute, Dhanbad.

He regularly publishes in-depth tutorials, practical coding examples, and high-quality learning resources for both beginners and working professionals. Every article is carefully researched, technically reviewed, and regularly updated to ensure accuracy, clarity, and real-world relevance, helping learners build job-ready skills with confidence.

Related Posts