try / catch / finally / throw Since: PHP 5（2004）

// Basic syntax for catching exceptions.
try {
	// Code that may throw an exception
} catch (Exception $e) {
	// Code to handle the exception
} finally {
	// Code that always runs, regardless of whether an exception occurred
}

// Throws an exception.
throw new Exception($message, $code);

<?php
// Basic exception handling.
try {
	$result = 10 / 0; // Triggers a division by zero error.
} catch (DivisionByZeroError $e) {
	echo "Error: " . $e->getMessage(); // Outputs "Division by zero".
}

// Throwing and catching an exception.
function validateAge(int $age): void
{
	if ($age < 0 || $age > 150) {
		throw new InvalidArgumentException("Age must be between 0 and 150.");
	}
}

try {
	validateAge(200);
} catch (InvalidArgumentException $e) {
	echo $e->getMessage(); // Outputs "Age must be between 0 and 150."
}

// Handling multiple exception types individually.
try {
	$pdo = new PDO('mysql:host=localhost;dbname=myapp', 'user', 'password');
	$stmt = $pdo->prepare("SELECT * FROM users WHERE id = :id");
	$stmt->execute([':id' => 'abc']); // Invalid value
} catch (PDOException $e) {
	echo "Database error: " . $e->getMessage();
} catch (Exception $e) {
	echo "Unexpected error: " . $e->getMessage();
}

// In PHP 8+, you can catch multiple types using a pipe (|).
try {
	$data = json_decode('invalid', true, 512, JSON_THROW_ON_ERROR);
} catch (JsonException | InvalidArgumentException $e) {
	echo "Input data error: " . $e->getMessage();
}

// The finally block always runs.
$file = null;
try {
	$file = fopen('data.txt', 'r');
	if ($file === false) {
		throw new RuntimeException("Could not open the file.");
	}
	$content = fread($file, filesize('data.txt'));
	echo $content;
} catch (RuntimeException $e) {
	echo "Error: " . $e->getMessage();
} finally {
	if ($file !== null) {
		fclose($file); // Ensures the file is closed even if an exception occurs.
	}
}

// Common methods of Exception.
try {
	throw new Exception("Test error", 500);
} catch (Exception $e) {
	echo $e->getMessage(); // Outputs "Test error".
	echo $e->getCode(); // Outputs "500".
	echo $e->getFile(); // Outputs the filename where the exception was thrown.
	echo $e->getLine(); // Outputs the line number where the exception was thrown.
}

// Defining a custom exception class.
class AppException extends RuntimeException
{
	private string $detail;

	public function __construct(string $message, string $detail, int $code = 0)
	{
		parent::__construct($message, $code);
		$this->detail = $detail;
	}

	public function getDetail(): string
	{
		return $this->detail;
	}
}

try {
	throw new AppException("Authentication error", "The token has expired.", 401);
} catch (AppException $e) {
	echo $e->getMessage() . ": " . $e->getDetail();
}

try / catch is PHP's exception handling syntax, used to safely handle runtime errors. Always wrap operations that may fail — such as database access, file I/O, and external API calls — in exception handling blocks. If an exception is not caught, the script terminates and an error message is displayed to the user.

In catch blocks, specifying a concrete exception type allows you to handle different kinds of errors appropriately. If you write a broad type like Exception first, subsequent catch blocks will never be reached — so always order your catch blocks from most specific to most general.

The finally block always executes regardless of whether an exception occurred, making it ideal for releasing resources. When combining exception handling with database transactions, see beginTransaction() / commit() / rollBack(). For JSON conversion error handling, see json_encode() / json_decode().