Managing error in PHP and updating report settings

<?Php
error_reporting(0);// no error reporting 
?>

<?php

// Turn off all error reporting
error_reporting(0);

// Report simple running errors
error_reporting(E_ERROR | E_WARNING | E_PARSE);

//  E_WARNING is removed
error_reporting(E_ERROR |  E_PARSE); 

// Reporting E_NOTICE can be good too (to report uninitialized)
error_reporting(E_ERROR | E_WARNING | E_PARSE | E_NOTICE);

// Report all errors except E_NOTICE
error_reporting(E_ALL & ~E_NOTICE);

// Report all PHP errors
error_reporting(E_ALL);

// Report all PHP errors
error_reporting(-1);

// Same as error_reporting(E_ALL);
ini_set('error_reporting', E_ALL);
?>

• parse or syntax errors
• fatal errors
• warning errors
• notice errors

display_errors = On

display_errors=Off

Local or script level settings

<?Php
$one = $two; 
?>

 Notice: Undefined variable: two in J:\php_files\t\error\test.php on line 13

<?Php
error_reporting(0);// With this no error reporting will be there
$one = $two; 
?>

Development environment

error_reporting(E_ALL);

ini_set('display_errors', true);

Production environment

ini_set('display_errors', 0);
error_reporting(0);

PHP Error Constants

PHP try-catch-finally Block: Explanation and Examples 🔝

In PHP, the try-catch-finally block is used for handling exceptions. It helps in managing errors in a controlled and structured way.

Key Components

• try Block: Contains the code that may throw an exception. PHP will monitor this block for any exceptions.
• catch Block: Executes if an exception is thrown in the try block. It handles the exception and provides an error message or fallback operation.
• finally Block: (Optional) Always executes after the try and catch blocks, regardless of whether an exception was thrown. It is typically used for cleanup operations, like closing connections or freeing resources.

Example 1: Basic try-catch Block

<?php
try {
    // Code that may cause an exception
    $number = 10;
    if ($number > 5) {
        throw new Exception("The number is too large!");
    }
    echo "This will not be executed.";
} catch (Exception $e) {
    // Code to handle the exception
    echo 'Caught exception: ' . $e->getMessage();
}
?>

Explanation:

• throw new Exception(): Throws a new exception if the condition is met.
• catch (Exception $e): Catches the thrown exception and retrieves the error message via $e->getMessage().

Output:

Caught exception: The number is too large!

Example 2: Using try-catch-finally

<?php
$connection = null;
try {
    // Attempt to connect to a database
    $connection = new mysqli("localhost", "user", "password", "database");

    // Throw an exception if the connection fails
    if ($connection->connect_error) {
        throw new Exception("Connection failed: " . $connection->connect_error);
    }

    echo "Connected successfully!";
} catch (Exception $e) {
    // Handle the exception
    echo "Error: " . $e->getMessage();
} finally {
    // This will always execute, even if an exception was thrown
    if ($connection) {
        $connection->close();
        echo " Connection closed.";
    }
}
?>

Explanation:

• The finally block ensures the database connection is closed, regardless of success or failure.

Output (if connection fails):

Error: Connection failed: Access denied for user 'user'@'localhost'
Connection closed.

Example 3: Multiple catch Blocks

<?php
try {
    // Code that may throw different exceptions
    $num1 = 10;
    $num2 = 0;
    
    if ($num2 == 0) {
        throw new DivisionByZeroError("Cannot divide by zero!");
    }
    
    $result = $num1 / $num2;
} catch (DivisionByZeroError $e) {
    // Handle division by zero error
    echo "Math error: " . $e->getMessage();
} catch (Exception $e) {
    // Handle other general exceptions
    echo "General error: " . $e->getMessage();
}
?>

Explanation:

• DivisionByZeroError: Specific exception for division by zero errors.
• Exception: Catches any general exceptions that are not specific.

Output:

Math error: Cannot divide by zero!

Key Points

• Exception Propagation: If an exception is not caught, it propagates up the call stack. If uncaught, PHP outputs a fatal error.
• finally Block: Always executes after the try and catch blocks, making it ideal for cleanup operations.
• Custom Exceptions: You can create custom exceptions by extending PHP's Exception class.

Subhendu Mohapatra

Author & Instructor at plus2net

I write and maintain practical tutorials on Python, PHP, SQL, JavaScript, HTML, jQuery, and web development at plus2net. The tutorials focus on clear explanations, working examples, and code that readers can test and adapt while learning.

About the author   Watch on YouTube

Connect: