Why error handling matters in PHP - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this PHP code with error handling?

Look at this PHP code that tries to divide two numbers. What will it print?

PHP

<?php
function divide($a, $b) {
    try {
        if ($b == 0) {
            throw new Exception("Division by zero.");
        }
        return $a / $b;
    } catch (Exception $e) {
        return $e->getMessage();
    }
}

echo divide(10, 0);

A Fatal error: Division by zero

B Division by zero.

C 0

D 10

💡 Hint

Think about what happens when the divisor is zero and how the exception is handled.

The code throws an exception when dividing by zero. The catch block catches it and returns the error message, so the output is the string "Division by zero."

❓ Predict Output

intermediate

What happens if error handling is missing?

What will this PHP code output?

PHP

<?php
function divide($a, $b) {
    return $a / $b;
}

echo divide(10, 0);

A Fatal error: Division by zero

B Division by zero.

C 0

D 10

💡 Hint

What happens when you divide by zero in PHP without catching errors?

Without error handling, dividing by zero causes a fatal error and the script stops running.

🔧 Debug

advanced

Find the error in this PHP error handling code

There is a mistake in this PHP code that tries to handle errors. What is it?

PHP

<?php
function readFileContent($filename) {
    try {
        $content = file_get_contents($filename);
        if (!$content) {
            throw new Exception("File not found or empty.");
        }
        return $content;
    } catch (Exception $e) {
        return $e->getMessage();
    }
}

echo readFileContent("missing.txt");

A The Exception class is not imported.

B The try block is missing a catch block.

C The condition if (!$content) fails when file content is '0', causing false error.

D file_get_contents throws a fatal error, so try-catch won't work.

💡 Hint

Think about what happens if the file content is the string '0'.

The condition if (!$content) treats '0' as false, so it wrongly throws an exception even if the file exists and contains '0'.

🧠 Conceptual

advanced

Why is error handling important in PHP applications?

Choose the best reason why error handling is important in PHP applications.

A It prevents the application from crashing and allows graceful recovery.

B It makes the code run faster by skipping error checks.

C It hides all errors so users never see any messages.

D It automatically fixes bugs in the code.

💡 Hint

Think about what happens when something unexpected occurs in your program.

Error handling helps the program continue running or fail gracefully instead of crashing unexpectedly.

❓ Predict Output

expert

What is the output of this PHP code with nested try-catch?

Analyze this PHP code with nested try-catch blocks. What will it output?

PHP

<?php
function test() {
    try {
        try {
            throw new Exception("Inner error");
        } catch (Exception $e) {
            echo "Caught: " . $e->getMessage() . "\n";
            throw new Exception("Outer error");
        }
    } catch (Exception $e) {
        echo "Caught again: " . $e->getMessage() . "\n";
    }
}

test();

A Fatal error: Uncaught Exception: Outer error

B

Caught: Outer error
Caught again: Inner error

C

Caught: Inner error

D

Caught: Inner error
Caught again: Outer error

💡 Hint

Look carefully at how exceptions are re-thrown and caught in nested blocks.

The inner try throws "Inner error" which is caught and printed. Then it throws "Outer error" which is caught by the outer catch and printed.

Practice

1. Why is error handling important in PHP programs?

easy

A. It hides all errors from the user permanently.

B. It makes the program run faster by skipping code.

C. It helps keep the program running smoothly even when errors occur.

D. It automatically fixes all bugs without programmer input.

Solution

1. Step 1: Understand the purpose of error handling

   Error handling is designed to manage unexpected problems so the program doesn't crash.

2. Step 2: Identify the correct benefit

   Keeping the program running smoothly despite errors is the main goal of error handling.

3. Final Answer:

   It helps keep the program running smoothly even when errors occur. -> Option C

4. Quick Check:

   Error handling importance = keep program running smoothly [OK]

Hint: Error handling prevents crashes and keeps programs running [OK]

Common Mistakes:

• Thinking error handling fixes bugs automatically
• Believing error handling hides errors forever
• Confusing error handling with performance optimization

2. Which PHP syntax correctly starts a block to catch exceptions?

easy

A. try { ... } catch (Exception $e) { ... }

B. catch { ... } try (Exception $e) { ... }

C. try (Exception $e) { ... } catch { ... }

D. catch (Exception $e) { ... } try { ... }

Solution

1. Step 1: Recall PHP error handling syntax

   PHP uses try to start a block and catch (Exception $e) to handle exceptions.

2. Step 2: Match correct syntax

   try { ... } catch (Exception $e) { ... } correctly shows try { ... } catch (Exception $e) { ... }.

3. Final Answer:

   try { ... } catch (Exception $e) { ... } -> Option A

4. Quick Check:

   Correct try-catch syntax = try { ... } catch (Exception $e) { ... } [OK]

Hint: Remember: try first, then catch with exception variable [OK]

Common Mistakes:

• Swapping try and catch order
• Missing exception variable in catch
• Using parentheses incorrectly around try

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

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

medium

A. No error

B. Fatal error: uncaught exception

C. Caught: No error

D. Caught: Error happened

Solution

1. Step 1: Understand the throw statement

   The code throws an Exception with message 'Error happened', so normal flow stops at throw.

2. Step 2: Catch block executes and prints message

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

3. Final Answer:

   Caught: Error happened -> Option D

4. Quick Check:

   Exception thrown and caught = 'Caught: Error happened' [OK]

Hint: Exception stops try block; catch prints message [OK]

Common Mistakes:

• Expecting code after throw to run
• Confusing exception message with echo text
• Thinking uncaught error occurs

4. Identify the error in this PHP code snippet:

try {
  echo 'Start';
} catch {
  echo 'Error caught';
}

medium

A. Missing exception variable in catch parentheses

B. Missing semicolon after echo statements

C. try block cannot have echo statements

D. catch block must come before try block

Solution

1. Step 1: Check catch syntax

   In PHP, catch must specify an exception variable like catch (Exception $e).

2. Step 2: Identify missing variable

   The code has catch { ... } without the exception variable, causing a syntax error.

3. Final Answer:

   Missing exception variable in catch parentheses -> Option A

4. Quick Check:

   Catch requires exception variable = Missing exception variable in catch parentheses [OK]

Hint: Always include exception variable in catch parentheses [OK]

Common Mistakes:

• Leaving catch parentheses empty
• Thinking catch can be empty
• Misplacing catch before try

5. You want to handle errors in a PHP function that divides two numbers. Which approach best improves user experience and debugging?

hard

A. Ignore errors and let PHP show default warnings on screen.

B. Use try-catch to catch division by zero and return a friendly message.

C. Use echo to print errors inside the function without stopping execution.

D. Use exit() immediately when an error occurs to stop the program.

Solution

1. Step 1: Consider user experience and debugging needs

   Good error handling should catch errors and provide clear, friendly messages without crashing.

2. Step 2: Evaluate options

   Use try-catch to catch division by zero and return a friendly message. uses try-catch to handle division by zero gracefully, improving experience and debugging.

3. Final Answer:

   Use try-catch to catch division by zero and return a friendly message. -> Option B

4. Quick Check:

   Best error handling = try-catch with friendly message [OK]

Hint: Catch errors and show friendly messages, don't stop abruptly [OK]

Common Mistakes:

• Ignoring errors and confusing users
• Using exit() which stops program abruptly
• Printing raw errors without handling