Modern PHP Cheat Sheet

# Arrays

# Destructuring 7.1

You can destructure arrays to pull out several elements into separate variables:

$array = [1, 2, 3];

// Using the list syntax:
list($a, $b, $c) = $array;

// Or the shorthand syntax:
[$a, $b, $c] = $array;

You can skip elements:

[, , $c] = $array;

// $c = 3

As well as destructure based on keys:

$array = [
    'a' => 1,
    'b' => 2,
    'c' => 3,
];

['c' => $c, 'a' => $a] = $array;

# Rest and Spread Operators 5.6

Arrays can be spread into functions:

$array = [1, 2];

function foo(int $a, int $b) { /* … */ }

foo(...$array);

Functions can automatically collect the rest of the variables using the same operator:

function foo($first, ...$other) { /* … */ }

foo('a', 'b', 'c', 'd', …);

Rest parameters can even be type hinted:

function foo($first, string ...$other) { /* … */ }

foo('a', 'b', 'c', 'd', …);

7.4 Arrays with numerical keys can also be spread into a new array:

$a = [1, 2];
$b = [3, 4];

$result = [...$a, ...$b]; // [1, 2, 3, 4]

8.1 You can also spread arrays with textual keys starting from PHP 8.2

# Attributes 8.0

Make your own by tagging a class with #[Attribute]

#[Attribute]
class ListensTo
{
    public string $event;

    public function __construct(string $event)
    {
        $this->event = $event;
    }
}

You can add them to properties, (anonymous) classes, functions, constants, closures, function arguments:

#[
    Route(Http::POST, '/products/create'),
    Autowire,
]
class ProductsCreateController
{
    public function __invoke() { /* … */ }
}

Use reflection to get them, you can pass in optional arguments to `getAttributes` in order to filter the result:

$attributes = $reflectionClass->getAttributes(
    ContainerAttribute::class,
    ReflectionAttribute::IS_INSTANCEOF
);

# Closures

# Short Closures 7.4

Short closures have automatic access to the outer scope, and only allow a single expression which is automatically returned:

array_map(
    fn($x) => $x * $this->modifier,
    $numbers
);

# First class callables 8.1

You can now make a closure from a callable by calling that callable and passing it '...' as its argument

function foo(int $a, int $b) { /* … */ }
 $foo = foo(...);
 $foo(a: 1, b: 2);

# Cosmetics

# Class Names 8.0

As of PHP 8, you can use ::class on objects as well:

Order::class;

$object::class;

# Numeric Values 7.4

Use the _ operator to format numeric values:

$price = 100_10;
// $100 and 10 cents

# Trailing Commas 8.0

Trailing commas are allowed in several places:

Arrays
Function calls
Function definitions
Closure use statements

# Enums

# Declaring Enums 8.1

Enums are built-in in the language:

enum Status
 {
     case DRAFT;
     case PUBLISHED;
     case ARCHIVED;
 }

# Enum methods 8.1

Enums can have methods, as well as have a string or integer value per case:

enum Status: int
 {
     case DRAFT = 1;
     case PUBLISHED = 2;
     case ARCHIVED = 3;

     public function color(): string
     {
         return match($this)
         {
             Status::DRAFT => 'grey',
             Status::PUBLISHED => 'green',
             Status::ARCHIVED => 'red',
         };
     }
 }

# Exceptions 8.0

Throwing an exception is an expression now, which means there are more places you can throw from, such as short closures or as a null coalescing fallback:

$error = fn($message) => throw new Error($message);

$input = $data['input'] ?? throw new Exception('Input not set');

You also don't have to catch an exception with a variable anymore:

try {
    // …
} catch (SpecificException) {
    throw new OtherException();
}

# Match 8.0

Similar to switch, but with strong type checks, no break keyword, combined arms and it returns a value:

$message = match ($statusCode) {
    200, 300 => null,
    400 => 'not found',
    500 => 'server error',
    default => 'unknown status code',
};

# Dealing with null

# Null Coalescing 7.0

Use the null coalescing operator to provide a fallback when a property is null:

$paymentDate = $invoice->paymentDate ?? Date::now();

It also works nested:

$input = $data['few']['levels']['deep'] ?? 'foo';

7.4

You can use the null coalescing assignment operator to write the value into the original variable when it's null:

$temporaryPaymentDate = $invoice->paymentDate ??= Date::now();

// $invoice->paymentDate is now also set

# Nullsafe Operator 8.0

Chain methods that possibly return null:

$invoice
    ->getPaymentDate()
    ?->format('Y-m-d');

The nullsafe operator can also be chained multiple times:

$object
    ?->methodA()
    ?->methodB()
    ?->methodC();

# Named Arguments 8.0

Pass in arguments by name instead of their position:

setcookie(
    name: 'test',
    expires: time() + 60 * 60 * 2,
);

Named arguments also support array spreading:

$data = [
    'name' => 'test',
    'expires' => time() + 60 * 60 * 2,
];

setcookie(...$data);

# Performance

# The JIT 8.0

Enable the JIT by specifying a buffer size in your ini settings; you can switch the jit mode between function or tracing:

opcache.jit_buffer_size=100M

opcache.jit=function
; opcache.jit=tracing

# Preloading 7.4

Add opcache.preload to your ini settings:

opcache.preload=/path/to/project/preload.php

Every file that's loaded in the preload script will be preloaded into memory until server restart.

# Properties

# Property Promotion 8.0

Prefix constructor arguments with public, protected or private to make them promoted:

class CustomerDTO
{
    public function __construct(
        public string $name,
        public string $email,
        public DateTimeImmutable $birth_date,
    ) {}
}

You can still add a constructor body, and combine both promoted and non-promoted properties:

class MyClass
{
    public string $b;

    public function __construct(
        public string $a,
        string $b,
    ) {
        assert($this->a !== 'foo');

        $this->b = $b;
    }
}

# Using new in initializers 8.1

PHP 8.2 allows you to use the new keyword in function definitions as a default parameter, as well as in attribute arguments and other places.

class MyController {
     public function __construct(
         private Logger $logger = new NullLogger(),
     ) {}
 }

This also means that nested attributes are a thing now:

#[Assert\All(
     new Assert\NotNull,
     new Assert\Length(max: 6),
 )]

# Read only properties 8.1

Properties can be marked readonly:

class Offer
 {
     public readonly ?string $offerNumber = null;
     public readonly Money $totalPrice;
}

Once a readonly property is set, it cannot change ever again.

8.2

Classes can be completely readonly:

readonly class Offer
 {
     public ?string $offerNumber = null;
     public Money $totalPrice;
}

All properties of a class will become readonly, adding properties dynamically is impossible.

# Types

# Built-in Types

During the PHP 7.x releases and with PHP 8, several new built-in types were added:

void: a return type indicating nothing's returned 7.1
static: a return type representing the current class or its children 8.0
object: anything that is an object 7.2
mixed: anything 8.0

# Union Types 8.0

Combine several types into one union, which means that whatever input must match one of the given types:

interface Repository
{
    public function find(int|string $id);
}

# Typed properties 7.4

Add types to your class properties:

class Offer
{
    public ?string $offerNumber = null;

    public Money $totalPrice;
}

Beware of the uninitialized state, which is only checked when reading a property, and not when constructing the class:

$offer = new Offer();

$offer->totalPrice; // Error

# Intersection Types 8.1

Combine several types into one intersection, which means that whatever input must match all of the given types

public function url(WithId&WithSlug $obj): string;

# DNF Types 8.2

You can create a union of intersection types, useful for creating a nullable intersection type:

public function url((WithId&WithSlug)|null $obj): string;