Nuttige (nieuwe) PHP features

[pjdevries]

Algemeen

• Type declarations
• Generators
• Traits

Per PHP versie

• 5.6
  • const
  • ... for variadic function parameters and array unpacking.
  • ** Exponentation operator
• 7.0
  • Function return type declarations: string, ìnt, float, bool, array (type ...$types).
  • Function parameter type declarations: string, ìnt, float, bool, array.
  • Null coalescing operator: ??
  • Spaceship operator: <=>
  • Constant arrays: define('FOO] , [1, 2, 3])
  • Anonymous classes: new class [implements Interface] {}
  • Group use declarations: use some\namespace\{ClassA, ClassB, ClassC as C};
  • preg_replace_callback_array()
• 7.1
  • Nullable function parameter and return types: function d(?int $foo): ?string.
  • Void functions: function f(): void
  • Array destructuring (list() shorthand): [$foo, $bar] = [1, 2]
  • Scoped class constants.
  • Iterable pseudo-type: function f(iterable $i)
  • Multi catch exception handling: catch (Exception1 | Exception2 | .... $e)
  • Keys in list() and array destructuring: ['foo' => $item1, 'bar' => $item2] = ['foo' => 1, 'bar' => 2]
• 7.2
  • New object type: object
  • PDO prepared statement debugging: PDOStatement::debugDumpParams()
• 7.3
  • More flexible Heredoc and Nowdoc.
• 7.4
  • Typed class properties.
  • Arrow functions.
  • Limited return type covariance and argument type contravariance.
  • Null coalescing assignment operator: ??=
  • Unpacking inside arrays: [1, 2, ...[3, 4], 5]
• 8.0
  • Named arguments
  • Support fort Attributes
  • Constructor property promotion
  • Union types: function f(Foo|Bar $param)
  • Match expressions: match(expression) {...}
  • Null safe operator: ?->
  • Support for mixed type: mixed
  • get_class($object) shorthand: $object::class
  • str_contains(), str_starts_with(), str_ends_with()
• 8.1
  • Array Unpacking with String Keys: [1, 2, [...['foo' => 3, 'bar' => 4], 5]
  • Enumerations
  • First Class Callable Syntax: $fn = callable(...)
  • Intersection types: function f(Foo&Bar $param)
  • Never return type: function f(): never { exit; }
  • new in Initializers: default value of a parameter, static variable, global constant initializers, and as attribute arguments.
  • Readonly properties
  • Final class constants: final public const foo = "bar";
• 8.2
  • SensitiveParameter Attribute: #[\SensitiveParameter]
  • Stand alone types null, false and true.
  • Intersection and union types can be combined.
  • Readonly classes.

[pjdevries]

@HermanPeeren en @roland-d Wat vinden jullie van bovenstaande lijst? Te veel, te weinig, precies genoeg, beetje overdreven, tot nu toe door niemand om gevraagd, ...? (Hoe) gaan we die verdelen?

[roland-d]

@pjdevries Ik vind het een veel te lange lijst. Zeker een interessante lijst maar ik denk dat het behalve ons 3 voor de meeste boven de pet is. Mijn idee zou zijn om de lijst te consolideren tot meer/veel gebruikte/nuttige opties, om wat voorbeelden uit de lijst te pakken:

• null coalescing operator
• const
• function return type declaration
• anonymous classes
• named arguments
• match expression
• null safe operator
• Nullable function parameter and return types
• Null coalescing assignment operator
• Support for mixed type

Ik mis nog wat nieuwe functies zoals de str_contains

My 2 cents

[pjdevries]

@roland-d Ja hij is lang en mijn bedoeling was niet de hele lijst af te werken, tenzij daar behoefte aan is. Als @HermanPeeren ook zijn blik er over laat gaan en suggesties doet, dan stellen we een definitieve lijst op die we onderling verdelen.

[pjdevries]

@roland-d Ik heb str_contains(), str_starts_with() en str_ends_with() onder 8.0 toegevoegd.

[pjdevries]

@HermanPeeren, @roland-d Wat doen we hiermee?

[roland-d]

Als @HermanPeeren ook zijn blik er over laat gaan en suggesties doet, dan stellen we een definitieve lijst op die we onderling verdelen.

De definitieve lijst opstellen?

[pjdevries]

@roland-d Jij vond de lijst aan de lange kant. Een definitieve zou dan korter moeten zijn, toch?

[roland-d]

@pjdevries Ik heb toch een kortere lijst doorgegeven?

[pjdevries]

@roland-d Ik realiseerde me niet dat jij jouw kortere lijst als definitief had bestempeld. Vandaar de vraag aan @HermanPeeren er ook zijn blik over te laten gaan.

Zeker een interessante lijst maar ik denk dat het behalve ons 3 voor de meeste boven de pet is.

Ik vond dit ook wat kort door de bocht, want we zitten met wat slimme luitjes bij elkaar. Maar zelfs als je gelijk hebt, is dat niet juist waarvoor deze dag aanvankelijk was bedoeld?

De lijst die ik heb opgesteld, komt voort uit wat ik als nuttig ervaar of het bestaan ervan nuttig vind. Dat zou dus ook voor anderen het geval kunnen zijn. Misschien zelfs voor jou :grin: Maar dat de lijst voor het praktische misschien wat aan de lange kant is, ben ik met je eens. Vandaar de vraag of @HermanPeeren er ook eens naar wil kijken om tot een definitieve lijst te komen. Zelf mis ik er in jouw lijst er ook nog enkelen, waarvan ik denk dat ze heel nuttig kunnen zijn.

[HermanPeeren]

Ik zou niet van die losse punten willen behandelen, maar thematisch te werk gaan. Als ik een beetje uit de losse pols tel valt bijna 40% van de grote lijst van @pjdevries onder het thema "typing & scoping". Dat is denk ik ook het hoofdthema van veranderingen in de versies van PHP sinds 5.6. Ik stel dus voor dat we op de bijeenkomst een verhaal houden over typing & scoping en daar allerlei punten van de lijst in te gebruiken. In context wordt het duidelijk wat het belang van die features is. De strict_types-declaratie past ook in dit verhaal. Misschien een idee voor een leuk verhaal: proberen om foute voorbeelden te maken zonder gebruik van die features, die voorkomen kunnen worden door wel stricter te typeren of de scope te beperken (maar ja, is wel weer extra werk; ik weet voor mezelf niet of ik er tijd voor heb).

Andere thema's zouden kunnen zijn:

• toekomstbestendig (in 8.2 creation of dynamic properties is deprecated => hoe nu wel te doen)
• geheugen en grote bestanden (generators)
• modulaire opbouw, cross-cutting concerns & traits (zoals gebruikt in Joomla: i.c.m. een interface) - hier hebben we dan ook een bruggetje naar Dependency Injection.

En een onderwerp dat ik leuk vind: composability met anonymous functions, closures & arrow-functions.

Ik denk dat allerlei losse features zonder context (thema) een beetje verloren gaan. Of misschien kunnen in 1 rest-onderwerp "moet je kijken wat handig dit is" toch nog even allerlei losse handigheidjes of syntactic sugar behandeld worden. Dan wel liefst met een voorbeeldje van code zonder die feature en met.

[pjdevries]

Thematisch groeperen vind ik op zich een goed idee, al wil ik de relatie met de PHP versie wel behouden. Maar zoals je zelf al opmerkt, zoiets bruikbaar voorbereiden kost extra tijd en dat is niet iets waar we allemaal veel van over hebben. Ik zou het ook een uitdaging vinden.

[HermanPeeren]

Ik zei niet dat het bruikbaar voorbereiden extra tijd kost, maar het maken van foute voorbeelden en laten zien hoe stricter typing en scoping die fouten kan voorkomen. "Bruikbaar voorbereiden" kost wel tijd, maar is altijd nodig (anders is het niet bruikbaar/nuttig), dus geen extra tijd.

Ik had op jouw lijst even voor mezelf aangemerkt wat (enigszins) met typing en scoping te maken had en als je die onderwerpen samenpakt, dan komt er al bijna vanzelf een "verhaaltje" uit, een samenhang tussen die verschillende punten.

[HermanPeeren]

Mijn voorstel is om eerst van die typing & scoping features (en er enigszins mee samenhangende dingen, die aan dat thema opgehangen kunnen worden) een geheel te maken en de rest even te laten zitten. Dan over een paar weken weer eens kijken hoe dat ervoor staat en wat we van de rest nog oppakken. Beter 1 onderwerp wat grondiger uitdiepen dan alles half doen.

Misschien een taakverdeling voor dat uitwerken, zodat we er met meerderen aan kunnen werken? Waarbij opgemerkt, dat ik t/m 15 november erg weinig tijd heb (maar kan altijd mijn gedachten alvast over een deelonderwerp laten gaan). Mogelijke deeltaken bij dat ene thema:

• belang van typing & scoping in het algemeen
• als je de features op dat gebied per PHP-versie op een rijtje zet, dan zie je daar een progressie in
• foute voorbeelden verzinnen; misschien de features binnen dit thema verdelen tussen ons drieën Nog andere taakverdelingen?

Dit is maar een voorstel, hoor. Hoe ik het aan zou pakken. Als je liever toch een keuze uit je lijst wil maken en die punten uit wil werken, dan moet je dat zeker doen! :-) Ik beperk me voorlopig alleen tot typing & scoping (maar zoals ik al zei, dekt dat ongeveer 40% van je lijst).

[pjdevries]

Ik ga mijn best doen de lijst opnieuw te organiseren naar thema. Daarna zien we wel verder.

@roland-d Wat vind jij van @HermanPeeren's idee?

[HermanPeeren]

Zoiets qua thema Typing & Scoping:

Algemeen

• Type declarations

Per PHP versie

• 5.6
  • const
• 7.0
  • Function return type declarations: string, ìnt, float, bool, array (type ...$types).
  • Function parameter type declarations: string, ìnt, float, bool, array.
• 7.1
  • Nullable function parameter and return types: function d(?int $foo): ?string.
  • Void functions: function f(): void
  • Scoped class constants.
• 7.4
  • Type class proeprties.
  • Limited return type covariance and argument type contravariance.
• 8.0
  • Named arguments
  • Union types: function f(Foo|Bar $param)
  • Support for mixed type: mixed
• 8.1
  • Enumerations
  • First Class Callable Syntax: $fn = callable(...)
  • Intersection types: function f(Foo&Bar $param)
  • Never return type: function f(): never { exit; }
  • Readonly properties
  • Final class constants: final public const foo = "bar";
• 8.2
  • Stand alone types null, false and true.
  • Intersection and union types can be combined.
  • Readonly classes.

[roland-d]

Het idee van het groeperen op thema vind ik een prima idee. Ook de groep die Herman noemt typing & scoping vind ik een goede. Het is denk ik ook een groep waarmee je de hele dag wel kan vullen als je het over niets anders wil hebben :) De lijst hierboven lijkt mij prima. Ook ik weet ze niet allemaal uit het blote hoofd als ik de lijst zie :/

Toch wil ik het thema new functions niet laten vallen. Dat zal een aanzienlijk kortere lijst zijn.

[HermanPeeren]

Ik heb Enums ook bij de types gezet en (ook van 8.1) First Class Callable syntax.

Ik heb die Null-safe operator even weggehaald uit die typing-list en dacht aan een aparte rubriek null-handling, met de volgende items van @pjdevries z'n lijst:

Per PHP versie

• 7.0
  • Null coalescing operator: ??
• 7.1
  • Nullable function parameter and return types: function d(?int $foo): ?string. (staat ook bij typing)
• 7.4
  • Null coalescing assignment operator: ??=
• 8.0
  • Null safe operator: ?->
  • Support for mixed type: mixed (staat ook bij typing)

Maybe (pun intended) met een klein uitstapje naar functional programming (in PHP uiteraard) met een Optional type/object/function. Maar waarschijnlijk zijn jullie het daar niet mee eens, want dan dwalen we wat te veel af... voor een andere keer dan. Zie https://auxiliaire.medium.com/perhaps-functional-programming-in-php-part-5-163f88c811cf . Zie ook Scott Wlaschin's artikel over "Railway Oriented programming" https://fsharpforfunandprofit.com/rop/

[HermanPeeren]

Misschien zijn de new functions vooral new text-processing functions. Uit PJ's lijst:

• 7.0
  • preg_replace_callback_array()
• 8.0
  • str_contains(), str_starts_with(), str_ends_with()

Maar wellicht zijn er meer.

[pjdevries]

Hangt er een beetje vanaf wat je onder nieuw verstaat :grin:

[HermanPeeren]

Ik zoek vooral naar het embedden van losse functies in een context. In dit geval: tekst manipulatie. Wat wil je bereiken en hoe krijg je dat voor elkaar (kookboek-recepten).

Soms volstaan eeuwenoude ingrediënten in een recept, soms is iets nieuwsers handiger.

[pjdevries]

Ik heb Enums ook bij de types gezet en (ook van 8.1) First Class Callable syntax.

Vanwaar de keuze om de First Class Callable syntax bij de Types & Scoping onder te brengen?

[pjdevries]

In navolging van @HermanPeeren's aangepaste lijst, heb ik de vrijheid genomen de gehele lijst vergelijkbaar te herorganiseren. Ik heb echter moeite om de lijst in te delen op conceptuele topics, zoals die @HermanPeeren opsomt: toekomstbestendig, geheugen en grote bestanden, modulaire opbouw, cross-cutting concerns, etc. Niet alleen vergt dat veel meer tijd en aandacht om voor te bereiden, maar ik denk dat het ook veel extra tijd in de besprekning tot gevolg heeft. Uiteraard staat het ons allemaal vrij om interessante voorbeelden binnen zo'n conceptuele context te maken. De lijst is dus vooral PHP topic specifiek gegroepeerd.

Ik ben ook zo eigenwijs geweest om First Class Callable Syntax niet onder typing & scoping onder te brengen. Het lukt me niet dat te beredeneren en @HermanPeeren heeft nog niet toeglicht waarom hij het daar heeft ondergebracht.

Als laatste heb ik, met het oog op de release in november, ook wat nieuwe PHP 8.3 features aan de lijst toegevoegd.

---

Topics

• Algemeen
• Typing & Scoping
• NULL handling
• New operators
• Array handling
• New functions
• Classes & Functions
• Attributes
• Other stuff

Algemeen

• Abstract classes & Interfaces
• Generators
• Traits

Typing & Scoping

• 5.6
  • const
• 7.0
  • Function return type declarations: string, ìnt, float, bool, array (type ...$types)
  • Function parameter type declarations: string, ìnt, float, bool, array
  • Constant arrays: define('FOO] , [1, 2, 3])
• 7.1
  • Nullable function parameter and return types: function d(?int $foo): ?string
  • Scoped class constants
  • Void functions: function f(): void
  • Iterable pseudo-type: function f(iterable $i)
• 7.2
  • New object type: object
• 7.4
  • Typed class properties
  • Limited return type covariance and argument type contravariance
• 8.0
  • Named arguments
  • Union types: function f(Foo|Bar $param)
  • Support for mixed type: mixed
• 8.1
  • Intersection types: function f(Foo&Bar $param)
  • Enumerations
  • Never return type: function f(): never { exit; }
  • Readonly properties
  • Final class constants: final public const foo = "bar";
• 8.2
  • Stand-alone types null, false and true
  • Intersection and union types can be combined
  • Readonly classes
• 8.3
  • Anonymous classes may now be marked as readonly.
  • Readonly properties can now be reinitialized during cloning.
  • Class, interface, trait, and enum constants now support type declarations.

NULL handling

• 7.0
  • Null coalescing operator: ??
• 7.1
  • Nullable function parameter and return types: function d(?int $foo): ?string
• 7.4
  • Null coalescing assignment operator: ??=
• 8.0
  • Null safe operator: ?->
  • Support for mixed type: mixed

New operators

• 5.6
  • ... for variadic function parameters and array unpacking.
  • ** Exponentation operator
• 7.0
  • Spaceship operator: <=>

Array handling

• 7.1
  • Array destructuring (list() shorthand): [$foo, $bar] = [1, 2]
  • Keys in list() and array destructuring: ['foo' => $item1, 'bar' => $item2] = ['foo' => 1, 'bar' => 2]
• 7.4
  • Unpacking inside arrays: [1, 2, ...[3, 4], 5]
• 8.1
  • Array Unpacking with String Keys: [1, 2, [...['foo' => 3, 'bar' => 4], 5]

String handling

• 7.0
  • preg_replace_callback_array()
• 7.3
  • More flexible Heredoc and Nowdoc.
• 8.0
  • str_contains()
  • str_starts_with()
  • str_ends_with()
• 8.3
  • mb_str_pad()

Classes & Functions

• 7.0
  • Anonymous classes: new class [implements Interface] {}
• 7.4
  • Arrow functions.
• 8.0
  • Constructor property promotion
  • get_class($object) shorthand: $object::class
• 8.1
  • First Class Callable Syntax: $fn = callable(...)
  • new in Initializers: default value of a parameter, static variable, global constant initializers, and as attribute arguments.
• 8.3
  • Anonymous classes may now be marked as readonly.
  • Static variable initializers can now contain arbitrary expressions.

Attributes

• 8.0
  • Support fort Attributes
• 8.2
  • #[\SensitiveParameter]
  • #[\AllowDynamicProperties]
• 8.3
  • #[\Override]

Other stuff

• 7.0
  • Group use declarations: use some\namespace\{ClassA, ClassB, ClassC as C};
• 7.1
  • Multi catch exception handling: catch (Exception1 | Exception2 | .... $e)
• 7.2
  • PDO prepared statement debugging: PDOStatement::debugDumpParams()
• 8.0
  • Match expressions: match(expression) {...}
• 8.3
  • Class constants can now be accessed dynamically using the C::{$name} syntax.

PHP new features

• 5.6
• 7.0
• 7.1
• 7.2
• 7.3
• 7.4
• 8.0
  • https://stitcher.io/blog/new-in-php-8
• 8.1
  • https://stitcher.io/blog/new-in-php-81
• 8.2
  • https://stitcher.io/blog/new-in-php-82
• 8.3
  • https://stitcher.io/blog/new-in-php-83

[pjdevries]

@roland-d, @HermanPeeren Ik stel voor dat we een definitieve onderverdeling maken, wie welke topics uit de lijst oppakt. Laten we daarbij en bij de voorbereiding niet uit het oog verliezen dat we beperkte tijd hebben en dus efficient moeten zijn. Dit is immers slechts één van de 13 issues die voor de komende meetup op de lijst staan om behandeld te worden.

[pjdevries]

@roland-d, @HermanPeeren Ik heb het onderwerpenoverzicht onder de naam Topics.md in de repo gecommit.

[pjdevries]

@roland-d, @HermanPeeren Ook een eerste voorbeeld in de repo gezet. Alleen niet m.b.t. dit issue :grin:

[HermanPeeren]

@pjdevries schreef:

Ik ben ook zo eigenwijs geweest om First Class Callable Syntax niet onder typing & scoping onder te brengen. Het lukt me niet dat te beredeneren en @HermanPeeren heeft nog niet toeglicht waarom hij het daar heeft ondergebracht.

Zie ik nu pas 😅. Is natuurlijk prima, kan op verschillende manieren ingedeeld worden, is maar net wat je als kapstokje wil gebruiken. Ik was uitgegaan van: "CallableExpr(...) has the same semantics as Closure::fromCallable(). That is, unlike callable using strings and arrays, CallableExpr(...) respects the scope at the point where it is created".

Maar als je een aparte rubriek Classes & Functions hebt, dan kun je het ook daar onder brengen.