Error vs Exception in PHP - Practice Questions

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of error and exception handling

What will be the output of this PHP code snippet?

PHP

<?php
function test() {
    try {
        throw new Exception("Exception caught");
    } catch (Error $e) {
        echo "Error caught";
    } catch (Exception $e) {
        echo $e->getMessage();
    }
}
test();

A Error caught

B Fatal error

C Exception caught

D No output

💡 Hint

Remember that Exception and Error are different classes in PHP and catch blocks handle exceptions based on type.

The thrown Exception is caught by the catch block for Exception, so it prints 'Exception caught'. The catch block for Error is skipped because the thrown object is not an Error.

❓ Predict Output

intermediate

Behavior of uncaught Error

What happens when this PHP code runs?

PHP

<?php
function test() {
    try {
        undefinedFunction();
    } catch (Exception $e) {
        echo "Exception caught";
    }
}
test();

A Warning but script continues

B Exception caught

C No output

D Fatal error: Uncaught Error: Call to undefined function

💡 Hint

Undefined functions cause Errors, not Exceptions.

Calling an undefined function throws an Error, which is not caught by the catch block for Exception, so a fatal error occurs.

🔧 Debug

advanced

Identify the error type caught

What type of error or exception is caught by this code?

PHP

<?php
try {
    $arr = [];
    $arr[5]();
} catch (Error $e) {
    echo get_class($e);
} catch (Exception $e) {
    echo get_class($e);
}

A ErrorException

B Error

C Exception

D UndefinedOffsetException

💡 Hint

Accessing an undefined array index triggers a specific error type in PHP 7+.

Accessing an undefined array index throws an Error of type Error, not Exception or ErrorException.

📝 Syntax

advanced

Which catch block order is correct?

Given that Error and Exception are both throwable in PHP, which catch block order will NOT cause a fatal error?

PHP

try {
    // some code
} catch (___) {
    // handle
} catch (___) {
    // handle
}

A catch (Error $e) then catch (Exception $e)

B catch (Exception $e) then catch (Error $e)

C catch (Exception $e) then catch (Throwable $t)

D catch (Throwable $t) then catch (Exception $e)

💡 Hint

More specific exceptions must be caught before more general ones.

Error and Exception both implement Throwable. Catching Error before Exception is correct because they are siblings. Catching Throwable before Exception causes unreachable code error.

🧠 Conceptual

expert

Difference between Error and Exception in PHP

Which statement best describes the difference between Error and Exception in PHP?

A Errors represent serious problems from PHP engine or environment, Exceptions represent user-defined or runtime issues that can be caught and handled.

B Errors and Exceptions are identical and interchangeable in PHP.

C Errors represent fatal problems that cannot be caught, Exceptions represent recoverable problems that can be caught.

D Exceptions are only for syntax errors, Errors are for runtime errors.

💡 Hint

Think about what kind of problems each class represents and how PHP treats them.

Errors represent serious problems like engine failures or type errors, while Exceptions are for user-defined or runtime issues that can be caught and handled by the program.

Practice

1. Which statement best describes the difference between an Error and an Exception in PHP?

easy

A. Errors are serious problems that usually stop the script, while exceptions can be caught and handled.

B. Exceptions are more serious than errors and always stop the script immediately.

C. Errors can be caught with try-catch blocks, but exceptions cannot.

D. There is no difference; errors and exceptions are the same in PHP.

Solution

1. Step 1: Understand PHP error handling basics

   Errors usually indicate serious problems like syntax errors or memory issues that stop the script.

2. Step 2: Understand exceptions in PHP

   Exceptions are objects that can be caught and handled using try-catch blocks to keep the program running.

3. Final Answer:

   Errors are serious problems that usually stop the script, while exceptions can be caught and handled. -> Option A

4. Quick Check:

   Error stops script, Exception can be caught [OK]

Hint: Errors stop scripts; exceptions can be caught and handled [OK]

Common Mistakes:

• Thinking exceptions always stop the script
• Believing errors can be caught with try-catch
• Confusing errors and exceptions as identical

2. Which of the following is the correct syntax to catch an exception in PHP?

easy

A. try { /* code */ } catch (Exception $e) { /* handle */ }

B. catch (Exception $e) { /* handle */ } try { /* code */ }

C. try { /* code */ } except (Exception $e) { /* handle */ }

D. try: /* code */ catch (Exception $e): /* handle */ endtry;

Solution

1. Step 1: Recall PHP exception handling syntax

   PHP uses try { ... } catch (Exception $e) { ... } to handle exceptions.

2. Step 2: Identify correct syntax among options

   try { /* code */ } catch (Exception $e) { /* handle */ } matches the correct PHP syntax; others use wrong keywords or order.

3. Final Answer:

   try { /* code */ } catch (Exception $e) { /* handle */ } -> Option A

4. Quick Check:

   try-catch block syntax = try { /* code */ } catch (Exception $e) { /* handle */ } [OK]

Hint: Remember: try then catch with parentheses [OK]

Common Mistakes:

• Using 'except' instead of 'catch'
• Placing catch before try
• Using colon syntax which is invalid in PHP

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

try {
  throw new Exception('Oops!');
  echo 'No error';
} catch (Exception $e) {
  echo 'Caught: ' . $e->getMessage();
}

medium

A. Fatal error: Uncaught Exception

B. No error

C. Caught: Oops!

D. No output

Solution

1. Step 1: Understand the throw statement

   The code throws an Exception with message 'Oops!'. The line after throw is not executed.

2. Step 2: Catch block execution

   The catch block catches the Exception and echoes 'Caught: ' plus the message.

3. Final Answer:

   Caught: Oops! -> Option C

4. Quick Check:

   Exception thrown and caught outputs message [OK]

Hint: Throw stops try; catch runs and prints message [OK]

Common Mistakes:

• Expecting 'No error' to print
• Thinking throw causes fatal error without catch
• Ignoring that catch block runs after throw

4. Identify the error in this PHP code snippet:

try {
  echo 10 / 0;
} catch (Exception $e) {
  echo 'Error caught';
}

medium

A. Syntax error: missing semicolon after echo.

B. Division by zero error is not caught because it is an Error, not an Exception.

C. Catch block syntax is incorrect.

D. No error; code runs and prints 'Error caught'.

Solution

1. Step 1: Understand division by zero in PHP

   Division by zero triggers a fatal Error, not an Exception.

2. Step 2: Check catch block behavior

   Catch block only catches Exceptions, so the Error is not caught and script stops.

3. Final Answer:

   Division by zero error is not caught because it is an Error, not an Exception. -> Option B

4. Quick Check:

   Errors not caught by catch(Exception) [OK]

Hint: Errors like division by zero aren't caught by catch(Exception) [OK]

Common Mistakes:

• Assuming catch catches all errors
• Thinking division by zero throws Exception
• Ignoring difference between Error and Exception

5. You want to handle both Error and Exception in PHP to prevent your script from stopping unexpectedly. Which approach is best?

hard

A. Use set_exception_handler() to catch both errors and exceptions.

B. Only use try-catch blocks everywhere; errors will be caught automatically.

C. Ignore errors and exceptions; PHP will handle them internally.

D. Use try-catch for exceptions and set a custom error handler with set_error_handler() for errors.

Solution

1. Step 1: Understand handling exceptions

   Exceptions are handled with try-catch blocks to catch and manage them.

2. Step 2: Understand handling errors

   Errors are handled by setting a custom error handler using set_error_handler() to manage errors gracefully.

3. Final Answer:

   Use try-catch for exceptions and set a custom error handler with set_error_handler() for errors. -> Option D

4. Quick Check:

   Separate handlers for errors and exceptions [OK]

Hint: Use try-catch for exceptions, set_error_handler for errors [OK]

Common Mistakes:

• Expecting try-catch to catch all errors
• Ignoring errors leading to script termination
• Using set_exception_handler for errors