Learn PHP Programming

<?php
declare(strict_types=1);

function fetchUserData(int $userId): array {
    // Simulate different failure scenarios
    if ($userId <= 0) {
        throw new \InvalidArgumentException("User ID must be positive, got: {$userId}");
    }
    if ($userId > 1000) {
        throw new \OverflowException('User ID exceeds maximum range');
    }
    if ($userId === 999) {
        throw new \RuntimeException('Database connection timeout');
    }

    return ['id' => $userId, 'name' => 'User ' . $userId];
}

function getUserSafely(int $id): ?array {
    $dbConnection = null;

    try {
        $dbConnection = 'connected';  // Simulate resource acquisition
        $user = fetchUserData($id);
        echo "Found: {$user['name']}\n";
        return $user;

    } catch (\InvalidArgumentException $e) {
        // Handle validation errors specifically
        echo "Validation Error: {$e->getMessage()}\n";
        echo "Fix: Provide a valid positive user ID\n";
        return null;

    } catch (\OverflowException $e) {
        // Handle range errors
        echo "Range Error: {$e->getMessage()}\n";
        return null;

    } catch (\RuntimeException $e) {
        // Handle infrastructure errors
        echo "System Error: {$e->getMessage()}\n";
        echo "File: {$e->getFile()}, Line: {$e->getLine()}\n";
        error_log($e->getTraceAsString());  // Log full trace
        return null;

    } finally {
        // ALWAYS executes - whether exception was thrown or not
        // Perfect for cleanup: closing connections, releasing locks
        if ($dbConnection !== null) {
            $dbConnection = null;  // Release resource
            echo "Connection cleaned up\n";
        }
    }
}

// Test different scenarios
getUserSafely(42);    // Found: User 42 + cleanup
getUserSafely(-1);   // Validation Error + cleanup
getUserSafely(999);  // System Error + cleanup

// PHP 8.0+ multi-catch with union types
try {
    fetchUserData(0);
} catch (\InvalidArgumentException | \OverflowException $e) {
    echo "Input Error: {$e->getMessage()}\n";
}
?>

<?php
// Base application exception
class AppException extends \Exception {
    private string $errorCode;
    private array $context;

    public function __construct(
        string $message,
        string $errorCode = 'APP_ERROR',
        array $context = [],
        int $httpStatus = 500,
        ?\Throwable $previous = null
    ) {
        parent::__construct($message, $httpStatus, $previous);
        $this->errorCode = $errorCode;
        $this->context = $context;
    }

    public function getErrorCode(): string {
        return $this->errorCode;
    }

    public function getContext(): array {
        return $this->context;
    }

    public function toArray(): array {
        return [
            'error' => $this->errorCode,
            'message' => $this->getMessage(),
            'context' => $this->context,
            'status' => $this->getCode()
        ];
    }
}

// Specific exception types
class ValidationException extends AppException {
    private array $errors;

    public function __construct(array $errors, array $context = []) {
        $this->errors = $errors;
        $message = 'Validation failed: ' . implode(', ', $errors);
        parent::__construct($message, 'VALIDATION_ERROR', $context, 422);
    }

    public function getErrors(): array {
        return $this->errors;
    }
}

class NotFoundException extends AppException {
    public function __construct(string $resource, string|int $id) {
        parent::__construct(
            "{$resource} with ID '{$id}' not found",
            'NOT_FOUND',
            ['resource' => $resource, 'id' => $id],
            404
        );
    }
}

class AuthenticationException extends AppException {
    public function __construct(string $reason = 'Invalid credentials') {
        parent::__construct($reason, 'AUTH_FAILED', [], 401);
    }
}

// Usage in application code
function findProduct(int $id): array {
    $products = [1 => ['name' => 'Laptop'], 2 => ['name' => 'Phone']];

    if (!isset($products[$id])) {
        throw new NotFoundException('Product', $id);
    }
    return $products[$id];
}

function createOrder(array $data): array {
    $errors = [];
    if (empty($data['product_id'])) $errors[] = 'product_id is required';
    if (empty($data['quantity'])) $errors[] = 'quantity is required';
    if ($errors) {
        throw new ValidationException($errors, ['input' => $data]);
    }
    return ['order_id' => 1, 'status' => 'created'];
}

// Catching custom exceptions
try {
    $product = findProduct(99);
} catch (NotFoundException $e) {
    echo $e->getMessage();        // Product with ID '99' not found
    echo $e->getErrorCode();      // NOT_FOUND
    echo $e->getCode();           // 404
    $response = $e->toArray();    // Structured error response
}
?>

<?php
// Global handler catches any unhandled exceptions
set_exception_handler(function (\Throwable $e): void {
    // Log the full error details
    $logEntry = sprintf(
        "[%s] %s: %s in %s:%d\nTrace: %s\n",
        date('Y-m-d H:i:s'),
        get_class($e),
        $e->getMessage(),
        $e->getFile(),
        $e->getLine(),
        $e->getTraceAsString()
    );
    error_log($logEntry);

    // Show user-friendly response based on exception type
    if ($e instanceof AppException) {
        http_response_code($e->getCode());
        echo json_encode($e->toArray());
    } else {
        // Generic error - never expose internals to users
        http_response_code(500);
        echo json_encode([
            'error' => 'INTERNAL_ERROR',
            'message' => 'An unexpected error occurred'
        ]);
    }
});

// Convert PHP errors to exceptions
set_error_handler(function (
    int $severity,
    string $message,
    string $file,
    int $line
): bool {
    // Don't handle suppressed errors (@operator)
    if (!(error_reporting() & $severity)) {
        return false;
    }
    throw new \ErrorException($message, 0, $severity, $file, $line);
});

// Register shutdown function for fatal errors
register_shutdown_function(function (): void {
    $error = error_get_last();
    if ($error !== null && in_array($error['type'], [E_ERROR, E_CORE_ERROR, E_COMPILE_ERROR])) {
        error_log("FATAL: {$error['message']} in {$error['file']}:{$error['line']}");
        http_response_code(500);
        echo json_encode(['error' => 'FATAL_ERROR', 'message' => 'A fatal error occurred']);
    }
});

// Now any unhandled exception gets caught gracefully
// throw new \RuntimeException('Unhandled!');  // Caught by global handler
?>

<?php
/*
 * PHP 7+ Throwable Hierarchy:
 *
 * Throwable (interface)
 * ├── Error (internal engine errors)
 * │   ├── TypeError
 * │   ├── ValueError (PHP 8.0+)
 * │   ├── ArithmeticError
 * │   │   └── DivisionByZeroError
 * │   ├── ParseError
 * │   └── CompileError
 * └── Exception (application-level errors)
 *     ├── LogicException
 *     │   ├── InvalidArgumentException
 *     │   ├── OutOfRangeException
 *     │   └── LengthException
 *     └── RuntimeException
 *         ├── OverflowException
 *         ├── UnderflowException
 *         └── UnexpectedValueException
 */

// Catching both Errors and Exceptions
function safeDivide(mixed $a, mixed $b): float|string {
    try {
        // TypeError if non-numeric, DivisionByZeroError if $b is 0
        return $a / $b;
    } catch (\TypeError $e) {
        return "Type error: both arguments must be numeric";
    } catch (\DivisionByZeroError $e) {
        return "Cannot divide by zero";
    } catch (\Throwable $e) {
        // Catches ANYTHING - both Error and Exception subclasses
        return "Unexpected error: {$e->getMessage()}";
    }
}

echo safeDivide(10, 2);       // 5
echo safeDivide(10, 0);       // Cannot divide by zero
echo safeDivide('abc', 2);   // Type error (in strict mode)

// Catching Error types that would previously be fatal
function loadClass(string $className): object {
    try {
        return new $className();
    } catch (\Error $e) {
        echo "Fatal error caught: {$e->getMessage()}\n";
        return new \stdClass();
    }
}

$obj = loadClass('NonExistentClass');  // Fatal error caught gracefully

// Exception chaining - preserve the original cause
function processFile(string $path): string {
    try {
        if (!file_exists($path)) {
            throw new \RuntimeException("File not found: {$path}");
        }
        $content = file_get_contents($path);
        return strtoupper($content);
    } catch (\RuntimeException $e) {
        // Wrap in domain-specific exception, preserve original
        throw new AppException(
            'Failed to process file',
            'FILE_PROCESSING_ERROR',
            ['path' => $path],
            500,
            $e  // Previous exception preserved
        );
    }
}

try {
    processFile('/nonexistent.txt');
} catch (AppException $e) {
    echo $e->getMessage();               // Failed to process file
    echo $e->getPrevious()->getMessage(); // File not found: /nonexistent.txt
}
?>