PHP 8 New Features Explained — Match, JIT, Nullsafe & More

<?php

// Simulating an order status coming from the database
$orderStatus = 3;

// OLD WAY: switch — loose comparison, easy to forget break, no return value
// This is the kind of code that causes 2am on-call incidents.
switch ($orderStatus) {
    case 1:
        $label = 'Pending';
        break;
    case 2:
        $label = 'Processing';
        break;
    case 3:
        $label = 'Shipped';
        break;
    default:
        $label = 'Unknown';
}
echo "Switch result: $label" . PHP_EOL;

// NEW WAY: match — strict comparison, returns a value, exhaustive by default
$label = match($orderStatus) {
    1       => 'Pending',
    2       => 'Processing',
    3, 4    => 'Shipped',   // multiple conditions share one arm — switch can't do this cleanly
    5       => 'Delivered',
    default => 'Unknown',
};

echo "Match result: $label" . PHP_EOL;

// Demonstrating strict type safety — this is the killer feature
$statusFromUrl = '3'; // user input is always a string

$labelFromUrl = match($statusFromUrl) {
    1 => 'Pending',
    2 => 'Processing',
    3 => 'Shipped',      // '3' (string) does NOT match 3 (int) — strict comparison
    default => 'Type mismatch caught safely',
};

echo "Strict check result: $labelFromUrl" . PHP_EOL;

// What happens with no match and no default?
try {
    $result = match(99) {
        1 => 'One',
        2 => 'Two',
        // no default — PHP 8 throws UnhandledMatchError instead of silently returning null
    };
} catch (\UnhandledMatchError $e) {
    echo "Caught: " . $e->getMessage() . PHP_EOL;
}

<?php

// Domain model — typical in any Laravel or Symfony application
class Country {
    public function __construct(
        public readonly string $name,
        public readonly string $isoCode
    ) {}

    public function getDiallingCode(): string {
        return match($this->isoCode) {
            'GB' => '+44',
            'US' => '+1',
            'DE' => '+49',
            default => 'unknown',
        };
    }
}

class Address {
    public function __construct(
        public readonly string $street,
        public readonly ?Country $country = null  // country is optional
    ) {}
}

class User {
    public function __construct(
        public readonly string $name,
        public readonly ?Address $shippingAddress = null  // address is optional
    ) {}
}

// --- Scenario 1: A fully populated user ---
$user = new User(
    name: 'Elena Vasquez',
    shippingAddress: new Address(
        street: '12 Baker Street',
        country: new Country('United Kingdom', 'GB')
    )
);

// BEFORE PHP 8 — readable nightmare
if ($user !== null && $user->shippingAddress !== null && $user->shippingAddress->country !== null) {
    $isoCodeOldWay = $user->shippingAddress->country->isoCode;
} else {
    $isoCodeOldWay = null;
}
echo "Old way ISO code: " . ($isoCodeOldWay ?? 'N/A') . PHP_EOL;

// PHP 8 nullsafe — one expression, same result, intent is crystal clear
$isoCode = $user?->shippingAddress?->country?->isoCode;
echo "Nullsafe ISO code: " . ($isoCode ?? 'N/A') . PHP_EOL;

// Chaining method calls also works — not just property access
$diallingCode = $user?->shippingAddress?->country?->getDiallingCode();
echo "Dialling code: " . ($diallingCode ?? 'N/A') . PHP_EOL;

// --- Scenario 2: A guest user with no address ---
$guestUser = new User(name: 'Guest');

// The chain short-circuits at ->shippingAddress (which is null)
// No error thrown — just returns null cleanly
$guestIsoCode = $guestUser?->shippingAddress?->country?->isoCode;
echo "Guest ISO code: " . ($guestIsoCode ?? 'N/A') . PHP_EOL;

<?php

// Union types in a real repository pattern
// The function genuinely accepts either an int ID or a string slug
function findProduct(int|string $identifier, bool $includeArchived = false): array|null {
    // In a real app this would hit a database
    $products = [
        ['id' => 1, 'slug' => 'wireless-keyboard', 'name' => 'Wireless Keyboard', 'archived' => false],
        ['id' => 2, 'slug' => 'usb-hub',           'name' => 'USB Hub',            'archived' => true],
    ];

    foreach ($products as $product) {
        // Match by either integer ID or string slug — the union type makes both valid
        $matchesId   = is_int($identifier)    && $product['id']   === $identifier;
        $matchesSlug = is_string($identifier) && $product['slug'] === $identifier;

        if ($matchesId || $matchesSlug) {
            // Respect the archived filter
            if ($product['archived'] && !$includeArchived) {
                return null; // found it but it's hidden
            }
            return $product;
        }
    }
    return null;
}

// --- Named arguments in action ---

// Old positional call — what does 'true' mean here? You have to read the signature.
$result1 = findProduct('usb-hub', true);
echo "Positional call: " . ($result1['name'] ?? 'Not found') . PHP_EOL;

// Named argument call — reads like plain English, order doesn't matter
$result2 = findProduct(
    identifier: 'usb-hub',
    includeArchived: true    // the intent is immediately obvious
);
echo "Named argument call: " . ($result2['name'] ?? 'Not found') . PHP_EOL;

// Named arguments let you skip to only the params you care about
// Without named args you'd need: findProduct(1, false) — the false is redundant noise
$result3 = findProduct(identifier: 1); // includeArchived uses its default
echo "Skip-to-param call: " . ($result3['name'] ?? 'Not found') . PHP_EOL;

// Union type enforcement — PHP 8 will throw TypeError if you pass a float
try {
    $invalid = findProduct(3.14); // float is not int|string
} catch (\TypeError $e) {
    // The error is caught HERE, at the boundary, not buried in your logic
    echo "Type enforced at boundary: " . $e->getMessage() . PHP_EOL;
}

// Built-in functions work with named arguments too — this is genuinely useful
$paddedId = str_pad(string: '42', length: 8, pad_string: '0', pad_type: STR_PAD_LEFT);
echo "Padded ID: $paddedId" . PHP_EOL;

<?php

// ============================================================
// CONSTRUCTOR PROMOTION — before and after
// ============================================================

// BEFORE PHP 8 — the three-step ritual every developer got tired of
class MoneyLegacy {
    private int $amountInPence;    // Step 1: declare the property
    private string $currencyCode;
    private string $formattedSymbol;

    public function __construct(
        int $amountInPence,        // Step 2: constructor parameter
        string $currencyCode,
        string $formattedSymbol
    ) {
        $this->amountInPence   = $amountInPence;    // Step 3: assign it
        $this->currencyCode    = $currencyCode;
        $this->formattedSymbol = $formattedSymbol;
    }

    public function format(): string {
        return $this->formattedSymbol . number_format($this->amountInPence / 100, 2);
    }
}

// PHP 8 CONSTRUCTOR PROMOTION — same result, 60% less code
// The 'private readonly' in the constructor IS the property declaration AND the assignment
class Money {
    public function __construct(
        private readonly int    $amountInPence,    // declared, parameter, and assigned in one shot
        private readonly string $currencyCode,
        private readonly string $formattedSymbol
    ) {}

    public function format(): string {
        return $this->formattedSymbol . number_format($this->amountInPence / 100, 2);
    }

    public function add(Money $other): Money {
        // Ensures currencies match before adding — real-world guard
        if ($this->currencyCode !== $other->currencyCode) {
            throw new \InvalidArgumentException(
                "Cannot add {$this->currencyCode} to {$other->currencyCode}"
            );
        }
        return new Money(
            amountInPence:    $this->amountInPence + $other->amountInPence,
            currencyCode:     $this->currencyCode,
            formattedSymbol:  $this->formattedSymbol
        );
    }
}

$price    = new Money(amountInPence: 1999, currencyCode: 'GBP', formattedSymbol: '£');
$shipping = new Money(amountInPence: 499,  currencyCode: 'GBP', formattedSymbol: '£');
$total    = $price->add($shipping);

echo "Item price: "    . $price->format()    . PHP_EOL;
echo "Shipping: "      . $shipping->format() . PHP_EOL;
echo "Total: "         . $total->format()    . PHP_EOL;

// Demonstrating the currency guard
try {
    $usdPrice = new Money(amountInPence: 2000, currencyCode: 'USD', formattedSymbol: '$');
    $price->add($usdPrice); // should throw
} catch (\InvalidArgumentException $e) {
    echo "Caught: " . $e->getMessage() . PHP_EOL;
}

// ============================================================
// JIT — you enable it in php.ini, not in code
// These settings are what you'd add to php.ini or a Docker config
// ============================================================
// opcache.enable=1
// opcache.jit_buffer_size=100M
// opcache.jit=tracing      <- 'tracing' is the recommended mode for web apps
//
// Verify JIT is active at runtime:
$jitStatus = opcache_get_status()['jit'] ?? null;
if ($jitStatus) {
    echo "JIT enabled: " . ($jitStatus['enabled'] ? 'Yes' : 'No') . PHP_EOL;
} else {
    echo "JIT status: OPcache not available in this environment" . PHP_EOL;
}