Modern PHP 8 Features

Why modern syntax matters

The PHP you have written so far works, but it looks like PHP from ten years ago. Every paid course today teaches PHP 8 — and the code you will see in real jobs and in Laravel leans heavily on the features below. They make code safer (the engine checks your types) and shorter (less boilerplate). None of this changes how PHP runs; it just lets you say more, more clearly.

Type declarations

A type declaration is a label that says what kind of value a parameter takes, what a function returns, or what a property holds. PHP then enforces it — pass the wrong type and you get a clear error instead of a silent bug. This is the single biggest upgrade to your everyday code.

Below, int before each parameter says "this must be a whole number", and the : int after the brackets says "this function returns a whole number":

<?php
  declare(strict_types=1);   // make PHP strict about types

  function add(int $a, int $b): int {
    return $a + $b;
  }

  echo add(5, 3);     // 8
  // echo add("5", "3");  // TypeError — a string is not an int
?>

Reading it: declare(strict_types=1) at the very top tells PHP not to quietly convert types for you, so mistakes surface immediately. add(int $a, int $b): int promises both inputs and the output are integers. Call it with two numbers and it returns their sum; call it with text and PHP throws a TypeError before any wrong answer can spread.

You can type properties too. A *typed property* guarantees an object always holds the right kind of data:

<?php
  class Product {
    public string $name;
    public float $price;
    public ?string $note = null;   // ? means "string OR null"
  }

  $p = new Product();
  $p->name = "Keyboard";
  $p->price = 1299.00;
?>

Each property declares its type: $name is always a string, $price always a float (a decimal number). The ?string on $note is a nullable type — the ? means the value may be a string or null (nothing yet). Try to set $p->price to text and PHP rejects it.

The match expression

You met switch earlier. match is its modern replacement: it compares with strict === (no surprises), needs no break, and — crucially — it returns a value you can store. It is tidier and safer for turning one value into another.

<?php
  $status = "shipped";

  $label = match ($status) {
    "pending"  => "Waiting to be processed",
    "shipped"  => "On its way",
    "delivered" => "Arrived",
    default    => "Unknown status",
  };

  echo $label;
?>

Read match ($status) as "look at $status and pick the matching arm". Here $status is "shipped", so the "shipped" => arm wins and its text becomes the value of the whole expression, which we store in $label. default catches anything not listed. Unlike switch, there is no fall-through to worry about and the result drops straight into a variable.

Enums — a fixed set of choices

An enum (short for *enumeration*) defines a small, fixed list of allowed values, each with a name. Instead of passing around loose strings like "shipped" (easy to mistype), you use OrderStatus::Shipped — and PHP guarantees it is one of the real options.

<?php
  enum OrderStatus: string {
    case Pending  = "pending";
    case Shipped  = "shipped";
    case Delivered = "delivered";
  }

  function describe(OrderStatus $status): string {
    return match ($status) {
      OrderStatus::Pending  => "Waiting",
      OrderStatus::Shipped  => "On its way",
      OrderStatus::Delivered => "Arrived",
    };
  }

  echo describe(OrderStatus::Shipped);
?>

The enum OrderStatus: string lists exactly three valid cases, each tied to a string value. The describe function is typed to accept only an OrderStatus — you literally cannot pass it a misspelled status, because nothing but OrderStatus::Pending, ::Shipped or ::Delivered exists. We then match on which case it is to build the label.

Named arguments & variadic functions

Named arguments let you pass values by their parameter name instead of by position — clearer, and you can skip optional ones. A variadic function (the ... before a parameter) accepts *any number* of arguments, bundled into an array.

<?php
  function makeUser(string $name, string $role = "member", bool $active = true): string {
    return "$name ($role) — " . ($active ? "active" : "inactive");
  }

  // named arguments — skip $role, set $active by name
  echo makeUser(name: "Asha", active: false);

  function sum(int ...$numbers): int {
    return array_sum($numbers);
  }
  echo "<br>" . sum(1, 2, 3, 4);   // any count of numbers
?>

In makeUser(name: "Asha", active: false) we label each value, so we can leave $role at its default "member" while still setting $active — no need to remember the position or pass placeholder values. In sum(int ...$numbers), the ... collects every argument into the $numbers array, so sum(1, 2, 3, 4) adds all four; you could pass two or twenty.

Arrow functions & the nullsafe operator

An arrow function (fn) is a one-line shorthand for a small function — perfect inside array_map or array_filter. The nullsafe operator ?-> safely reaches into an object that *might* be null: instead of crashing, the whole expression just becomes null.

<?php
  $prices = [100, 250, 90];
  $withTax = array_map(fn($p) => $p * 1.18, $prices);
  print_r($withTax);

  $user = null;
  echo $user?->name ?? "Guest";   // no crash — gives "Guest"
?>

The arrow function fn($p) => $p * 1.18 is a compact recipe "take a price, add 18% tax". array_map runs it on every item in $prices and returns a new array of taxed prices. Lower down, $user is null; writing $user->name would normally crash, but $user?->name stops safely at the null, and the ?? "Guest" then supplies a fallback.