O Que Há de Novo no PHP 7.4?

O PHP tem evoluído constantemente nos últimos anos e hoje em dia conta com um robusto ecossistema de ferramentas e funcionalidades. E, em breve, será lançado o PHP 7.4. Ela será uma das releases com o maior número de funcionalidades. Nesta apresentação falaremos sobre typed properties, arrow functions, spread operators em arrays, operador de atribuição null coalescing, FFI, preloading, numeric literal separator entre outras funcionalidades. Assista esta palestra e fique por dentro de todas as novidades.

Transcript

1. Marcel Gonçalves dos Santos @marcelgsantos php 7.4 o que há de novo no ?
2. pensandonaweb.com.br desenvolvedor web full-stack Marcel Gonçalves dos Santos @marcelgsantos
4. @femugsp sp.femug.com
5. @phpsp phpsp.org.br
6. 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
7. 1. seguir @marcelgsantos no Twitter
 2. tuitar utilizando as hashtags #php74,
 #locawebphpsummit e #novatec
 3. não vale tuíte em branco e retuíte
 4. ler e preencher este simples formulário
 bit.ly/sorteio-phpcs-2019 Concorra a um workshop e um livro Novatec!
8. O início!
9. o PHP existe há mais de 20 anos e passou por várias "revoluções"
10. na versão 5.3 o PHP incluiu o suporte para namespaces, funções lambda e closures
11. a criação do PHP-FIG permitiu a definição de padrões pela comunidade
12. o Composer causou uma transformação na forma como bibliotecas são distribuídas e como aplicações PHP são desenvolvidas
13. na versão 7.0 ficou de 2 a 3 vezes mais rápido e inúmeras funcionalidades foram adicionadas ao core da linguagem
14. o PHP como plataforma encontra-se mais maduro e robusto
15. mas sempre existe espaço para melhorar!
16. a próxima grande novidade do PHP é o lançamento da versão 7.4, o maior release 
 desde a versão 7.0
17. Typed properties ou propriedades tipadas
18. as typed properties ou propriedades tipadas é uma das funcionalidades mais esperadas do PHP 7.4
19. o PHP teve uma enorme evolução no seu sistema de tipos com o passar do tempo
20. utilizavam-se docblocks e métodos getters e setters para a garantia de tipos
21. isso fazia com que, para ter essa garantia, houvesse um boilerplate desnecessário de código
22. !// code with unnecessary boilerplate to enforce type contracts class User { /** @var int $id !*/ private $id; /** @var string $name !*/ private $name; public function !__construct(int $id, string $name) { $this!->id = $id; $this!->name = $name; } public function getId(): int { return $this!->id; } !// setId, getName and setName implementation!!... }
23. !// more concise code with same type contracts class User { public int $id; public string $name; public function !__construct(int $id, string $name) { $this!->id = $id; $this!->name = $name; } }
24. as propriedades tipadas permitem a garantia de tipos em tempo de execução
25. !// properties typed with scalar, class and nullable class class User { public int $age; protected Address $address; private ?Passport $passport; }
26. !// types in static property and with var notation class Example { public static iterable $staticProp; var bool $flag; }
27. !// typed properties with default values class Example { public string $str = "foo"; public ?string $nullableStr = null; }
28. !// typed properties in one declaration class Point { public float $x, $y; !// more implementation… }
29. !// typed properties in one declaration class Point { public float $x; public float $y;
 
 !// more implementation… }
30. as declarações de tipos para propriedades suportam todos os tipos suportados pelo PHP com exceção de void e callable
31. a tipagem de propriedades, assim como a declaração de parâmetros e tipos de retorno, são afetadas pela diretiva strict_types
32. somente a presença de strict_types no local de escrita da propriedade é relevante
33. !// typed properties and strict types !// file1.php declare(strict_types=1); class Test { public int $val; } $test = new Test; $test!->val = "42"; !// Throws TypeError
34. !// typed properties and strict types !// file2.php declare(strict_types=0); $test = new Test; $test!->val = "42"; var_dump($test!->val); !// int(42)
35. se uma propriedade tipada não tiver um valor padrão ela será considerada não inicializada
36. !// uninitialized properties and 
 !// default null (until PHP 7.3) class User { public $id; public $name; } $user = new User; var_dump($user);
37. class User#1 (2) { public $id !=> NULL public $name !=> NULL }
38. !// uninitialized properties and 
 !// no null default (PHP 7.4) class User { public int $id; public ?string $name; } $user = new User; var_dump($user);
39. object(User)#1 (0) { ["id"]!=>uninitialized(int) ["name"]!=>uninitialized(?string) }
40. ao tentar fazer a leitura de uma propriedade não inicializada será lançado um erro do tipo TypeError
41. !// try to access a uninitialized property class User { public int $id; public string $name; } $user = new User; echo $user!->id; !// Uncaught Error: Typed property User!::$id must 
 !// not be accessed before initialization
42. as propriedades tipadas podem ser referenciadas
43. Arrow functions
44. as funções anônimas no PHP são bastante verbosas, principalmente quando vamos realizar uma operação simples
45. isso ocorre por causa do boilerplate sintático 
 e a necessidade de importar as variáveis que serão utilizadas no escopo interno da função
46. !// anonymous function (more verbose) $add = function ($x, $y) { return $x + $y; };
47. a funcionalidade de arrow functions do PHP 7.4 torna mais concisa a sintaxe para esse padrão
48. !// anonymous function (less verbose) $add = fn ($x, $y) !=> $x + $y;
49. a sintaxe de uma arrow function é a seguinte: fn(parameter_list) => expression
50. ao utilizar uma variável definida no escopo externo ela será passada de forma implícita para a expressão
51. !// variable in parent scope is captured-by-value
 $y = 1; $fn1 = fn($x) !=> $x + $y; $fn2 = function ($x) use ($y) { return $x + $y; };
52. esse comportamento funciona para
 funções aninhadas
53. !// variable in parent scope is captured-by-value 
 !// (nested functions)
 $z = 1; $fn = fn($x) !=> fn($y) !=> $x * $y + $z;
54. as arrow functions permitem diversas assinaturas de funções…
55. …incluindo tipos de parâmetros e retornos, valores padrão, variadics e passagem e retorno de valor por referência
56. !// different function signatures fn(array $x) !=> $x; fn(): int !=> $x; fn($x = 42) !=> $x; fn(&$x) !=> $x; fn&($x) !=> $x; fn($x, !!...$rest) !=> $rest;
57. as arrow function podem ser utilizadas inúmeros casos do dia-a-dia
58. !// arrow functions help reducing code boilerplate
 !// (without arrow functions) $result = Collection!::from([1, 2]) !->map(function ($v) { return $v * 2; }) !->reduce(function ($tmp, $v) { return $tmp + $v; }, 0); echo $result; !// 6
59. !// arrow functions help reducing code boilerplate !// (with arrow functions)
 $result = Collection!::from([1, 2]) !->map(fn($v) !=> $v * 2) !->reduce(fn($tmp, $v) !=> $tmp + $v, 0); echo $result; !// 6
60. Spread operator em arrays
61. o PHP possui o suporte ao argument unpacking desde a versão 5.6 da linguagem
62. a funcionalidade permite o "desempacota- mento" de um array (ou um Traversable) em uma lista de argumentos utilizando o spread operator
63. function sum($a, $b) { return $a + $b; } !// using spread operator (!!...) to unpacking !// an array as an argument list $numbers = [3, 5]; echo sum(!!...$numbers); !// 8
64. a utilização do spread operator não era permitido na definição de arrays a partir de outro array
65. !// using spread operator to define a new array !// from another is not supported $someNumbers = [2, 3, 4]; $numbers = [1, !!...$someNumbers, 5]; print_r($numbers);
 !// PHP Parse error: syntax error, unexpected '!!...'
 !// (T_ELLIPSIS), expecting ']'
66. a nova funcionalidade permite a utilização do spread operator (...) na definição de um array através do unpacking dos valores de outro array ou Traversable
67. !// using spread operator to define an array from another $someNames = ['Bob', 'Carol']; $names = ['Alice', !!...$someNames, 'Daniel', 'Elisa']; print_r($names); !// ['Alice', 'Bob', 'Carol', 'Daniel', 'Elisa'];
68. essa funcionalidade só está disponível para arrays com chaves numéricas (para manter consistência com o argument unpacking)
69. é possível realizar a expansão de arrays múltiplas vezes e pode-se desempacotar um array retornado por uma função
70. Operador de atribuição 
 null coalescing
71. sempre que precisávamos verificar se uma variável foi definida e é não-nula, utilizávamos o operador ternário (?:) junto com a função isset
72. !// check if a variable is defined and not null
 
 !// $data['name'] = 'John'; $name = isset($data['name']) ? $data['name'] : 'anonymous'; echo $name; !// anonymous
73. !// check if a variable is defined and not null
 
 $data['name'] = 'John'; $name = isset($data['name']) ? $data['name'] : 'anonymous'; echo $name; !// John
74. a utilização do operador null coalesce (??), disponível a partir do PHP 7.0, torna mais fácil lidar com esse problema
75. !// using null coalesce !?? operator !// $data['name'] = 'John'; $name = $data['name'] !?? 'anonymous'; echo $name; !// anonymous
76. !// using null coalesce !?? operator $data['name'] = 'John'; $name = $data['name'] !?? 'anonymous'; echo $name; !// John
77. o código fica mais claro e legível
78. em casos que desejamos verificar se uma variável foi definida e é não-nula e atribuir o valor a ela própria ou usar um valor padrão o código fica pouco legível
79. !// check if variable is defined and not null and assign itself
 !// (without using null coalesce assignment operator)
 $data['comments']['name'] = $data['comments']['name'] !?? 'anonymous';
80. no PHP 7.4 é possível utilizar o operador de atribuição null coalesce (??=) que permite alcançar o mesmo objetivo de uma forma mais expressiva
81. !// check if variable is defined and not null and assign itself
 !// (using null coalesce assignment operator) $data['comments']['name'] !??= 'anonymous';
82. Numeric literal
 separator
83. ei, você consegue identificar que número é esse?
84. 1000000000;
85. é um bilhão, 100 milhões ou 10 bilhões?
86. Difícil, né?!
87. o olho de um ser humano não é otimizado para olhar e decodificar rapidamente uma sequências de dígitos
88. e esse valor?
89. $discount = 13500;
90. é 13.500 ou 135 porque está em centavos?
91. a nova funcionalidade numeric literal separator permite usar um separador visual para ajudar a melhorar a legibilidade do código e transmitir informações adicionais
92. !// using numeric literal separator $threshold = 1_000_000_000; !// a billion $testValue = 10_925_284.88; !// scale is hundreds of millions $discount = 135_00; !// $135, stored as cents
93. adicionar o underscore entre dois dígitos não alterará o seu valor
94. !// adding undescore doesn't change the value var_dump(1_000_000); !// int(1000000)
95. FFI ou foreign
 function interface
96. a nova funcionalidade FFI ou foreign function interface é outra das mais esperadas para o PHP 7.4
97. ela permite que um código PHP execute um código escrito em outra linguagem (C, por exemplo) ou fazer algo que não é suportado
98. !// calls abs() function from libc.so using PHP $ffi = FFI!::cdef('int abs(int j);', 'libc.so.6'); var_dump($ffi!->abs(-42)); !// 42
99. assistam a palestra de encerramento do Gabriel Couto sobre FFI que ele preparou coisas fantásticas para mostrar para vocês!
100. Preloading
101. o preloading é outra funcionalidade muito esperada do PHP 7.4
102. para realizar o preload de arquivos deve-se escrever um script para isso
103. o script é executado somente uma vez no início do servidor
104. todos os arquivos pré-carregados estão disponíveis em memória para as requisições posteriores
105. depois de qualquer alteração nos arquivos pré-carregados deve-se reiniciar o servidor
106. Quando vou 
 poder utilizar?
107. o PHP 7.4 estará disponível a partir de novembro de 2019
108. porém, as versões RC ou release candidates podem ser utilizadas agora para testes
109. Como faço para
 utilizá-lo neste momento?
110. o PHP 7.4 pode ser utilizado de duas formas principais: compilando o código fonte ou utilizando uma imagem Docker
111. o processo de compilar o código fonte do PHP, apesar de ser um trabalho tedioso, é super importante para a criação de instalações específicas
112. contudo, para o nosso caso (e muitos outros), é mais prático a utilização de uma imagem Docker
114. $ docker image pull php:7.4.0RC1-cli-alpine3.10
115. $ alias php74='docker container run -it !--rm -v 
 “$PWD":/app -w /app php:7.4.0RC1-cli-alpine3.10 php'
116. $ php74 !--version
 PHP 7.4.0RC1 (cli) (built: Sep 18 2019 21:37:20) ( NTS ) Copyright (c) The PHP Group Zend Engine v3.4.0-dev, Copyright (c) Zend Technologies
117. dependendo do editor que você utilizar, você pode ter problemas com o syntax highlight e o aviso de erros do editor
118. o PhpStorm 2019.3 EAP já possui suporte para as funcionalidades do PHP 7.4
120. Qual é o 
 futuro do PHP?
121. a próxima versão após o PHP 7.4 será a versão 8.0 e será lançada em novembro de 2020
122. a funcionalidade mais esperada para o PHP 8.0 é o JIT ou Just-In-Time Compiler
123. a compilação just-in-time permite a compilação de um programa em tempo de execução
124. a RFC do JIT foi aceita no início de 2019 e entraria como uma funcionalidade experimental no PHP 7.4
125. porém, isso foi recusado pelo internals
126. outra funcionalidade que ficou em evidência para o PHP 8.0 são as union types
127. uma union type aceita valores de tipos diferentes ao invés de apenas um tipo
128. as union types não são suportadas pelo PHP mas é possível utilizá-las via annotations em docblocks
129. Conclusão
130. o PHP tem tido uma enorme evolução e tem se tornado uma linguagem mais robusta
131. porém, sem perder a flexibilidade e a pequena curva de aprendizado que o torna uma linguagem tão democrática
132. as novas funcionalidades ajudarão o seu código a ter mais garantias, ser mais expressivo e te dar mais poderes
133. vá em frente e divirta-se!
134. Referências
135. bit.ly/referencias-palestra-php74
136. Avalie!
137. joind.in/talk/cd7b9
138. Anúncio!
139. bit.ly/workshop-php74 cupom de 20% desconto: MARCEL
140. @marcelgsantos speakerdeck.com/marcelgsantos Obrigado. Perguntas?