PHP 8.x Features: Complete Guide to Modern PHP Development

PHP 8.x Features: Complete Guide to Modern PHP Development

PHP 8.x Features: Complete Guide to Modern PHP Development

Specialized Guide by Alaa Amer – Professional Web & App Developer

PHP 8.x introduced revolutionary changes that transformed how we write PHP code. In this comprehensive guide, we'll explore all the major features and improvements.

2️⃣ PHP 8.1: Enums and Performance Improvements

Enums - Type-Safe Constants:

<?php
// PHP 8.1+ Pure Enums
enum Status
{
    case PENDING;
    case APPROVED;
    case REJECTED;
    case CANCELLED;
}

// Backed Enums with values
enum UserRole: string
{
    case ADMIN = 'admin';
    case MODERATOR = 'moderator';
    case USER = 'user';
    case GUEST = 'guest';

    public function getPermissions(): array
    {
        return match($this) {
            UserRole::ADMIN => ['read', 'write', 'delete', 'manage'],
            UserRole::MODERATOR => ['read', 'write', 'moderate'],
            UserRole::USER => ['read', 'write'],
            UserRole::GUEST => ['read']
        };
    }

    public function canManageUsers(): bool
    {
        return $this === UserRole::ADMIN;
    }

    public static function fromString(string $role): ?UserRole
    {
        return UserRole::tryFrom(strtolower($role));
    }
}

// Integer-backed enum
enum Priority: int
{
    case LOW = 1;
    case MEDIUM = 2;
    case HIGH = 3;
    case CRITICAL = 4;

    public function getColor(): string
    {
        return match($this) {
            Priority::LOW => 'green',
            Priority::MEDIUM => 'yellow',
            Priority::HIGH => 'orange',
            Priority::CRITICAL => 'red'
        };
    }
}

// Usage
class Task
{
    public function __construct(
        public string $title,
        public Status $status = Status::PENDING,
        public Priority $priority = Priority::MEDIUM
    ) {}

    public function approve(): void
    {
        if ($this->status !== Status::PENDING) {
            throw new InvalidStateException('Task must be pending to approve');
        }

        $this->status = Status::APPROVED;
    }
}

$task = new Task('Fix bug', Priority::HIGH);
echo $task->priority->value; // 3
echo $task->priority->getColor(); // orange

Readonly Properties:

<?php
class Configuration
{
    public function __construct(
        public readonly string $appName,
        public readonly string $environment,
        public readonly array $database,
        public readonly bool $debugMode
    ) {}

    // Properties cannot be modified after construction
    // $config->appName = 'new name'; // Error!
}

class ImmutableValueObject
{
    public readonly string $id;
    public readonly DateTime $createdAt;

    public function __construct(string $id)
    {
        $this->id = $id;
        $this->createdAt = new DateTime();

        // After this point, properties cannot be changed
    }
}

Fibers - Cooperative Multitasking:

<?php
class AsyncTaskManager
{
    private array $fibers = [];

    public function addTask(callable $task): void
    {
        $fiber = new Fiber($task);
        $this->fibers[] = $fiber;
    }

    public function runAll(): void
    {
        while (!empty($this->fibers)) {
            foreach ($this->fibers as $key => $fiber) {
                if (!$fiber->isStarted()) {
                    $fiber->start();
                } elseif ($fiber->isSuspended()) {
                    $fiber->resume();
                }

                if ($fiber->isTerminated()) {
                    unset($this->fibers[$key]);
                }
            }
        }
    }
}

// Usage
function httpRequest(string $url): string
{
    echo "Starting request to {$url}\n";

    // Simulate async operation
    Fiber::suspend();

    // Resume here after suspension
    echo "Completed request to {$url}\n";
    return "Response from {$url}";
}

$manager = new AsyncTaskManager();
$manager->addTask(fn() => httpRequest('https://api1.example.com'));
$manager->addTask(fn() => httpRequest('https://api2.example.com'));
$manager->runAll();

4️⃣ PHP 8.3: Latest Features

Typed Class Constants:

<?php
// PHP 8.3+
class ApiConfig
{
    public const string BASE_URL = 'https://api.example.com';
    public const int TIMEOUT = 30;
    public const array HEADERS = ['Content-Type' => 'application/json'];
    public const bool DEBUG_MODE = false;

    private const string SECRET_KEY = 'super-secret'; // Private constant
}

interface DatabaseInterface
{
    public const string DEFAULT_CHARSET = 'utf8mb4';
    public const int CONNECTION_TIMEOUT = 5;
}

class DatabaseConnection implements DatabaseInterface
{
    // Must match interface types
    public const string DEFAULT_CHARSET = 'utf8mb4';
    public const int CONNECTION_TIMEOUT = 10; // Can have different value
}

Anonymous Readonly Classes:

<?php
// PHP 8.3+
class ResponseFactory
{
    public function createSuccessResponse(array $data): object
    {
        return new readonly class($data) {
            public function __construct(
                public array $data
            ) {}

            public function toJson(): string
            {
                return json_encode([
                    'success' => true,
                    'data' => $this->data,
                    'timestamp' => time()
                ]);
            }
        };
    }

    public function createErrorResponse(string $message, int $code = 400): object
    {
        return new readonly class($message, $code) {
            public function __construct(
                public string $message,
                public int $code
            ) {}

            public function toJson(): string
            {
                return json_encode([
                    'success' => false,
                    'error' => $this->message,
                    'code' => $this->code,
                    'timestamp' => time()
                ]);
            }
        };
    }
}

New json_validate() Function:

<?php
class JsonProcessor
{
    public function processJson(string $json): array
    {
        // PHP 8.3+ - More efficient than json_decode for validation
        if (!json_validate($json)) {
            throw new InvalidArgumentException('Invalid JSON provided');
        }

        return json_decode($json, true);
    }

    public function validateApiRequest(string $input): bool
    {
        // Fast validation without decoding
        return json_validate($input);
    }
}

💡 Migration Best Practices

1. Update gradually - Don't rush to change everything
2. Test thoroughly - Use PHPUnit for compatibility
3. Monitor performance - JIT may not help all applications
4. Update dependencies - Ensure library compatibility
5. Train team - New syntax requires learning
6. Document changes - Keep track of modernization

Next Step

Explore modern PHP frameworks like Laravel 10+ and Symfony 6+ that leverage these features.

📩 Need help migrating to modern PHP?