PHP 7.4.22 Released!
Beschikbaar!
PHP 8.0 is een omvangrijke update van de PHP programmeertaal.
Het bevat veel nieuwe mogelijkheden en optimalisaties, waaronder argument naamgeving, unie types, attributen, promotie van constructor eigenschappen, expressie vergelijking, null-veilige operator, JIT, en verbeteringen aan het type systeem, foute afhandeling, en consistentie.

Argument naamgeving RFC

PHP 7
htmlspecialchars($string, ENT_COMPAT | ENT_HTML401, 'UTF-8', false);
PHP 8
htmlspecialchars($string, double_encode: false);
  • Geef enkel vereiste parameters op, sla optionele parameters over.
  • Argumenten hebben een onafhankelijke volgorde en documenteren zichzelf.

Attributen RFC Doc

PHP 7
class PostsController
{
   
/**
     * @Route("/api/posts/{id}", methods={"GET"})
     */
   
public function get($id) { /* ... */ }
}
PHP 8
class PostsController
{
   
#[Route("/api/posts/{id}", methods: ["GET"])]
   
public function get($id) { /* ... */ }
}

In plaats van met PHPDoc annotaties kan je nu gestructureerde metadata gebruiken in PHP's eigen syntaxis.

Promotie van constructor eigenschappen RFC Doc

PHP 7
class Point {
  public
float $x;
  public
float $y;
  public
float $z;

  public function
__construct(
   
float $x = 0.0,
   
float $y = 0.0,
   
float $z = 0.0
 
) {
   
$this->x = $x;
   
$this->y = $y;
   
$this->z = $z;
  }
}
PHP 8
class Point {
  public function
__construct(
    public
float $x = 0.0,
    public
float $y = 0.0,
    public
float $z = 0.0,
  ) {}
}

Minder standaardcode nodig om eigenschappen te definiëren en initialiseren.

Unie types RFC Doc

PHP 7
class Number {
 
/** @var int|float */
 
private $number;

 
/**
   * @param float|int $number
   */
 
public function __construct($number) {
   
$this->number = $number;
  }
}

new
Number('NaN'); // Ok
PHP 8
class Number {
  public function
__construct(
    private
int|float $number
 
) {}
}

new
Number('NaN'); // TypeError

In plaats van met PHPDoc annotaties kan je de mogelijke types via unie types declareren zodat deze ook gevalideerd worden tijdens de runtime.

Expressie vergelijking RFC Doc

PHP 7
switch (8.0) {
  case
'8.0':
   
$result = "Oh no!";
    break;
  case
8.0:
   
$result = "This is what I expected";
    break;
}
echo
$result;
//> Oh no!
PHP 8
echo match (8.0) {
 
'8.0' => "Oh no!",
 
8.0 => "This is what I expected",
};
//> This is what I expected

De nieuwe match is gelijkaardig aan switch en heeft volgende eigenschappen:

  • Match is een expressie, dit wil zeggen dat je het in een variabele kan bewaren of teruggeven.
  • Match aftakkingen zijn expressies van één enkele lijn en bevatten geen break statements.
  • Match vergelijkingen zijn strikt.

Null-veilige operator RFC

PHP 7
$country null;

if (
$session !== null) {
 
$user = $session->user;

  if (
$user !== null) {
   
$address = $user->getAddress();
 
    if (
$address !== null) {
     
$country = $address->country;
    }
  }
}
PHP 8
$country = $session?->user?->getAddress()?->country;

In plaats van een controle op null uit te voeren kan je nu een ketting van oproepen vormen met de null-veilige operator. Wanneer één expressie in de ketting faalt, zal de rest van de ketting niet uitgevoerd worden en is het resultaat van de hele ketting null.

Verstandigere tekst met nummer vergelijkingen RFC

PHP 7
0 == 'foobar' // true
PHP 8
0 == 'foobar' // false

Wanneer PHP 8 een vergelijking uitvoert tegen een numerieke tekst zal er een numerieke vergelijking uitgevoerd worden. Anders zal het nummer naar een tekst omgevormd worden en er een tekstuele vergelijking uitgevoerd worden.

Consistente type fouten voor interne functies RFC

PHP 7
strlen([]); // Warning: strlen() expects parameter 1 to be string, array given

array_chunk([], -1); // Warning: array_chunk(): Size parameter expected to be greater than 0
PHP 8
strlen([]); // TypeError: strlen(): Argument #1 ($str) must be of type string, array given

array_chunk([], -1); // ValueError: array_chunk(): Argument #2 ($length) must be greater than 0

De meeste interne functies gooien nu een Error exception als de validatie van parameters faalt.

Just-In-Time compilatie

PHP 8 introduceert twee systemen voor JIT compilatie. De tracerende JIT is veelbelovend en presteert ongeveer 3 keer beter bij synthetische metingen en kan sommige langlopende applicaties 1.5–2 keer verbeteren. Prestaties van typische web applicaties ligt in lijn met PHP 7.4.

Relatieve JIT bijdrage aan de prestaties van PHP 8

Just-In-Time compilatie

Type systeem en verbeteringen van de fout afhandeling

  • Strikte type controles bij rekenkundige/bitsgewijze operatoren RFC
  • Validatie voor abstracte trait methodes RFC
  • Correcte signatures bij magic methods RFC
  • Herindeling van de engine warnings RFC
  • Fatal error bij incompatibele method signatures RFC
  • De @ operator werkt niet meer bij het onderdrukken van fatale fouten.
  • Overerving bij private methods RFC
  • Mixed type RFC
  • Static return type RFC
  • Types voor interne functies Email draadje
  • Opaque objects in plaats van resources voor Curl, Gd, Sockets, OpenSSL, XMLWriter, and XML extensies

Andere syntaxis aanpassingen en verbeteringen

  • Sta toe om een komma te plaatsen bij het laatste parameter in een lijst RFC en bij de use in closures RFC
  • Catches die niets vangen RFC
  • Variabele Syntaxis Aanpassingen RFC
  • Namespaced namen worden als één enkel token afgehandeld RFC
  • Throw is nu een expressie RFC
  • ::class werkt bij objecten RFC

Nieuwe Classes, Interfaces, en Functies

To Top