{"id":40052,"date":"2021-09-16T09:28:38","date_gmt":"2021-09-16T07:28:38","guid":{"rendered":"https:\/\/kinsta.com\/?p=101567"},"modified":"2023-05-22T14:20:19","modified_gmt":"2023-05-22T12:20:19","slug":"php-8-1","status":"publish","type":"post","link":"https:\/\/kinsta.com\/nl\/blog\/php-8-1\/","title":{"rendered":"Wat is er nieuw in PHP 8.1: features, veranderingen, verbeteringen en meer"},"content":{"rendered":"

PHP 8.1, uitgebracht op 25 november 2021 is eindelijk hier<\/a>, boordevol verschillende opwindende features.<\/p>\n

In dit artikel bespreken we in detail wat er nieuw is in PHP 8.1. Van de nieuwe features en prestatieverbeteringen tot belangrijke wijzigingen en afschrijvingen, we behandelen ze allemaal uitvoerig.<\/p>\n

Let’s go!<\/p>\n

<\/div><\/kinsta-auto-toc>\n

Nieuwe features in PHP 8.1<\/h2>\n

Laten we beginnen met het behandelen van alle nieuwe features in PHP 8.1. En dat is nogal een lijst.<\/p>\n

<\/div><\/kinsta-auto-toc>\n\n

Pure intersection types<\/h3>\n

PHP 8.1 voegt ondersteuning toe voor intersection types. Deze zijn vergelijkbaar met union types<\/a> die met PHP 8.0 hun intrede deden, maar waarvoor je ze kan gebruiken is precies het tegenovergestelde.<\/p>\n

Om het gebruik ervan beter uit te leggen, is het goed om even kort te herhalen hoe type declarations werken in PHP.<\/p>\n

In wezen kan je type declarations toevoegen aan function arguments, return values en class properties. Deze toewijzing wordt type hinting genoemd en zorgt ervoor dat de waarde van het juiste type is wanneer je deze callt. In andere gevallen geeft deze meteen een TypeError<\/a>. Dit helpt je om je code beter de debuggen.<\/p>\n

Het declaren van een enkel type heeft echter zijn beperkingen. Union types helpen je dit obstakel te overbruggen door je toe te staan een waarde met meerdere types te declaren, en de invoer moet ten minste voldoen aan \u00e9\u00e9n van de gedeclareerde types.<\/p>\n

Het RFC<\/a> beschrijft intersection types als volgt:<\/p>\n

Een “intersection type” vereist een waarde om te voldoen aan meerdere type constraints in plaats van aan \u00e9\u00e9n.<\/em><\/p>\n

…pure intersection types worden gespecificeerd met behulp van de syntaxis T1&T2&… en kunnen worden gebruikt in alle posities waar types momenteel worden geaccepteerd…<\/em><\/p><\/blockquote>\n

Let op het gebruik van de &<\/code> (AND) operator om de intersection types te declareren. Daarentegen gebruiken we de |<\/code> (OR) operator om union types te declaren.<\/p>\n

Het gebruik van de meeste standaardtypes in een intersection type zal resulteren in een type waaraan nooit kan worden voldaan (bijv. integer en string). Daarom kunnen intersection types alleen class types bevatten (bijv. interfaces en class names).<\/p>\n

Dit is voorbeeldcode van hoe je intersection types kan gebruiken:<\/p>\n

class A {\n\u00a0 \u00a0 private Traversable&Countable $countableIterator;\n \n\u00a0 \u00a0 public function setIterator(Traversable&Countable $countableIterator): void {\n\u00a0 \u00a0 \u00a0 \u00a0 $this->countableIterator = $countableIterator;\n\u00a0 \u00a0 }\n \n\u00a0 \u00a0 public function getIterator(): Traversable&Countable {\n\u00a0 \u00a0 \u00a0 \u00a0 return $this->countableIterator;\n\u00a0 \u00a0 }\n}<\/code><\/pre>\n
In de bovenstaande code hebben we een variabele countableIterator<\/strong> gedefinieerd als intersection van twee types: Traversable<\/strong> en Countable<\/strong>. In dit geval zijn de twee gedeclareerde types interfaces.<\/p>\n
Intersection types voldoen ook aan de standaard PHP regels met betrekking tot variance die al worden gebruikt voor type checking en inheritance. Maar er zijn twee aanvullende regels met betrekking tot de interactie tussen intersection types en subtyping. Je kan in de RFC meer lezen over de variance regels rond intersection types<\/a>.<\/p>\n
In sommige programmeertalen kan je Union Types en Intersection Types combineren in dezelfde declaration. Maar PHP 8.1 verbiedt dit. Daarom wordt de implementatie ervan “pure” intersection types genoemd. De RFC vermeldt echter wel dat dit iets is waar ze in de toekomst nog naar willen kijken.<\/p>\n
Enums<\/h3>\n
PHP 8.1 voegt eindelijk ondersteuning toe voor enums (ook wel enumerations of enumerated types genoemd). Ze zijn een user-defined data type dat bestaat uit een reeks mogelijke waarden.<\/p>\n
De meest voorkomende voorbeelden van enums in programmeertalen is het boolean<\/strong> type met true<\/code> en false<\/code> als twee mogelijke waarden. Het is inmiddels zo gewoon dat het in veel moderne programmeertalen<\/a> is ingebakken.<\/p>\n
Volgens de RFC<\/a> zijn enums in PHP in eerste instantie beperkt tot unit enumerations:<\/p>\n
De scope van deze RFC is beperkt tot “unit enumerations”, dat wil zeggen enums die zelf een waarde zijn, in plaats van eenvoudigweg een fancy syntax voor een primitive constant, en die geen aanvullende bijbehorende informatie bevatten. Deze mogelijkheid biedt sterk uitgebreide ondersteuning voor gegevensmodellering, custom type definitions en monad-style behavior. Enums maken de modelleringstechniek mogelijk van “ongeldige toestanden onrepresenteerbaar maken”, wat leidt tot robuustere code met minder noodzaak aan veel testen.<\/em><\/p><\/blockquote>\n
Het PHP team heeft veel talen bestudeerd die al enumerations ondersteunen. Uit hun onderzoek<\/a> bleek dat je enums in drie algemene groepen kunt indelen: Fancy Constants, Fancy Objects en volledige Algebraic Data Types (ADT’s). Het is interessant om te lezen!<\/p>\n
PHP implementeert “Fancy Objects” enums, met plannen om het in de toekomst uit te breiden naar volledige ADT’s. Het is conceptueel en semantisch gemodelleerd naar de enumerated types in Swift, Rust en Kotlin, hoewel het niet direct op een van hen is gemodelleerd.<\/p>\n
De RFC gebruikt de welbekende analogie van kleuren in een pak kaarten om uit te leggen hoe het zal werken:<\/p>\n
enum Suit {\n\u00a0 case Hearts;\n\u00a0 case Diamonds;\n\u00a0 case Clubs;\n\u00a0 case Spades;\n}<\/code><\/pre>\n
Hier definieert de enum Suit<\/strong> vier mogelijke waarden: Hearts<\/strong>, Diamonds<\/strong>, Clubs<\/strong> en Spades<\/strong>. Je kan deze waarden rechtstreeks benaderen met behulp van de syntax: Suit::Hearts<\/code>, Suit::Diamonds<\/code>, Suit::Clubs<\/code> en Suit::Spades<\/code>.<\/p>\n
Dit gebruik lijkt misschien bekend, omdat enums bovenop classes en objects worden gebouwd. Ze gedragen op dezelfde manier en hebben bijna dezelfde vereisten. Enums delen dezelfde namespaces als classes, interfaces en traits.<\/p>\n
De hierboven genoemde enums worden Pure Enums<\/strong> genoemd.<\/p>\n
Je kan ook Backed Enums<\/strong> defini\u00ebren als je aan alle gevallen een scalar equivalent value wil geven aan cases. Backed enums kunnen echter maar \u00e9\u00e9n type hebben, ofwel int<\/code> of string<\/code> (nooit beide).<\/p>\n
enum Suit: string {\n\u00a0 case Hearts = 'H';\n\u00a0 case Diamonds = 'D';\n\u00a0 case Clubs = 'C';\n\u00a0 case Spades = 'S';\n}<\/code><\/pre>\n
Bovendien moeten alle verschillende cases van een backed enum een unieke waarde hebben. En je kan nooit pure en backed enums mengen.<\/p>\n
De RFC gaat dieper in op enum methods, static methods, constants, constant expressions en nog veel meer. Het valt buiten de scope van dit artikel om ze allemaal te behandelen. Je kan de documentatie raadplegen om vertrouwd te raken met alles wat ermee te maken heeft.<\/p>\n
Het never<\/code> return type<\/h3>\n
PHP 8.1 voegt een nieuwe return type hint toe met de naam never<\/code>. Deze is superhandig te gebruiken in functions die altijd throw<\/code> of exit<\/code> hebben.<\/p>\n
Volgens de RFC<\/a> zijn URL redirect functions die altijd exit<\/code> (expliciet of impliciet) teruggeven, een goed voorbeeld van het gebruik ervan.<\/p>\n
function redirect(string $uri): never {\n\u00a0 \u00a0 header('Location: ' . $uri);\n\u00a0 \u00a0 exit();\n}\n \nfunction redirectToLoginPage(): never {\n\u00a0 \u00a0 redirect('\/login');\n}<\/code><\/pre>\n
Een met never<\/code> gedeclareerde function moet aan de volgende drie voorwaarden voldoen:<\/p>\n