PHP CheatSheet

This cheatsheet outlines when some various handy features were introduced in different versions of PHP.

Obviously not intended to be a comprehensive list.

PHP 8.4

Class property hooks. Property hooks can also be defined in interfaces

class User {
  public string $phone {
      set (string $newPhone) {
          // validate phone
      }
      get => $this->phone;
  }
}

Asymmetric visibility for class properties. This means a property can be public/protected/private depending on if the property is being read or written. Also works for properties promoted in the constructor
```
class User {
  // This property can only be set from inside the class
  public private(set) string $name;
}
```
New array functions
- array_find takes a callback and returns the first element for which the callback returns true
- array_find_key which is the same as array_find but returns the key
- array_any returns true if at least one element matches the callback
- array_all returns true if all elements match the callback

Read-only classes

readonly class Person {
  public function __construct(
      public string $name,
      public string $address,
  ) {}
}

null, true, and `false are standalone types

function bigNope(): false {
  return false;
}

Combine union and intersection types

function createAnimal( (Cat|Dog)|null $animal ) {
  // do stuff
}

Traits can have constants, though the constant is only accessible from the class that uses the trait.

enum Color {
  case Red;
  case Green;
  case Blue;
}

Array unpacking with string keys (unpacking previously only worked with numeric keys)

$a1 = ["a" => 1];
$a2 = ["b" => 2];

$newArr = [...$a1, ...$a2];

// ["a" => 1, "b" => 2]

Use new for default parameter values or constructor property promotion
- function foo( $input = new Bar() )
Readonly class properties: public readonly string $name (also works with constructor property promotion)
First-class callable syntax

function foo(int $a, int $b) { }

$foo = foo(...);
$foo(1, 2);

Intersection types. Similar to Union types but the input must be all of the specified types.
New never return type for functions. Signifies that the function wills top all program flow.
New array_is_list function.
Specify class constants as final to prevent them from being overridden during inheritance.

Union types
- function foo(Foo|Bar $input): int|float
Nullsafe operator
- $dateAsString = $booking->getStartDate()?->asDateTimeString();
Named function arguments
- function foo(string $a, ?string $c = null)
- foo(a: 'this is a', c: 'this is c')
Attributes
Constructor property promotion

class Thing {
  public function __construct(
  	public string $name = ''
  ) {}
}

$thing = new Thing('Mark');

echo $this->name;

Match expressions
- Similar to switch between results can be returned or stored.
- break not needed
- Strict comparisons

echo match (8.0) {
  '8.0' => "Oh no!",
  8.0 => "This is what I expected",
};

Type declarations for class properties
- Excludes void and callable
- Nullable is allowed private ?string $s;
Spread operator to merge arrays
- ['a', 'b', ...$others]
Arrow functions
- fn($n) => $n + 1
- Automatically inherits variables in the parent scope without needing use()
Null coalescing assignment operator ??=

object type declarations which allows passing or returning any arbitrary class or object
- function f(object $thing)
Trailing commas in grouped namespaces
- use App\Stuff\{Thing1, Thing2, Thing3,}

Type declarations for
- Function arguments (scalar types like int, string, etc)
- Function return values
Null coalescing operator ??
Spaceship operator <=>
Constant arrays using define()

heredoc and nowdoc strings
Variadic functions with ...
- function foo($arg1, ...$moreArgs)
Exponentiation with **
Type declarations for
- Function arguments (classes, arrays, interfaces, or callback)
Grouped namespaces
- use App\Stuff\{Thing1, Thing2, Thing3}