Errors and Exceptions Basics

Errors and exceptions are how PHP tells you something went wrong. A syntax error means PHP could not understand the code. A warning or notice usually means the code ran into a suspicious situation. An exception is an object thrown by code to say "this path cannot continue normally."

As a beginner, focus on three habits: fail early when input is invalid, catch exceptions only where you can do something useful, and do not show raw error details to users in production.

Throwing For Invalid Input

Use an exception when a function cannot do its job with the value it received.

<?php

function normaliseName(string $name): string
{
    $name = trim($name);

    if ($name === '') {
        throw new InvalidArgumentException('Name is required.');
    }

    return $name;
}

echo normaliseName(' Ada ') . "\n";

// Prints:
// Ada

The function rejects an empty name before returning a value. That is better than letting empty data move deeper into the application and cause a harder bug later.

Catching An Exception

Use try and catch when you want to handle an exception and continue with a controlled response.

<?php

function normaliseName(string $name): string
{
    $name = trim($name);

    if ($name === '') {
        throw new InvalidArgumentException('Name is required.');
    }

    return $name;
}

try {
    echo normaliseName('   ') . "\n";
} catch (InvalidArgumentException $exception) {
    echo "Please enter your name.\n";
}

// Prints:
// Please enter your name.

The user-facing message is simple. The exception message can be useful for logs or debugging, but you usually do not show internal details directly to users.

Catch Specific Exceptions First

Catch the specific exception type you expect. Catching every Throwable too early can hide programming mistakes.

<?php

function parsePositiveAmount(string $value): int
{
    if (!ctype_digit($value)) {
        throw new InvalidArgumentException('Amount must contain digits only.');
    }

    $amount = (int) $value;

    if ($amount <= 0) {
        throw new InvalidArgumentException('Amount must be positive.');
    }

    return $amount;
}

try {
    echo parsePositiveAmount('25') . "\n";
} catch (InvalidArgumentException $exception) {
    echo "Invalid amount.\n";
}

// Prints:
// 25

This function treats invalid input as an expected failure path. It still returns a normal integer when the input is valid.

Warnings Are Not A Plan

Do not rely on PHP warnings as validation. Check the data before using it.

<?php

$payload = ['email' => 'amo@example.com'];

if (!isset($payload['name'])) {
    echo "Name is missing\n";
    return;
}

echo $payload['name'] . "\n";

// Prints:
// Name is missing

The code checks the key before reading it. That makes the failure path deliberate instead of letting PHP warn about a missing array key.

Development And Production

During development, visible errors help you fix code quickly. In production, raw errors can leak paths, SQL details, tokens, configuration names, and other sensitive information.

Production applications should log errors for developers and show users a safe message. The exact logging setup comes later, but the habit starts here: error details are for developers, not for public output.

Common Mistakes

Do not catch an exception and ignore it. If the failure matters, handle it or let it keep moving upward.

Do not throw exceptions for ordinary branches such as "order is pending" when a return value would be clearer.

Do not expose exception messages from low-level code directly to users. Convert them to safe user-facing messages at the boundary.

What You Should Be Able To Do

After this lesson, you should be able to:

• throw InvalidArgumentException for invalid function input;
• catch an expected exception with try and catch;
• explain the difference between a normal branch and an exceptional failure;
• check array keys before reading them;
• avoid showing raw error details to users.