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. 3.
  2. 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
  3. 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!
  4. 9.

    o PHP existe há mais de 20 anos e passou

    por várias "revoluções"
  5. 12.

    o Composer causou uma transformação na forma como bibliotecas são

    distribuídas e como aplicações PHP são desenvolvidas
  6. 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
  7. 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
  8. 19.
  9. 21.

    isso fazia com que, para ter essa garantia, houvesse um

    boilerplate desnecessário de código
  10. 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!!... }
  11. 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; } }
  12. 25.

    !// properties typed with scalar, class and nullable class class

    User { public int $age; protected Address $address; private ?Passport $passport; }
  13. 26.

    !// types in static property and with var notation class

    Example { public static iterable $staticProp; var bool $flag; }
  14. 27.

    !// typed properties with default values class Example { public

    string $str = "foo"; public ?string $nullableStr = null; }
  15. 28.

    !// typed properties in one declaration class Point { public

    float $x, $y; !// more implementation… }
  16. 29.

    !// typed properties in one declaration class Point { public

    float $x; public float $y;
 
 !// more implementation… }
  17. 30.

    as declarações de tipos para propriedades suportam todos os tipos

    suportados pelo PHP com exceção de void e callable
  18. 31.

    a tipagem de propriedades, assim como a declaração de parâmetros

    e tipos de retorno, são afetadas pela diretiva strict_types
  19. 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
  20. 34.

    !// typed properties and strict types !// file2.php declare(strict_types=0); $test

    = new Test; $test!->val = "42"; var_dump($test!->val); !// int(42)
  21. 35.

    se uma propriedade tipada não tiver um valor padrão ela

    será considerada não inicializada
  22. 36.

    !// uninitialized properties and 
 !// default null (until PHP

    7.3) class User { public $id; public $name; } $user = new User; var_dump($user);
  23. 38.

    !// uninitialized properties and 
 !// no null default (PHP

    7.4) class User { public int $id; public ?string $name; } $user = new User; var_dump($user);
  24. 40.

    ao tentar fazer a leitura de uma propriedade não inicializada

    será lançado um erro do tipo TypeError
  25. 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
  26. 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
  27. 47.

    a funcionalidade de arrow functions do PHP 7.4 torna mais

    concisa a sintaxe para esse padrão
  28. 50.

    ao utilizar uma variável definida no escopo externo ela será

    passada de forma implícita para a expressão
  29. 51.

    !// variable in parent scope is captured-by-value
 $y = 1;

    $fn1 = fn($x) !=> $x + $y; $fn2 = function ($x) use ($y) { return $x + $y; };
  30. 53.

    !// variable in parent scope is captured-by-value 
 !// (nested

    functions)
 $z = 1; $fn = fn($x) !=> fn($y) !=> $x * $y + $z;
  31. 55.
  32. 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;
  33. 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
  34. 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
  35. 62.

    a funcionalidade permite o "desempacota- mento" de um array (ou

    um Traversable) em uma lista de argumentos utilizando o spread operator
  36. 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
  37. 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 ']'
  38. 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
  39. 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'];
  40. 68.

    essa funcionalidade só está disponível para arrays com chaves numéricas

    (para manter consistência com o argument unpacking)
  41. 69.

    é possível realizar a expansão de arrays múltiplas vezes e

    pode-se desempacotar um array retornado por uma função
  42. 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
  43. 72.

    !// check if a variable is defined and not null


    
 !// $data['name'] = 'John'; $name = isset($data['name']) ? $data['name'] : 'anonymous'; echo $name; !// anonymous
  44. 73.

    !// check if a variable is defined and not null


    
 $data['name'] = 'John'; $name = isset($data['name']) ? $data['name'] : 'anonymous'; echo $name; !// John
  45. 74.

    a utilização do operador null coalesce (??), disponível a partir

    do PHP 7.0, torna mais fácil lidar com esse problema
  46. 75.

    !// using null coalesce !?? operator !// $data['name'] = 'John';

    $name = $data['name'] !?? 'anonymous'; echo $name; !// anonymous
  47. 76.

    !// using null coalesce !?? operator $data['name'] = 'John'; $name

    = $data['name'] !?? 'anonymous'; echo $name; !// John
  48. 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
  49. 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';
  50. 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
  51. 81.

    !// check if variable is defined and not null and

    assign itself
 !// (using null coalesce assignment operator) $data['comments']['name'] !??= 'anonymous';
  52. 87.

    o olho de um ser humano não é otimizado para

    olhar e decodificar rapidamente uma sequências de dígitos
  53. 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
  54. 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
  55. 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
  56. 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
  57. 99.

    assistam a palestra de encerramento do Gabriel Couto sobre FFI

    que ele preparou coisas fantásticas para mostrar para vocês!
  58. 100.
  59. 110.

    o PHP 7.4 pode ser utilizado de duas formas principais:

    compilando o código fonte ou utilizando uma imagem Docker
  60. 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
  61. 112.

    contudo, para o nosso caso (e muitos outros), é mais

    prático a utilização de uma imagem Docker
  62. 113.
  63. 115.
  64. 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
  65. 117.

    dependendo do editor que você utilizar, você pode ter problemas

    com o syntax highlight e o aviso de erros do editor
  66. 119.
  67. 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
  68. 122.
  69. 124.

    a RFC do JIT foi aceita no início de 2019

    e entraria como uma funcionalidade experimental no PHP 7.4
  70. 128.

    as union types não são suportadas pelo PHP mas é

    possível utilizá-las via annotations em docblocks
  71. 129.
  72. 130.

    o PHP tem tido uma enorme evolução e tem se

    tornado uma linguagem mais robusta
  73. 131.

    porém, sem perder a flexibilidade e a pequena curva de

    aprendizado que o torna uma linguagem tão democrática
  74. 132.

    as novas funcionalidades ajudarão o seu código a ter mais

    garantias, ser mais expressivo e te dar mais poderes
  75. 136.
  76. 138.