O Que Há de Novo no PHP 7.4?

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.

52711e2157a6fed933b0361cc06a6953?s=128

Marcel dos Santos

September 27, 2019
Tweet

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

  3. None
  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
  113. None
  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
  119. None
  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?