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.