PHP8 - What's New In PHP8? Cheat Sheet

A Programming › PHP cheat sheet in English by DaveChild

A rundown of the changes in PHP8

PHP Development LAMP Programming Web Php8

15,515 views 3,073 downloads 31 Mar 2021 History

PRs

PHP8 Variable Types

Class/interface name	An instance of the class or interface
self	The same class the type is used in
parent	The parent of the class the type is used in
callable	Something callable
bool	A boolean
int	An integer
float	A float
string	A string
array	An array
iterable	Array or traversable
object	An object
mixed	Any value
Return Types
void	Function will not return anything
static	Function may return `static`

New `mixed` type

Mixed means any one of:
	array	bool	callable
	string	int	resource
	float	null	object

Note that because mixed already contains null, it is not nullable itself.

Return static

class Foo
{
    public function test(): static
    {
        return new static();
    }
}

Static is now a valid return type.

The nullsafe operator (copy)

$foo = $bar->getBaz()?->asFormatted();

Quickly check for nulls in method returns.

Union types

public function foo(Foo|Bar $input): int|float;

You can now specify more than one type in a type hint:
• The void type cannot be part of a union.
• Unions can be nullable by including null as a type or preceding with a question mark.

Named arguments

function foo(string $a, int $b, ?string $c = null)
{
    ...
}

foo(
    c: 'value c',
    a: 'value a'
);

Pass values to functions and methods by name, regardless of the order in which they are defined.

Attributes

use App\Attributes\ExampleAttribute;

#[ExampleAttribute]
class Foo
{
    #[ExampleAttribute]
    public const FOO = 'foo';
 
    #[ExampleAttribute]
    public $x;
 
    #[ExampleAttribute]
    public function foo(#[ExampleAttribute] $bar) { }
}

Structured metadata

Match expression

$result = match($input) {
    0 => "hello",
    '1', '2', '3' => "world",
};

Switch statements made simple. Note, the comparisons made by match use strict types.

Constructor property promotion

class Money 
{
    public function __construct(
        public Currency $currency,
        public int $amount,
    ) {}
}

In the above example Currency and int are both automatically made public properties of the class and assigned values on construction.

Weak maps

class Foo 
{
    private WeakMap $cache;
 
    public function getSomethingWithCaching(object $obj): object
    {
        return $this->cache[$obj]
           ??= $this->computeSomethingExpensive($obj);
    }
}

A weak map allows for storage of key-value pairs, but the PHP garbage collection will drop a weak map element where the only reference to it is the weak map itself.

Throw expression

$triggerError = fn () => throw new MyError();
$foo = $bar['offset'] ?? throw new CustomEx('offset');

Throw is now an expression instead of a statement, making it more flexible.

Non-capturing catches

try {
    // Something goes wrong
} catch (MySpecialException) {
    Log::error("Something went wrong");
}

When you catch exceptions and throwables, you no longer need a variable.

::class on objects

$foo = new Foo();
var_dump($foo::class);

Works the same as get_class().

Trailing comma in parameter lists

public function(
    string $parameterA,
    int $parameterB,
    Foo $objectfoo,
) {
    // …
}

You can now end a parameter list with a comma without an error.

Create DateTime objects from interfaces

DateTime::createFromInterface(DateTimeInterface $other);
DateTimeImmutable::createFromInterface(DateTimeInterface $other);

New Stringable interface

class Foo
{
    public function __toString(): string
    {
        return 'foo';
    }
}

function bar(string|Stringable $stringable) { /* … */ }

bar(new Foo());
bar('abc');

New functions

`str_contains('haystack', 'needle')`	Does haystack contain needle?
`str_starts_with('haystack', 'needle')`	Does haystack start with needle?
`str_ends_with('haystack', 'needle')`	Does haystack end with needle?
`fdiv()`	Handles division by zero without an error.
`get_debug_type()`	Like `gettype()` but with more detail
`get_resource_id()`	Fetch the numeric ID of a resource

Breaking Changes

Internal errors and engine warnings have been made consistent and/or reclassified.

The @ operator no longer silences fatal errors.

The default error reporting level is now E_ALL.

The default PDO error mode is no longer silent.

Concatenation precedence has changed - addition now precedes concatenation.

Namespaces can now include reserved names.

ReflectionFunction::isDisabled(), ReflectionParameter::getClass() and ReflectionParameter::isCallable() have been deprecated.

There are more breaking and engine changes, this list is limited to those you are most likely to encounter. For a full run-down, check out Brent's article linked below.

With Thanks

This is a condensed version of the excellent PHP8 write-up you can find by Brent at stitcher.io

Badges

Downloaded from Unusual Locations × 3

Comments

No comments yet.