O Que Há de Novo no PHP 8.4 e 8.5?

A linguagem evoluiu bastante nos últimos anos e conta com um conjunto considerável de funcionalidades. Conhecê-las te dá vantagem competitiva como profissional e te habilita a alcançar maior produtividade em novos projetos. Fique por dentro de funcionalidades como visibilidade assimétrica, new sem parênteses, atributo Deprecated, property hooks, funções de array, pipe operator e aplicação parcial.

Transcript

1. Marcel Gonçalves dos Santos @marcelgsantos O que há de novo no php 8.4 e 8.5 ?
2. pensandonaweb.com.br tech lead e engenheiro de software Marcel Gonçalves dos Santos @marcelgsantos
3. @phpsp phpsp.org.br
4. Interaja nas mídias sociais! - fale sobre o evento, palestrantes e conteúdo - tire fotos do evento e publique - interaja com outros participantes do evento - tire dúvidas ou dê feedbacks para os palestrantes - utilize as hashtags #php e #ingaphp
5. O Início!
6. O PHP existe há quase 30 anos e passou por várias "revoluções".
7. Na versão 5.3 o PHP incluiu o suporte para namespaces, funções lambda e closures.
8. A criação do PHP-FIG permitiu a de fi nição de padrões pela comunidade.
9. O Composer causou uma transformação na forma como bibliotecas são distribuídas e como aplicações PHP são desenvolvidas.
10. Na versão 7.0 fi cou de 2 a 3 vezes mais rápido e inúmeras funcionalidades foram adicionadas ao core da linguagem.
11. Na versão 7.4 foram introduzidas funcionali- dades muito solicitadas como propriedades tipadas, arrow functions e spread operator.
12. A criação da PHP Foundation foi criada para garantir o desenvolvimento sustentável da linguagem PHP.
13. O PHP como plataforma encontra-se mais maduro e robusto.
14. PHP F ou ndati o , PHP-FIG, C om pos e , L ar avel, Symf on y, Laminas, Slim, CakePHP , CodeIgnit e , Pr oo ph, Doc tr ine, Guzzle, Respect, PHP League, M on ol og, PHP-DI, FastR ou te, Psl, PHP-DS, Symf on y C om p on ents, Ramsey Uuid, Email Validat o , C ar b on , Flysystem, CLImate, Psysh, Twig, Fak e , Int er venti on Image, Ass er t, Magento, W or dPress, Sylius, OpenC ar t, W oo C om m er ce, PhpSt or m, Sw oo le, ReactPHP , Amp, Rev ol t PHP , Hyp er f, Octane, Bref, Vap o , XDebug, phpdbg, PHPStan, Psalm, Phan, PHPUnit, Codecepti on , Pest, Infecti on PHP , Mock er y, Behat, PHP CodeSniff e , PHP CS F ixer , PHPMD, PHPCPD, GrumPHP , CaptainH oo k, Dep tr ac, Rect o
15. Mas sempre existe espaço para melhorar!
16. A última grande novidade do PHP é o lançamento da versão 8.5, uma release com muitas novidades.
17. Mas vamos revisar as principais novidades das últimas versões! 😜.
18. Visibilidade Assimétrica
19. Na orientação a objetos, é possível controlar a visibilidade de propriedades e comportamentos de objetos.
20. O controle é feito de forma simétrica.
21. Isto é, ao declarar a visibilidade como private, ela será privada tanto para a leitura quanto para a escrita.
22. / / não é possível acessar uma propriedade privada / / de fora do objeto class User { public function _ _ construct( private string $email, ) {} } $user = new User(email: 'johndoe@example.com'); echo $user - > email; / / PHP Fatal error: Uncaught Error: Cannot access / / private property User : : $email
23. A funcionalidade de visibilidade assimétrica permite controlar a visibilidade de uma propriedade de forma independente.
24. Isto é, é possível tornar a leitura pública e escrita privada, por exemplo.
25. / / def i ne propriedade com leitura pública e escrita privada class User { public function _ _ construct( public private(set) string $email, ) {} public function setEmail(string $email) : void { if (! f i lter_var($email, FILTER_VALIDATE_EMAIL)) { throw new InvalidArgumentException('invalid email'); } $this - > email = $email; } }
26. / / propriedade com leitura pública $user = new User(email: 'johndoe@example.com'); echo $user - > email . PHP_EOL; / / johndoe@example.com / / propriedade com escrita privada $user - > email = 'alice@example.com'; / / Fatal error: Uncaught Error: Cannot modify / / private(set) property User : : $email from global scope
27. Pode-se combinar a funcionalidade de visibilidade de propriedades assimétricas junto com a promoção de propriedades no construtor.
28. / / propriedade com visibilidade assimétrica usando / / promoção de propriedades no construtor class User { public function _ _ construct( private(set) string $name, private(set) string $email, private(set) DateTimeImmutable $dob, ) {} } $user = new User( name: 'John Doe', email: 'johndoe@example.com', dob: new DateTimeImmutable('2000-01-01') ); echo $user - > email . PHP_EOL; / / johndoe@example.com
29. New Sem Parênteses
30. A funcionalidade de acesso aos membros de uma classe durante a instanciação foi introduzida na versão 5.4.
31. Para isso, a instanciação deveria envolvida por parênteses como em (new Request())- >withMethod(...).
32. class Request { const string VERSION = '2.0'; public function _ _ construct( private(set) ?string $method = null, private(set) ?string $uri = null, ) {} public function withMethod(string $method) : Request { $this - > method = $method; return $this; } public function withUri(string $uri) : Request { $this - > uri = $uri; return $this; } public function _ _ toString() : string { return $this - > method . ' ' . $this - > uri; } }
33. $request1 = new Request('GET', 'http: / / apple.com'); echo 'Request 1 : ' . $request1 . PHP_EOL; / / Request 1 : GET http: / / apple.com
34. / / acessa membros da classe durante a / / instanciação com parênteses $request2 = (new Request()) - > withMethod('GET') - > withUri('http: / / google.com'); echo 'Request 2 : ' . $request2 . PHP_EOL; / / Request 2 : GET http: / / google.com
35. Agora é possível acessar os membros de uma classe durante a instanciação agora sem parênteses.
36. / / acessa membros da classe durante a / / instanciação sem parênteses $request3 = new Request() - > withMethod('GET') - > withUri('http: / / amazon.com'); echo 'Request 3 : ' . $request3 . PHP_EOL; / / Request 3 : GET http: / / amazon.com
37. Isso funciona para todos os membros como: constantes, propriedades e métodos estáticos, propriedades e métodos.
38. / / acessa membros da classe (constante) / / durante a instanciação sem parênteses echo 'Request 4 (version) : ' . new Request() : : VERSION . PHP_EOL; / / Request 4 (version) : 2.0
39. / / acessa membros da classe (propriedade) / / durante a instanciação sem parênteses echo 'Request 5 (uri) : ' . new Request(uri: 'http: / / spotify.com') - > uri . PHP_EOL; / / Request 5 (uri) : http: / / spotify.com
40. Atributo Deprecated
41. No PHP só era possível que funções e constantes de classes internas fossem marcadas como obsoletas ou deprecated.
42. Não existia uma forma o fi cial de fazer o mesmo em userland, isto é, no lado do usuário.
43. Isso era contornado através do uso da annotation @deprecated ou de um atributo personalizado.
44. Mas a linguagem ainda carecia de uma solução o fi cial.
45. Na versão 8.4 foi introduzido o novo atributo #[Deprecated].
46. / / função não obsoleta function non_deprecated_function() { echo "eu sou uma função não obsoleta\n"; } non_deprecated_function(); / / eu sou uma função não obsoleta
47. / / função obsoleta # [ \Deprecated] function deprecated_function() { echo "eu sou uma função obsoleta\n"; } deprecated_function(); / / Deprecated: Function deprecated_function() is deprecated in line 3 / / eu sou uma função obsoleta
48. # [ \Deprecated("use non_deprecated_function()", since: "1.2")] function deprecated_function() { / / function implementation } / / Deprecated: Function deprecated_function() is deprecated / / since 1.2, use non_deprecated_function() in . . .
49. Ele pode ser aplicado a funções, métodos e constante de classe em userland.
50. O seu funcionamento é compatível com a funcionalidade existente para funções e constantes de classe internas.
51. Property Hooks
52. Os property hooks permitem adicionar comportamento ao acessar propriedades.
53. / / os hooks get e set são usados, respectivamente, / / para leitura e escrita class User { public string $email { get { / * expression * / } set ($value) { / * expression * / } } }
54. O hook de get pode ser usado com a sintaxe longa e curta.
55. / / o hook get usando sintaxe longa class User { public string $email { get { 'mailto:' . $this - > email; } } }
56. / / o hook get usando sintaxe reduzida class User { public string $email { get = > 'mailto:' . $this - > email; } }
57. O hook de set pode ser usado com implementação de regra de negócio.
58. / / o hook set com validação de regra de negócio class User { public string $email { get = > 'mailto:' . $this - > email; set (string $value) { if (! f i lter_var($value, FILTER_VALIDATE_EMAIL)) { throw new InvalidArgumentException('Invalid email'); } $this - > email = $value; } } }
59. Pode-se de fi nir uma propriedade virtual usando o hook de get.
60. / / def i ne uma propriedade virtual class User { public string $fullName { get = > $this - > f i rst . ' ' . $this - > last; } public function _ _ construct( private string $f i rst, private string $last, ) { } }
61. Funções array_ fi rst() e array_last()
62. No PHP 7.3 foram introduzidas as funções array_key_ fi rst() e array_key_last() para obter a primeira e a última chave de um array, respectivamente.
63. Contudo, não existiam funções nativas para obter o primeiro e o último valor de um array.
64. Essa é uma tarefa que pode ser um pouco desa fi adora por causa de algumas características da linguagem como:
65. 1. os índices podem ser não numéricos; 2. os índices numéricos podem não começar em zero ou serem sequenciais; 3. usar reset() e end() modi fi ca o ponteiro interno do array;
66. No PHP 8.5 foram introduzidas as funções array_ fi rst() e array_last() para obter o primeiro e o último valor de um array.
67. A função array_ fi rst() equivale a $array[array_key_ fi rst($array)].
68. A função array_last() equivale a $array[array_key_last($array)].
69. Pode-se obter os valores iniciais e fi nais utilizando um loop do tipo foreach.
70. Se existir alguma implementação das funções em userland, deve-se adicionar cláusulas de guarda com function_exists() para evitar rede fi nições.
71. A implementação nativa traz alguns benefícios como...
72. 1. mantém consistência com a API já existente; 2. o custo de implementação baixo para o core team da linguagem; 3. o desempenho superior a implementações em userland;
73. / / obtém o primeiro elemento de um array / / com índices não sequenciais $array = [2 = > 'a', 4 = > 'b', 6 = > 'c']; $f i rst = array_f i rst($array); $last = array_last($array); var_dump($f i rst); / / string(1) "a" var_dump($last); / / string(1) "c"
74. / / obtém o primeiro elemento de um array / / com índices como string $array = ['x' = > 10, 'y' = > 20, 'z' = > 30]; $f i rst = array_f i rst($array); $last = array_last($array); var_dump($f i rst); / / int(10) var_dump($last); / / int(30)
75. / / obtém o primeiro elemento de um array vazio $array = []; $f i rst = array_f i rst($array); $last = array_last($array); var_dump($f i rst); / / NULL var_dump($last); / / NULL
76. / / obtém o primeiro elemento de uma array com índices / / mistos e valores nulos $array = [3 = > null, 'a' = > 'apple', 5 = > 'banana']; $f i rst = array_f i rst($array); $last = array_last($array); var_dump($f i rst); / / NULL var_dump($last); / / string(6) "banana"
77. Pipe Operator
78. A composição de funções na programação funcional consiste em encadear duas funções de ponta a ponta para criar uma nova função.
79. A composição de funções pode ser imediata ou atrasada.
80. A execução imediata de funções encadeadas é implementada através do operador pipe.
81. A execução atrasada é implementada através de um operador de composição que recebe duas funções e produz uma nova funções que chamará cada uma por vez.
82. A combinação das duas funcionalidades permite permite usar o estilo point-free, uma abordagem de programação que limita o uso de variáveis intermediárias desnecessárias.
83. Existe já uma RFC que trata do operador de composição de funções no PHP.
84. / / obtém a soma dos produtos do carrinho usando o operador pipe $cart = [ ['id' = > 1, 'product' = > 'iPhone', 'price' = > 499], ['id' = > 2, 'product' = > 'Kindle', 'price' = > 179], ['id' = > 3, 'product' = > 'MacBook Pro', 'price' = > 1199], ]; $total = $cart | > (fn ($list) = > array_column($list, 'price')) | > array_sum( . . . ); var_dump($total); / / 1877
85. O operador pipe é avaliado da esquerda para a direita.
86. O valor à esquerda é passado para o callable à direita como primeiro único parâmetro.
87. / / os códigos a seguir são equivalentes $result = "Hello World" | > strlen( . . . ); $result2 = strlen("Hello World"); var_dump($result = = = $result2); / / true
88. O pipe operator é bastante útil quando existe a necessidade de encadear múltiplas chamadas à funções.
89. / / encadeamento de múltiplas chamadas à funções $raw = " John Doe "; $username = $raw | > trim( . . . ) | > strtolower( . . . ) | > (fn ($value) = > preg_replace('/\s + /', '-', $value)); $temp = trim($raw); $temp = strtolower($temp); $temp = preg_replace('/\s + /', '-', $temp); $username2 = $temp; var_dump($username); / / john - doe var_dump($username = = = $username2); / / true
90. O código do lado direito do operador pipe deve ser um callable que aceita um único valor ou uma expressão que avalia.
91. / / erro ao encadear valor para um callable que recebe / / mais de um parâmetro $numbers = [1, 2, 3, 4, 5]; $total = $numbers | > array_map( . . . ); / / Fatal error: Uncaught ArgumentCountError: array_map() / / expects at least 2 arguments, 1 given $total = $numbers | > (fn ($x, $y) = > $x + $y); / / Fatal error: Uncaught ArgumentCountError: Too few arguments / / to function {closure:/app/01-pipe - operator.php:74}(), 1 passed
92. O operador pipe suporta qualquer tipo de callable suportado pelo PHP.
93. É possível lidar com manipulação de strings, arrays, coleções entre outros.
94. Aplicação Parcial
95. A aplicação parcial é o processo de chamar uma função com apenas alguns de seus parâmetros obrigatórios...
96. ...deixando os demais para serem fornecidos posteriormente.
97. function add4(int $a, int $b, int $c, int $d) : int { return $a + $b + $c + $d; } $fn = add4(1, ?, 3, 4); / / $fn = static fn(int $b) : int = > add4(1, $b, 3, 4); echo $fn(2); / / 1 + 2 + 3 + 4 = 10
98. / / encadeamento de múltiplas chamadas à funções $raw = " John Doe "; / / sem aplicação parcial $username = $raw | > trim( . . . ) | > strtolower( . . . ) | > (fn ($value) = > preg_replace('/\s + /', '-', $value)); / / com aplicação parcial $username = $raw | > trim( . . . ) | > strtolower( . . . ) | > preg_replace('/\s + /', '-', ?);
99. Conclusão
100. O PHP tem tido uma enorme evolução e tem se tornado uma linguagem mais robusta.
101. Porém, sem perder a fl exibilidade e a pequena curva de aprendizado que o torna uma linguagem tão democrática.
102. As novas funcionalidades ajudarão o código a ter mais garantias, ser mais expressivo e te dar mais poderes.
103. Vá em frente e divirta-se!
104. Avalie!
105. @marcelgsantos speakerdeck.com/marcelgsantos Obrigado. Perguntas?