🧯 Error Handling in Node, Python & PHP

Why Structured Error Handling?

An error (or exception) is a signal that a piece of code could not do its job. Rather than letting the program limp on with bad data, the language stops the current path and hands control to whoever is prepared to deal with the problem. Structured handling gives you three things a scattering of if checks cannot: a clear place to react, a way to separate the happy path from the failure path, and a guarantee that cleanup still runs.

💡 A useful analogy: Think of throw/raise as pulling the emergency cord on a train. Everything after it in the current carriage stops immediately, and the train keeps rolling backward through the carriages (the call stack) until it reaches a station (a catch/except) that's staffed to handle the emergency. If no station is staffed, the whole train stops — an unhandled crash.

All three languages share the same core idea — a protected block plus a handler — but they differ in vocabulary and in a few important details, which we'll line up next.

The try Block in Three Languages

Here is the same defensive pattern — attempt something risky, react on failure, always clean up — expressed in each language.

JavaScript (Node.js) — try / catch / finally

try {
  const data = JSON.parse(rawInput);   // may throw a SyntaxError
  console.log(data.name);
} catch (err) {
  // err is the thrown Error object
  console.error('Could not parse input:', err.message);
} finally {
  console.log('Done attempting.');     // always runs
}

JavaScript has a single catch clause. To react differently to different error types, inspect the caught object inside the block — usually with instanceof:

catch (err) {
  if (err instanceof SyntaxError) {
    // handle malformed JSON
  } else {
    throw err;   // re-throw anything we didn't expect
  }
}

Python — try / except / else / finally

try:
    data = json.loads(raw_input)          # may raise JSONDecodeError
except json.JSONDecodeError as err:
    print(f'Could not parse input: {err}')
except (KeyError, ValueError) as err:     # catch several types at once
    print(f'Bad data: {err}')
else:
    print(data['name'])   # runs ONLY if no exception was raised
finally:
    print('Done attempting.')             # always runs

Python is the richest here: you can list multiple typed except clauses, and it adds an else block that runs only when the try succeeded — a clean way to keep the success-only code out of the protected block.

PHP — try / catch / finally with Throwable

<?php
try {
    $data = json_decode($rawInput, true, 512, JSON_THROW_ON_ERROR);
    echo $data['name'];
} catch (JsonException $err) {           // typed catch, like Python
    echo 'Could not parse input: ' . $err->getMessage();
} catch (Throwable $err) {               // catch-all safety net
    echo 'Unexpected: ' . $err->getMessage();
} finally {
    echo 'Done attempting.';             // always runs
}

Like Python, PHP supports multiple typed catch clauses. The base type to catch is Throwable, which sits above both Exception and Error.

Throwing & Raising

When your own code detects a bad situation, signal it explicitly rather than returning a magic value like -1 or null that the caller might forget to check.

// JavaScript — throw an Error instance
function withdraw(balance, amount) {
  if (amount > balance) {
    throw new Error('Insufficient funds');
  }
  return balance - amount;
}

# Python — raise an exception instance
def withdraw(balance, amount):
    if amount > balance:
        raise ValueError('Insufficient funds')
    return balance - amount

<?php
// PHP — throw an exception instance
function withdraw(float $balance, float $amount): float {
    if ($amount > $balance) {
        throw new InvalidArgumentException('Insufficient funds');
    }
    return $balance - $amount;
}

Custom Error Classes

Built-in error types are fine, but a named error class makes your intent explicit and lets callers catch exactly the failure they care about. In every language you make one by extending the base error type.

// JavaScript — extend Error
class InsufficientFundsError extends Error {
  constructor(deficit) {
    super(`Short by ${deficit}`);
    this.name = 'InsufficientFundsError'; // so stack traces read well
    this.deficit = deficit;               // attach useful context
  }
}

// caller can now target it precisely:
try {
  withdraw(50, 80);
} catch (err) {
  if (err instanceof InsufficientFundsError) {
    console.log('Top up by', err.deficit);
  }
}

# Python — subclass Exception
class InsufficientFundsError(Exception):
    def __init__(self, deficit):
        super().__init__(f'Short by {deficit}')
        self.deficit = deficit

try:
    withdraw(50, 80)
except InsufficientFundsError as err:
    print('Top up by', err.deficit)

<?php
// PHP — extend Exception
class InsufficientFundsException extends Exception {
    public function __construct(
        public readonly float $deficit
    ) {
        parent::__construct("Short by {$deficit}");
    }
}

try {
    withdraw(50, 80);
} catch (InsufficientFundsException $err) {
    echo 'Top up by ' . $err->deficit;
}

Propagation & Cleanup

If a block doesn't catch an error, it doesn't vanish — it propagates up to the function that called it, then that function's caller, and so on up the stack until something catches it or the program crashes. This is powerful: low-level code can raise, and a single high-level handler can deal with it.

finally always runs

The finally block executes whether the try succeeded, threw, or even returned — making it the reliable place to release resources like file handles or database connections.

# Python — the file closes even if processing raises
f = open('data.txt')
try:
    process(f.read())
finally:
    f.close()          # guaranteed

# Idiomatic Python prefers a context manager, which does this for you:
with open('data.txt') as f:
    process(f.read())  # file auto-closes on exit, error or not

// JavaScript — release a lock no matter what
const release = await lock.acquire();
try {
  await doWork();
} finally {
  release();           // guaranteed
}

Best Practices

The mechanics are similar across languages; the discipline is what makes error handling good. These principles hold in Node, Python, and PHP alike.

# Anti-pattern: the silent swallow — never do this
try:
    risky()
except Exception:
    pass          # the error is gone forever; good luck debugging

# Better: catch what you expect, log the rest, re-raise the unknown
try:
    risky()
except TimeoutError as err:
    logger.warning('Retrying after timeout: %s', err)
    retry()

Hands-on Exercise

// JavaScript
class ConfigError extends Error {
  constructor(msg) { super(msg); this.name = 'ConfigError'; }
}

function getPort(config) {
  try {
    const port = config.port;
    if (typeof port !== 'number' || port < 1 || port > 65535) {
      throw new ConfigError(`Invalid port: ${port}`);
    }
    return port;
  } finally {
    console.log('config check complete');
  }
}

try {
  console.log(getPort({ port: 3000 }));  // 3000
  console.log(getPort({}));              // throws
} catch (err) {
  if (err instanceof ConfigError) console.error('Config problem:', err.message);
  else throw err;
}

# Python
class ConfigError(Exception):
    pass

def get_port(config):
    try:
        port = config.get('port')
        if not isinstance(port, int) or not (1 <= port <= 65535):
            raise ConfigError(f'Invalid port: {port}')
        return port
    finally:
        print('config check complete')

try:
    print(get_port({'port': 3000}))   # 3000
    print(get_port({}))               # raises
except ConfigError as err:
    print('Config problem:', err)

<?php
class ConfigError extends Exception {}

function getPort(array $config): int {
    try {
        $port = $config['port'] ?? null;
        if (!is_int($port) || $port < 1 || $port > 65535) {
            throw new ConfigError("Invalid port: " . var_export($port, true));
        }
        return $port;
    } finally {
        echo "config check complete\n";
    }
}

try {
    echo getPort(['port' => 3000]) . "\n";  // 3000
    echo getPort([]) . "\n";                // throws
} catch (ConfigError $err) {
    echo 'Config problem: ' . $err->getMessage() . "\n";
}

Summary & Quiz

📚 Further Reading

• MDN — try...catch
• Python docs — Errors and Exceptions
• PHP manual — Exceptions

🚀 What's Next?

With resilient code in hand, the next lesson puts it to work reading and writing the outside world — working with files and JSON in Node, Python, and PHP, where error handling and cleanup really earn their keep.