Set_error_handler function in PHP

Introduction

The set_error_handler function lets you control what happens when an error occurs in your PHP program. Instead of showing the default error message, you can create your own way to handle errors.

You want to log errors to a file instead of showing them on the screen.

You want to show friendly messages to users when something goes wrong.

You want to stop the program from crashing and handle errors smoothly.

You want to customize how different types of errors are treated.

You want to debug your program by catching errors in a special way.

Syntax

PHP

set_error_handler(callable $error_handler, int $error_levels = E_ALL): ?callable

The $error_handler is a function you create that will run when an error happens.

The optional $error_levels lets you choose which errors to catch (default is all errors).

Examples

This example sets a simple error handler that prints error details.

PHP

<?php
function myErrorHandler($errno, $errstr, $errfile, $errline) {
    echo "Error [$errno]: $errstr in $errfile on line $errline\n";
}
set_error_handler('myErrorHandler');

This example uses an anonymous function to handle errors with a short message.

PHP

<?php
set_error_handler(function($errno, $errstr) {
    echo "Custom error: $errstr\n";
});

This example sets the handler only for warnings and notices, ignoring other errors.

PHP

<?php
set_error_handler('myErrorHandler', E_WARNING | E_NOTICE);

Sample Program

This program sets a custom error handler that prints a friendly message when an error happens. Then it causes two errors: dividing by zero and using an undefined variable. Instead of default errors, the custom messages show.

PHP

<?php
function customErrorHandler($errno, $errstr, $errfile, $errline) {
    echo "Oops! Error number $errno happened: $errstr on line $errline in file $errfile\n";
}

set_error_handler('customErrorHandler');

// This will cause a warning (division by zero)
echo 10 / 0;

// This will cause a notice (undefined variable)
echo $undefinedVar;

Important Notes

The error handler function must accept at least four parameters: error number, error message, file name, and line number.

After setting a custom error handler, PHP will use it for errors matching the specified levels.

Remember to restore the original error handler if needed using restore_error_handler().

Summary

set_error_handler lets you catch and handle errors your way.

You create a function that runs when an error happens.

This helps make your program friendlier and easier to debug.

Practice

1. What is the main purpose of the set_error_handler function in PHP?

easy

A. To define a custom function to handle errors when they occur

B. To stop all errors from appearing

C. To automatically fix errors in the code

D. To log errors to a file without any custom handling

Solution

1. Step 1: Understand what set_error_handler does

   This function lets you tell PHP to use your own function to handle errors instead of the default error messages.

2. Step 2: Compare options with this understanding

   Only defining a custom function to handle errors when they occur correctly describes this behavior. Automatically fixing errors, stopping all errors from appearing, and logging errors to a file without any custom handling are all incorrect.

3. Final Answer:

   To define a custom function to handle errors when they occur -> Option A

4. Quick Check:

   Custom error handling = Define function with set_error_handler [OK]

Hint: Remember: set_error_handler sets your own error function [OK]

Common Mistakes:

• Thinking it stops errors completely
• Assuming it fixes errors automatically
• Confusing it with error logging functions

2. Which of the following is the correct syntax to set a custom error handler function named myErrorHandler?

easy

A. set_error_handler(&myErrorHandler);

B. set_error_handler(myErrorHandler);

C. set_error_handler('myErrorHandler');

D. set_error_handler($myErrorHandler);

Solution

1. Step 1: Recall the syntax for passing function names in PHP

   When passing a function name as a callback, it must be a string in quotes.

2. Step 2: Check each option

   set_error_handler('myErrorHandler'); correctly passes the function name as a string. set_error_handler(myErrorHandler); misses quotes, set_error_handler(&myErrorHandler); uses an invalid reference operator, and set_error_handler($myErrorHandler); uses a variable which is incorrect here.

3. Final Answer:

   set_error_handler('myErrorHandler'); -> Option C

4. Quick Check:

   Function name as string = 'myErrorHandler' [OK]

Hint: Function names as strings in callbacks [OK]

Common Mistakes:

• Omitting quotes around function name
• Using variable instead of string
• Using reference operator & incorrectly

3. What will be the output of the following PHP code?

function customError($errno, $errstr) {
    echo "Error: [$errno] $errstr";
}
set_error_handler('customError');
trigger_error('This is a test error', E_USER_WARNING);

medium

A. Warning: This is a test error

B. Error: [512] This is a test error

C. Fatal error: Uncaught Error

D. No output

Solution

1. Step 1: Understand the custom error handler and trigger_error

   The customError function prints the error number and message. The trigger_error calls this handler with E_USER_WARNING which has error number 512.

2. Step 2: Predict the output

   The output will be the echo from customError showing the error number and message exactly as coded.

3. Final Answer:

   Error: [512] This is a test error -> Option B

4. Quick Check:

   Custom handler prints error number 512 and message [OK]

Hint: E_USER_WARNING error number is 512 [OK]

Common Mistakes:

• Expecting default PHP warning format
• Confusing error numbers
• Thinking no output appears

4. Identify the error in this PHP code snippet using set_error_handler:

function handler($errno, $errstr) {
    echo "Error: $errstr";
}
set_error_handler(handler);
trigger_error('Oops!');

medium

A. trigger_error requires two arguments

B. trigger_error cannot be used with set_error_handler

C. handler function must return a value

D. Missing quotes around handler in set_error_handler

Solution

1. Step 1: Check the set_error_handler syntax

   The function name passed to set_error_handler must be a string, so it needs quotes.

2. Step 2: Verify trigger_error usage

   trigger_error can be called with one argument; the second is optional. The handler function does not need to return a value. Using trigger_error with set_error_handler is valid.

3. Final Answer:

   Missing quotes around handler in set_error_handler -> Option D

4. Quick Check:

   Function name must be string in quotes [OK]

Hint: Function names need quotes in set_error_handler [OK]

Common Mistakes:

• Omitting quotes around function name
• Thinking trigger_error needs two arguments
• Expecting handler to return a value

5. You want to log all warnings and notices to a file instead of displaying them. Which approach using set_error_handler is best?

hard

A. Create a function that writes error details to a log file and set it with set_error_handler

B. Use set_error_handler with an empty function to ignore errors

C. Call trigger_error inside set_error_handler to log errors

D. Disable error reporting and rely on PHP default logging

Solution

1. Step 1: Understand the goal

   You want to capture warnings and notices and save them to a file instead of showing them on screen.

2. Step 2: Evaluate options

   Create a function that writes error details to a log file and set it with set_error_handler correctly describes creating a custom function that writes error info to a log file and setting it as the error handler. Use set_error_handler with an empty function to ignore errors ignores errors, which is not logging. Call trigger_error inside set_error_handler to log errors misuses trigger_error inside the handler, causing recursion. Disable error reporting and rely on PHP default logging disables reporting but does not customize logging.

3. Final Answer:

   Create a function that writes error details to a log file and set it with set_error_handler -> Option A

4. Quick Check:

   Custom handler writes logs = best practice [OK]

Hint: Custom handler writes logs to file for error control [OK]

Common Mistakes:

• Ignoring errors instead of logging
• Calling trigger_error inside handler causing loops
• Disabling errors without custom logging