Exploring PHP 8.0

Recent PHP History

PHP 7.0, 2015

Return types, scalar types, spaceship, null coalesce, anon classes

PHP 7.1, 2016

iterable type, Nullable types, void returns

PHP 7.2, 2017

object type

PHP 7.3, 2018

Some minor stuff

PHP 7.4, 2019

Short lambdas, typed properties, null coalesce assign, array splat

PHP 8.0, 2020

So so much...

PHP 8.0 is the biggest release since...

PHP 7.4

Type improvements

Union types

function mangleUsers(string|array $users): array
{
    if (is_string($users)) {
        $users = [$users];
    }
    // ...
}
					

Union types

function doMath(int|float $in): int|float
{
    // ...
}
					

Union types

function handleRequest(RequestInterface $req):
          RequestInterface|ResponseInterface
{
    // ...
}
					

Speciality Unions

• null is a type, equivalent to ?
• false is a return type only, don't use it
• mixed ~ untyped, so use mixed

static returns

interface TaskBuilder
{
    public function addStep(Step $s): static;
}

class ImportantTask implements TaskBuilder
{
    public function addStep(Step $s): static
    {
        $this->steps[] = $s;
        return $this;
    }
}
        

addStep() returns ImportantTask, not TaskBuilder.

Improved string functions

str_*_with()

$needle = 'hello';

if (str_starts_with('hello world', $needle)) {
    print "This must be your first program.";
}
					

$needle = 'world';

if (str_ends_with('hello world', $needle)) {
    print "You say hello to everyone else but not me?";
}
					

In PHP 7.4...

0 == "wait, what?";           // true
0 == "";                      // true
99 == '99 bottles of beer';   // true
42 == '     42';              // true
42 == '42     ';              // false, only sometimes
in_array(0, ['a', 'b', 'c']); // true
					

"Burning Match Novoflex adaptor NX NIK 85mm Samsung NX200" by zen whisk is licensed under CC BY-ND 2.0

Have you done this?

$display = $user->isAdmin()
    ? $user->name() . ' (admin)'
    : $user->name() . ' (muggle)'
;
        

• Clean branching expression
• Encourages simple expressions
• Encourages factoring out to functions
• Only works for true/false :-(

match() expressions

$display = match($user->isAdmin()) {
    true  => $user->name . ' (admin)',
    false => $user->name . ' (muggle)',
};
        

• === match
• Returns expression
• No fall-through
• Must be exhaustive

This...

switch ($var) {
    case 'a':
        $message = "The variable was a.";
        break;
    case 'b':
        $message = "The variable was b.";
        break;
    case 'c':
        $message = "The variable was c.";
        break;
    default:
        $message = "The variable was something else.";
        break;
}
        

Becomes this

$message = match($var) {
    'a' => 'The variable was a',
    'b' => 'The variable was b',
    'c' => 'The variable was c',
    default => 'The variable was something else',
};
        

Nullsafe methods

Null: The billion dollar mistake

"100 Billion Dollars" by Peat Bakke is licensed under CC BY 2.0

Cleaning up someone else's null

$user = get_user($id);
if (!is_null($user)) {
    $address = $user->getAddress();
    if (!is_null($address)) {
        $state = $address->state;
        if (!is_null($state)) {
            // And so on.
        }
    }
}
          

PHP 8.0

$state = get_user($id)?->getAddress()?->state;
        

Moar warnings and errors

From warning to error exception

Modify property of non-object

$not_object->foo = 'bar'

Writing to scalar value as array

$an_int[] = 4;

Invalid argument for foreach()

foreach($an_int as $x) {}

foreach($not_traversable as $x) {}

Illegal offset

print $arr[$an_object]

Division by zero

$val = 5/0

From notice to warning

Array offset on non-array

$an_int[4]

Access property of non-object

$a_string->name

Array to string conversion

print $an_array

Undefined property

$object->does_not_exist

Undefined variable

print $does_not_exist

Undefined variables are now Warnings!

Moar commas

2017

RFC: Allow trailing commas in...

• function arguments
• function declaration
• grouped namespaces
• implements clause for interfaces
• use clauses for traits
• class property list
• closure use statement

¯\_(ツ)_/¯

Commas!

class Address
{
    public function __construct(
        string $street,
        string $number,
        string $city,
        string $state,
        string $zip,     // This is new.
    ) {
    // ...
    }
}
        

More Commas!

$a ='A';
$b = 'B';
$c = 'C';

$dynamic_function = function(
  $first,
  $second,
  $third, // This is new, as before.
) use (
  $a,
  $b,
  $c,     // This is also new.
);
        

Constructor Promotion

PHP 7.4 and earlier

class FormRenderer
{
    private ThemeSystem $theme;
    private UserRepository $users;
    private ModuleSystem $modules;

    public function __construct(
        ThemeSystem $theme,
        UserRepository $users,
        ModuleSystem $modules
    ) {
        $this->theme = $theme;
        $this->users = $users;
        $this->modules = $modules;
    }

    public function render(Form $form): string
    {
        // ...
    }
}
          

PHP 8.0

class FormRenderer
{
    public function __construct(
        private ThemeSystem $theme,
        private UserRepository $users,
        private ModuleSystem $modules,
    ) { }

    public function renderForm(Form $form): string
    {
        // ...
    }
}
          

Mix and match

class FormRenderer
{
    private User $currentUser;

    public function __construct(
        private ThemeSystem $theme,
        private UserRepository $users,
        private ModuleSystem $modules,
    ) {
        $this->currentUser = $this->users->getActiveUser();
    }

    public function renderForm(Form $form): string
    {
        // ...
    }
}
        

Trivial value objects

Class MailMessage
{
    public function __construct(
        public string $to,
        public string $subject,
        public string $from,
        public string $body,
        public array $cc,
        public array $bcc,
        public string $attachmentPath,
    ) {}
}
        

Meta(meta(data))

(~Doctrine Annotations but in core)

Attributes

#[GreedyLoad]
class Product
{
    #[Positive]
    protected int $id;

    #[Admin]
    public function refillStock(int $quantity): bool
    {
        // ...
    }
}
        

Example: Tukio

function my_listener(MyEvent $event): void { ... }

$provider = new OrderedListenerProvider();

// How you normally add a listener to a provider.
$provider->addListener('my_listener', 5, 'listener_a', MyEvent::class);
        

Step 1: Define attribute

namespace Crell\Tukio;

use \Attribute;

#[Attribute]
class Listener implements ListenerAttribute
{
   public function __construct(
       public ?string $id = null,
       public ?string $type = null,
   ) {}
}
        

Step 1.5: Restrict attribute

namespace Crell\Tukio;

use \Attribute;

#[Attribute(Attribute::TARGET_FUNCTION | Attribute::TARGET_METHOD)]
class Listener implements ListenerAttribute
{
   public function __construct(
       public ?string $id = null,
       public ?string $type = null,
   ) {}
}
        

Step 2: Tag it

use Crell\Tukio\Listener;

#[Listener('listener_a')]
function my_listener(MyEvent $event): void { ... }

$provider = new OrderedListenerProvider();

$provider->addListener('my_listener', 5);
        

Step 3: Interpret it

Use Crell\Tukio\Listener;

/// A string means it's a function name,
// so reflect on it as a function.
if (is_string($listener)) {
    $ref = new \ReflectionFunction($listener);
    $attribs = $ref->getAttributes(
        Listener::class,
        \ReflectionAttribute::IS_INSTANCEOF,
    );
    $attributes = array_map(
        fn(\ReflectionAttribute $attrib) => $attrib->newInstance(),
        $attribs,
    );
}
        

Symfony 5.2

use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Security\Http\Attribute\CurrentUser;

class SomeController
{
    #[Route('/path', 'action_name')]
    public function index(#[CurrentUser] MyUser $user)
    {
        // ...
    }
}
        

Promoted parameter attributes

class Point
{
    public function __construct(
        #[Positive]
        public int $x,
        #[Positive]
        public int $y
    ) {}
}
        

Applies to parameter and property

What does this do?

$new = array_fill(0, 100, 50);
          

• 50, 100 times?
• 100, 50 times?

That's what this does!

array_fill(start_index: 0, count: 100, value: 50);
          

Any order

array_fill(
  value: 50,
  count: 100,
  start_index: 0,
);
        

array_fill(
  value: 50,
  0,
  count: 100,
);
          

Variadics

// Indexed array, so the values will map to indexed parameters.
$params = [0, 100, 50];
array_fill(...$params);

// Named array, so the values will map to named parameters.
$params = ['count' => 100, 'start_index' => 0, 'value' => 50];
array_fill(...$params);
          

$args['value'] = $request->get('val') ?? 'a';
$args['start_index'] = 0;
$args['count'] = $config->getSetting('array_size');

$array = array_fill(...$args);
            

Value objects

class Url implements UrlInterface
{
    public function __construct(
        private string $scheme = 'https',
        private ?string $authority = null,
        private ?string $userInfo = null,
        private string $host = '',
        private ?int $port = 443,
        private string $path = '',
        private ?string $query = null,
        private ?string $fragment = null,
    ) {}
}
        

Attributes

class SomeController
{
    #[Route(
          path: '/path',
          name: 'action',
    )]
    public function someAction()
    {
        // ...
    }
}
        

The most important use case...

if (in_array(haystack: $arr, needle: 'A')) {
    // ...
}
        

¯\_(ツ)_/¯