O Que Há de Novo no PHP 8.0 e 8.1?

Slide 1

Slide 1 text

Marcel Gonçalves dos Santos @marcelgsantos php 8.0 o que há de novo ? 8.1 no e

Slide 2

Slide 2 text

pensandonaweb.com.br desenvolvedor web full-stack Marcel Gonçalves dos Santos @marcelgsantos

Slide 3

Slide 3 text

@phpsp phpsp.org.br

Slide 4

Slide 4 text

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#php80 e #php81

Slide 5

Slide 5 text

O início!

Slide 6

Slide 6 text

o PHP existe há mais de 20 anos e passou por várias "revoluções"

Slide 7

Slide 7 text

na versão 5.3 o PHP incluiu o suporte para namespaces, funções lambda e closures

Slide 8

Slide 8 text

a criação do PHP-FIG permitiu a de fi nição de padrões pela comunidade

Slide 9

Slide 9 text

o Composer causou uma transformação na forma como bibliotecas são distribuídas e como aplicações PHP são desenvolvidas

Slide 10

Slide 10 text

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

Slide 11

Slide 11 text

na versão 7.4 foram introduzidas funcionalidades muito solicitadas como propriedades tipadas, arrow functions e spread operator

Slide 12

Slide 12 text

o PHP como plataforma encontra-se mais maduro e robusto

Slide 13

Slide 13 text

C om pos e , L ar avel, Symf on y, Laminas, Slim, Sil er , CakePHP , Yii, 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, Depl oyer , PHPMail e , Magento, W or dPress, Drupal, J oo mla, 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 , PHPSpec, Pr op hecy, Mock er y, Behat, PHP CodeSniff e , PHP CS F ixer , PHPMD, PHPCPD, GrumPHP , CaptainH oo k, Dep tr ac, Rect or , phpDocument o , Safe-PHP

Slide 14

Slide 14 text

mas sempre existe espaço para melhorar!

Slide 15

Slide 15 text

a próxima grande novidade do PHP é o lançamento da versão 8.1, uma release com muitas novidades

Slide 16

Slide 16 text

Uma breve revisão sobre PHP 7.4!

Slide 17

Slide 17 text

Typed properties ou propriedades tipadas

Slide 18

Slide 18 text

as typed properties ou propriedades tipadas era uma das funcionalidades mais esperadas do PHP 7.4

Slide 19

Slide 19 text

o PHP teve uma enorme evolução no seu sistema de tipos com o passar do tempo

Slide 20

Slide 20 text

utilizavam-se docblocks e métodos getters e setters para a garantia de tipos

Slide 21

Slide 21 text

isso fazia com que, para ter essa garantia, houvesse um boilerplate desnecessário de código

Slide 22

Slide 22 text

/ / 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 . . . }

Slide 23

Slide 23 text

/ / 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; } }

Slide 24

Slide 24 text

as propriedades tipadas permitem a garantia de tipos em tempo de execução

Slide 25

Slide 25 text

se uma propriedade tipada não tiver um valor padrão ela será considerada não inicializada

Slide 26

Slide 26 text

/ / uninitialized properties and default null class User { public $id; public $name; } $user = new User; var_dump($user); / / class User#1 (2) { / / public $id = > NULL / / public $name = > NULL / / }

Slide 27

Slide 27 text

/ / uninitialized properties and no null default class User { public int $id; / / no null default public ?string $name; / / also no null default } $user = new User; var_dump($user); / / object(User)#1 (0) { / / ["id"] = > uninitialized(int) / / ["name"] = > uninitialized(?string) / / }

Slide 28

Slide 28 text

ao tentar fazer a leitura de uma propriedade não inicializada será lançado um erro do tipo TypeError

Slide 29

Slide 29 text

/ / 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

Slide 30

Slide 30 text

Arrow functions

Slide 31

Slide 31 text

as funções anônimas no PHP são bastante verbosas, principalmente quando vamos realizar uma operação simples

Slide 32

Slide 32 text

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

Slide 33

Slide 33 text

/ / anonymous function (more verbose) $add = function ($x, $y) { return $x + $y; };

Slide 34

Slide 34 text

a funcionalidade de arrow functions do PHP 7.4 torna mais concisa a sintaxe para esse padrão

Slide 35

Slide 35 text

/ / anonymous function (less verbose) $add = fn ($x, $y) = > $x + $y;

Slide 36

Slide 36 text

a sintaxe de uma arrow function é a seguinte: fn(parameter_list) => expression

Slide 37

Slide 37 text

ao utilizar uma variável de fi nida no escopo externo ela será passada de forma implícita para a expressão

Slide 38

Slide 38 text

/ / variable in parent scope is captured - by - value   $y = 1; $inc1 = fn($x) = > $x + $y; $inc2 = function ($x) use ($y) { return $x + $y; };

Slide 39

Slide 39 text

as arrow function podem ser utilizadas inúmeros casos do dia-a-dia

Slide 40

Slide 40 text

/ / 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

Slide 41

Slide 41 text

/ / 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

Slide 42

Slide 42 text

Spread operator em arrays

Slide 43

Slide 43 text

o PHP possui o suporte ao argument unpacking desde a versão 5.6 da linguagem

Slide 44

Slide 44 text

a funcionalidade permite o "desempacota- mento" de um array (ou um Traversable) em uma lista de argumentos utilizando o spread operator

Slide 45

Slide 45 text

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

Slide 46

Slide 46 text

a utilização do spread operator não era permitido na de fi nição de arrays a partir de outro array

Slide 47

Slide 47 text

/ / using spread operator to def i ne 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 ']'

Slide 48

Slide 48 text

a nova funcionalidade permite a utilização do spread operator (...) na de fi nição de um array através do unpacking dos valores de outro array ou Traversable

Slide 49

Slide 49 text

/ / using spread operator to def i ne an array from another $someNames = ['Bob', 'Carol']; $names = ['Alice', . . . $someNames, 'Daniel', 'Elisa']; print_r($names); / / ['Alice', 'Bob', 'Carol', 'Daniel', 'Elisa'];

Slide 50

Slide 50 text

essa funcionalidade só está disponível para arrays com chaves numéricas (para manter consistência com o argument unpacking)

Slide 51

Slide 51 text

Numeric literal   separator

Slide 52

Slide 52 text

ei, você consegue identi fi car que número é esse?

Slide 53

Slide 53 text

1000000000;

Slide 54

Slide 54 text

é um bilhão, 100 milhões ou 10 bilhões?

Slide 55

Slide 55 text

Difícil, né?!

Slide 56

Slide 56 text

o olho de um ser humano não é otimizado para olhar e decodi fi car rapidamente uma sequências de dígitos

Slide 57

Slide 57 text

e esse valor?

Slide 58

Slide 58 text

$discount = 13500;

Slide 59

Slide 59 text

é 13.500 ou 135 porque está em centavos?

Slide 60

Slide 60 text

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

Slide 61

Slide 61 text

/ / using numeric literal separator $threshold = 1_000_000_000; / / a billion $testValue = 100_925_284.88; / / scale is hundreds of millions $discount = 135_00; / / $135, stored as cents

Slide 62

Slide 62 text

adicionar o underscore entre dois dígitos não alterará o seu valor

Slide 63

Slide 63 text

/ / adding undescore doesn't change the value var_dump(1_000_000); / / int(1000000)

Slide 64

Slide 64 text

PHP 8.0

Slide 65

Slide 65 text

Named arguments

Slide 66

Slide 66 text

até o PHP 7.4 os argumentos só podiam ser passados de forma posicional

Slide 67

Slide 67 text

a partir do PHP 8.0 é possível passar os argumentos de forma nomeada

Slide 68

Slide 68 text

os argumentos nomeados permitem passar os argumentos para uma função com base no nome do parâmetro em vez da posição do parâmetro

Slide 69

Slide 69 text

os benefícios de usar argumentos nomeados são: -o argumento é auto-explicativo -pode ser usado em qualquer posição -pode omitir valores padrões

Slide 70

Slide 70 text

function greet(string $gretting, string $name, int $number = 1) : void { echo "$gretting, $name" . str_repeat('!', $number) . PHP_EOL; } / / using positional and named arguments greet("Hello", "Alice"); / / Hello Alice! greet(gretting: "Hello", name: "Bob"); / / Hello Bob! / / using of out - of - order named arguments greet("Hello", name: "Carol"); / / Hello Carol! greet(name: "Dave", gretting: "Hello", number: 5); / / Hello, Dave!!!!!

Slide 71

Slide 71 text

Attributes

Slide 72

Slide 72 text

os attributes permitem adicionar meta- informações a elementos do código como classes, propriedades, métodos, funções, parâmetros e constantes

Slide 73

Slide 73 text

eles permitem de fi nir diretivas de con fi guração diretamente no código

Slide 74

Slide 74 text

conceitos similares existem em outras linguagens como annotations em Java, attributes em C#, Rust e Hack e decorators em Python e JavaScript

Slide 75

Slide 75 text

os attributes ou annotations eram feitos com docblock e utilizam bibliotecas como Doctrine Annotations

Slide 76

Slide 76 text

/ / using docblock annotations in order to mapping / / an entity to database table class User { /** @Column(type="int") * / private int $id; /** @Column(type="string", length=100) * / private int $name; }

Slide 77

Slide 77 text

agora, como parte da linguagem, os attributes podem ter a sintaxe veri fi cada   por linters, ferramentas de análise   estática e IDEs

Slide 78

Slide 78 text

outra vantagem é não precisar de uma biblioteca externa para realizar o parsing de docblocks para obter as annotations

Slide 79

Slide 79 text

/ / using annotations with built - in attributes class User { # [ Column(type: 'integer')] private int $id; # [ Column(type: 'string', length: 100)] private int $name; }

Slide 80

Slide 80 text

o Doctrine ORM 2.9 passou a suportar attributes e typed properties

Slide 81

Slide 81 text

No content

Slide 82

Slide 82 text

o Symfony 5.2 também passou a suportar attributes

Slide 83

Slide 83 text

No content

Slide 84

Slide 84 text

/ / route def i nition in Symfony using attributes class SomeController { # [ Route('/path', name: 'action')] public function someAction() { / / . . . } }

Slide 85

Slide 85 text

Constructor   Property Promotion

Slide 86

Slide 86 text

durante a modelagem de objetos se faz necessário a utilização de muito boilerplate

Slide 87

Slide 87 text

cada propriedade é repetida 4 vezes e seu tipo é repetido 2 vezes

Slide 88

Slide 88 text

/ / user implementation with excessive boilerplate class User { public int $id; public string $name; public string $email; public function _ _ construct( int $id, string $name, string $email ) { $this - > id = $id; $this - > name = $name; $this - > email = $email; } }

Slide 89

Slide 89 text

$user1 = new User(1, "Alice", "alice@example.com"); print_r($user1); / / User Object / / ( / / [id] = > 1 / / [name] = > Alice / / [email] = > alice@example.com / / )

Slide 90

Slide 90 text

a partir do PHP 8.0 pode-se utilizar a funcionalidade constructor property promotion

Slide 91

Slide 91 text

ela permite a redução do boilerplate para a criação de um objeto

Slide 92

Slide 92 text

/ / using constructor property promotion / / and with no boilerplate class User { public function _ _ construct( public int $id, public string $name, public string $email ) {} }

Slide 93

Slide 93 text

$user2 = new User(2, "Bob", "bob@example.com"); print_r($user2); / / User Object / / ( / / [id] = > 2 / / [name] = > Bob / / [email] = > bob@example.com / / )

Slide 94

Slide 94 text

essa funcionalidade pode ser combinada com outras funcionalidades novas e reduzir a quantidade de código e torná-lo mais expressivo

Slide 95

Slide 95 text

a constructor property promotion está disponível em diversas linguagens como Kotlin e TypeScript

Slide 96

Slide 96 text

Union Types

Slide 97

Slide 97 text

um union type permite fazer uma anotação de tipos com diferentes tipos

Slide 98

Slide 98 text

o PHP já possui dois tipos especiais de union types: nullable types e iterable

Slide 99

Slide 99 text

o tipo nullable possui a sintaxe ?Type e pode ser do tipo Type|null, isto é, Type ou null

Slide 100

Slide 100 text

o tipo iterable pode ser do tipo array| Traversable, isto é, array ou Traversable

Slide 101

Slide 101 text

declare(strict_types=1); / / using union type to annotate a function parameter function power(float|int $number, int $exponent) : int|float { return $number * * $exponent; } echo power(3, 2); / / 9 echo power(3.5, 2); / / 12.25 echo power('3', 2.5); / / Uncaught TypeError: power() : Argument #1 ($number) must be of / / type int|float, string given

Slide 102

Slide 102 text

os union types são muito utilizado em projetos open-source e funções internas do PHP

Slide 103

Slide 103 text

o suporte nativo permite a garantia de tipos pelo interpretador PHP e reduz a necessidade de docblocks

Slide 104

Slide 104 text

Throw Expression

Slide 105

Slide 105 text

no PHP throw é uma instrução e não era possível lançar exceções em locais onde apenas expressões são permitidas…

Slide 106

Slide 106 text

…como arrow functions, null coalesce operator e operador ternário

Slide 107

Slide 107 text

/ / trying to throw an exception in an expression shows a / / syntax error in PHP 7.4 $function = fn() = > throw new Exception('an exception was thrown'); $function(); / / Parse error: syntax error, unexpected 'throw' (T_THROW) $nullableValue = null; $value = $nullableValue ? ? throw new Exception('null is not allowed'); / / Parse error: syntax error, unexpected 'throw' (T_THROW)

Slide 108

Slide 108 text

a partir do PHP 8.0 passou a ser possível utilizar throw como uma expressão

Slide 109

Slide 109 text

essa funcionalidade é bastante útil e torna o código bastante expressivo

Slide 110

Slide 110 text

/ throwing an exception in an expression $function = fn() = > throw new Exception('an exception was thrown'); $function(); / / PHP 8.0 - Fatal error: Uncaught Exception: an exception was thrown $nullableValue = null; $value = $nullableValue ? ? throw new Exception('null is not allowed'); / / PHP 8.0 - Fatal error: Uncaught Exception: null is not allowed

Slide 111

Slide 111 text

Match Expressions

Slide 112

Slide 112 text

costuma-se utilizar o switch para criar valores que serão usados no futuro

Slide 113

Slide 113 text

porém, o switch tem os seguintes problemas: - esquecer a atribuição da variável em algum dos casos   - possuir um boilerplate execessivo

Slide 114

Slide 114 text

/ / switch has an excessive boilerplate and is error prone switch ($statusCode) { case 200 : $reasonPhrase = 'Ok'; break; case 201 : $reasonPhrase = 'Created'; break; case 400 : $reasonPhrase = 'Bad Request'; break; } echo $result; / / Created

Slide 115

Slide 115 text

o match não necessita da palavra-chave break após cada branch e possui um boilerplate mais enxuto

Slide 116

Slide 116 text

/ / match is less verbose and more expressive echo match ($statusCode) { 200 = > 'Ok', 201 = > 'Created', 400 = > 'Bad Request', }; / / Created

Slide 117

Slide 117 text

o switch utiliza a comparação fraca (==) e pode levar a erros

Slide 118

Slide 118 text

o match utiliza a comparação estrita (===) e leva a uma avaliação mais previsível independente do uso de strict_types

Slide 119

Slide 119 text

utilização do break é uma das maiores fontes de erros ao utilizar o switch case

Slide 120

Slide 120 text

o match resolve este problema por ter um break implícito em cada branch

Slide 121

Slide 121 text

o match pode ter múltiplas condições para uma mesma branch

Slide 122

Slide 122 text

/ / match with multiple conditions for the same branch echo match($country) { 'brazil', 'portugal' = > 'portuguese', 'argentina', 'spain', 'mexico' = > 'spanish', default = > 'another language' }; / / portuguese

Slide 123

Slide 123 text

a match expression deve contemplar todas as opções possíveis

Slide 124

Slide 124 text

caso não exista uma branch correspondente ao resultado da expressão a exceção UnhandledMatchError será lançada

Slide 125

Slide 125 text

PHP 8.1

Slide 126

Slide 126 text

Enums

Slide 127

Slide 127 text

uma enum de fi ne um novo tipo que possui número fi xo e limitado de valores possíveis

Slide 128

Slide 128 text

/ / creates an enum for the suits of a deck enum Suit { case Hearts; case Diamonds; case Clubs; case Spades; } $value = Suit : : Hearts; var_dump($value); / / enum(Suit : : Hearts)

Slide 129

Slide 129 text

por padrão, os casos enumerados não possuem equivalentes escalares, isto é, eles são objetos singleton

Slide 130

Slide 130 text

esse tipo de valor é chamado de pure case e uma enum que contém apenas pure cases é chamada de pure enum

Slide 131

Slide 131 text

uma função ou método podem ser tipados com o tipo enum

Slide 132

Slide 132 text

/ / annotate a function parameter with an enum type function pick_a_card(Suit $suit) {} pick_a_card($value); / / ok pick_a_card(Suit : : Clubs); / / ok pick_a_card('Spades'); / / Fatal error: Uncaught TypeError: pick_a_card() : Argument #1 ($suit) must be of type Suit, string given

Slide 133

Slide 133 text

contudo, existem casos de usos em que é necessário ter equivalentes escalares para, por exemplo, persistir em uma base de dados

Slide 134

Slide 134 text

/ / create an enum backed with scalar values enum Suit: string { case Hearts = 'H'; case Diamonds = 'D'; case Clubs = 'C'; case Spades = 'S'; } var_dump(Suit : : Hearts); / / enum(Suit : : Hearts) var_dump(Suit : : Hearts - > name); / / string(6) "Hearts" var_dump(Suit : : Hearts - > value); / / string(1) "H"

Slide 135

Slide 135 text

um case que possui um equivalente escalar é chamado de backed case pois é "suportado" por um valor mais simples

Slide 136

Slide 136 text

uma enum que contém backed cases é chamado de backed enum

Slide 137

Slide 137 text

um backed enum implementa a interface interna BackedEnum que expõe dois méto- dos adicionais que são from e tryFrom

Slide 138

Slide 138 text

o método from() recebe um tipo escalar e retorna o case correspondente e, caso o valor não seja encontrado, a exceção ValueError é lançada

Slide 139

Slide 139 text

o método tryFrom() possui comportamento similar mas, caso o valor não seja encontrado, retorna nulo

Slide 140

Slide 140 text

/ / create an order status enum enum OrderStatus: string { case PendingPayment = 'pending_payment'; case Processing = 'processing'; case Completed = 'completed'; case Refunded = 'refunded'; case Cancelled = 'cancelled'; }

Slide 141

Slide 141 text

/ / create an enum value using from() method with a valid value $orderStatus = OrderStatus : : from('processing'); var_dump($orderStatus); / / enum(OrderStatus : : Processing) echo $orderStatus - > value; / / processing / / try to create an enum value using from() method with an invalid value $orderStatus = OrderStatus : : from('non_existent'); / / Fatal error: Uncaught ValueError: "non_existent" is not a / / valid backing value for enum "OrderStatus" / / try to create an enum value using tryFrom() method with an invalid value $orderStatus = OrderStatus : : tryFrom('non_existent'); var_dump($orderStatus); / / null

Slide 142

Slide 142 text

Array Unpacking com chaves em string

Slide 143

Slide 143 text

o PHP 7.4 tinha adicionado suporte para o unpacking de arrays em outros arrays utilizando o spread operator

Slide 144

Slide 144 text

porém, não era permitido o unpacking de arrays com chaves em string devido: (1) incertezas em relação a semântica e (2) limitações no argument unpacking

Slide 145

Slide 145 text

a limitação do argument unpacking foi resolvida graças a introdução de named arguments no PHP 8.0

Slide 146

Slide 146 text

/ / using array unpacking with string keys $user1 = ['name' = > 'Alice']; $user2 = ['name' = > 'Bob']; / / array unpacking with string keys in PHP 8.0 returns an error var_dump(array_merge($user1, $user2)); / / ["name" = > "Bob"] var_dump([ . . . $user1, . . . $user2]); / / Fatal error: Uncaught Error: Cannot unpack array with string keys / / array unpacking with string keys in PHP 8.1 var_dump(array_merge($user1, $user2)); / / ["name" = > "Bob"] var_dump([ . . . $user1, . . . $user2]); / / ["name" = > "Bob"]

Slide 147

Slide 147 text

com o suporte a essa funcionalidade é possível combinar as funcionalidades de argument unpacking e named arguments

Slide 148

Slide 148 text

/ / combine argument unpacking with named arguments function greet(string $greeting, string $name) : void { echo "$greeting, $name!" . PHP_EOL; } greet('Hi', 'Alice'); / / Hi, Alice! greet('Bonjour', 'Bob'); / / Bonjour, Bob! greet(greeting: 'Hallo', name: 'Carol'); / / Hallo, Carol! greet( . . . ['name' = > 'David', 'greeting' = > 'Konichiwa']); / / Konichiwa David!

Slide 149

Slide 149 text

Readonly Property

Slide 150

Slide 150 text

uma propriedade readonly não pode ser modi fi cada após a sua inicialização

Slide 151

Slide 151 text

os objetos de valores são imutáveis, isto é, as propriedades são inicializadas no construtor e não podem ser alteradas depois

Slide 152

Slide 152 text

a alternativa mais próxima disso é declarar uma propriedade privada e expor um getter público

Slide 153

Slide 153 text

/ / create an email value object and exposes a getter method class Email { public function _ _ construct( private string $value ) { / / throws an exception if the email is not valid $this - > value = $value; } public function value() : string { return $this - > value; } }

Slide 154

Slide 154 text

o lado negativo dessa abordagem é necessitar de um boilerplate maior

Slide 155

Slide 155 text

/ / create an email value object with less boilerplate class Email { public function _ _ construct( public readonly string $value ) { / / throws an exception if the email is not valid $this - > value = $value; } } $email = new Email('johndoe@example.com'); echo($email - > value); / / johndoe@example.com $email - > value = 'foobar@example.com'; / / Uncaught Error: Cannot modify readonly property Email : : $value

Slide 156

Slide 156 text

uma propriedade readonly só pode ser inicializada uma vez e somente no escopo em que ela foi declarada

Slide 157

Slide 157 text

o modi fi cador readonly só pode ser aplicado em propriedades tipadas

Slide 158

Slide 158 text

First-Class Callable Syntax

Slide 159

Slide 159 text

trata-se de uma nova sintaxe para a criação de closures

Slide 160

Slide 160 text

/ / create closures with both old and new syntax $strlen1 = Closure : : fromCallable('strlen'); $strlen2 = strlen( . . . );

Slide 161

Slide 161 text

essa sintaxe é mais expressiva, acessível a ferramentas de análise estática e respeita o escopo em que foi criada

Slide 162

Slide 162 text

Type Never

Slide 163

Slide 163 text

o tipo never é um novo tipo de retorno adicionado no PHP 8.1

Slide 164

Slide 164 text

uma função ou método declarados com o tipo de retorno never indica que nunca retornará um valor…

Slide 165

Slide 165 text

…isto é, sempre lançará uma exceção ou terminará com die ou exit

Slide 166

Slide 166 text

/ creates a function with never return type function redirect(string $url) : never { echo "redirected to $url . . . \n"; header('Location: ' . $url); exit(); } redirect('https: / / w w w .example.com'); / / redirected to https: / / w w w .example.com . . .   / / The rest of the code will not be executed! echo 'this will not be shown . . . ';

Slide 167

Slide 167 text

o objetivo do tipo de retorno never é indicar uma função que previne que o resto do código chamado seja executado

Slide 168

Slide 168 text

se uma função ou método com o tipo de retorno never não lançar uma exceção ou não terminar o programa será lançada a exceção TypeError

Slide 169

Slide 169 text

/ / create a function with never return type function dispatch(string $message) : never { echo $message; } dispatch('test'); / / Uncaught TypeError: dispatch() : never - returning / / function must not implicitly return

Slide 170

Slide 170 text

o suporte ao tipo de retorno never torna possível não utilizar mais a annotation @return noreturn

Slide 171

Slide 171 text

Quando vou poder   utilizá-lo?

Slide 172

Slide 172 text

o PHP 8.1 estará disponível a partir do fi nal de novembro de 2021

Slide 173

Slide 173 text

porém, as versões RC ou release candidates podem ser utilizadas agora para testes

Slide 174

Slide 174 text

Ok! Como faço para   utilizá-lo neste momento?

Slide 175

Slide 175 text

a forma mais prática é a utilização de uma imagem Docker

Slide 176

Slide 176 text

No content

Slide 177

Slide 177 text

$ docker image pull php:8.1.0RC5-cli - alpine3.14

Slide 178

Slide 178 text

$ alias php81='docker container run - it - - rm - v `pwd`:/app - w /app php:8.1.0RC5-cli - alpine3.14 php’

Slide 179

Slide 179 text

$ php81 - - version   PHP 8.1.0RC5 (cli) (built: Oct 28 2021 23 : 22 : 17) (NTS) Copyright (c) The PHP Group Zend Engine v4.1.0-dev, Copyright (c) Zend Technologies

Slide 180

Slide 180 text

dependendo do editor que você utilizar, você pode ter problemas com o syntax highlight e o aviso de erros do editor

Slide 181

Slide 181 text

o PhpStorm 2021.2 já possui suporte para algumas funcionalidades do PHP 8.1

Slide 182

Slide 182 text

Conclusão

Slide 183

Slide 183 text

o PHP tem tido uma enorme evolução e tem se tornado uma linguagem mais robusta

Slide 184

Slide 184 text

porém, sem perder a fl exibilidade e a pequena curva de aprendizado que o torna uma linguagem tão democrática

Slide 185

Slide 185 text

as novas funcionalidades ajudarão o seu código a ter mais garantias, ser mais expressivo e te de dar mais poderes