A linguagem PHP vem evoluindo ano desde que foi lançada em 1995. A cada nova versão, mudanças interessantíssimas na sintaxe da linguagem, funcionamento da VM e utilidades são adicionadas à linguagem e outras coisas que já não fazem mais sentido são removidas.

A discrepância é enorme e em 2023 o código PHP estará ainda mais diferente, com as funcionalidades introduzidas pelas versões 7.4, 8.0, 8.1 e 8.2. Eu separei então 8 dicas de PHP que você PRECISA conhecer em 2023 para o seu código PHP ficar LINDO.

Navegue pelo índice

    1) Expressões “match” – match expressions

    Quem trouxe as match expressions para a linguagem foi Ilija Tovilo com inspiração na linguagem Rust. Esta funcionalidade nos permite substituir um statement do tipo switch por uma expressão.

    De forma que as duas funções a seguir são equivalentes:

    function getFruitById(int $fruitId): string
{
  switch ($fruitId) {
    case FRUIT_APPLE:
      return 'apple';
    case FRUIT_BANANA:
      return 'banana';
    case FRUIT_TOMATO:
      return 'tomato';
    default:
      return 'unknown';
  }
}

function getFruiById2(int $fruitId): string
{
  return match($fruitId) {
    FRUIT_APPLE => 'apple',
    FRUIT_BANANA => 'banana',
    FRUIT_TOMATO => 'tomato',
    default => 'unknown'
  }
}

    Note que getFruiById2() tem um corpo de função MUITO menor. E como match é uma expressão, seu resultado por ser usado diretamente com um return ou ser armazenado numa variável.

    2) Construtores de classe tunados

    Aqui nós vamos somar funcionalidades que foram introduzidas ao PHP nas versões 8.0, 8.1 e 8.2 de uma vez só!

    Desde o PHP 8.0 é possível declarar propriedades de uma classe diretamente a partir de seu construtor. É o chamado Constructor Promotion.

    As duas classes abaixo são imediatamente equivalentes:

    class MinhaClasse {
  public string $hello;
  
  public function __construct(string $hello = 'world') {
    $this->hello = $hello;
  }
}

class MinhaClasse {
  public function __construct(
    public string $hello = 'world'
  ) {}
}

    Eu sei! A sintaxe é estranha, mas a praticidade faz valer a pena. Daí, com o PHP 8.1 vieram as propriedades somente leitura, que facilitam a implementação de imutabilidade no código. E como a funcionalidade se soma ao Constructor Promotion, nós podemos escrever classes assim:

    class MinhaClasse {
  public function __construct(
    public readonly string $hello = 'world'
  ) {}
}

    E agora com o PHP 8.2 nós podemos transformar a classe inteira em somente leitura. De forma que todas as propriedades de uma classe sejam somente leitura. Por fim a nossa classe fica assim:

    readonly class MinhaClasse {
  public function __construct(
    public string $hello = 'world'
  ) {}
}

    Se essa diquinha não valeu um compartilhamento nas suas redes, eu não sei o que vai valer!

    3) União, intersecção e tudo sobre tipos

    O PHP vem melhorando seu suporte a tipagem forte a cada versão. E como boa linguagem pirata que é, adota tudo que há de bom de outras linguagens por aí.

    Na versão do PHP 8.0 nós vimos nascer a sintaxe de Union Types, que permite a criação de tipos mais flexíveis. A função abaixo recebe um parâmetro que poderia ser um integer OU um float, mas nunca uma string por exemplo:

    function minhaFuncao(int|float $numero) {}

minhaFuncao(10); // Tudo bem
minhaFuncao(0.10); // Tudo bem
minhaFuncao("10"); // Uepa! String não!

    Acontece que $numero NUNCA poderia ser int E float ao mesmo tempo. Mas isto é necessário para alguns objetos! Por isso o PHP 8.1 trouxe os Intersection Types, que justamente permitem dizer que um parâmetro ou propriedade tem dois tipos ao mesmo tempo.

    Eu gosto sempre de dar este exemplo usando o Prophecy, utilizado para criar stubs no PHPUnit:

    class MeuTest extends TestCase
{
  private MinhaClasse & ObjectProphecy $meuObjeto;
}

    Este é um exemplo clássico de objeto que tem dois tipos ao mesmo tempo: o tipo original, e o tipo ObjectProphecy.

    Por fim, o PHP 8.2 nos permite misturar os conceitos de Union Types e Intersection Types no que é chamado de Disjunctive Normal Formal Types – nome feio da poxa! Que é só um jeito complicado de dizer que pode misturar os dois conceitos. Veja:

    private (MinhaClasse & ObjectProphecy) | false $meuObjeto;

    A tipagem no PHP está ficando MUITO robusta. Se você quiser entender de vez como funcionam os tipos na linguagem, eu recomendo o meu artigo sobre tipos em PHP que vai te dar uma visão profunda de como a máquina virtual PHP lida com tipos internamente.

    php 2023

    4) A expressão throw

    Desde o PHP 8.0 a palavra-chave throw não é mais considerada um statement, mas sim uma expression. Desta forma é possível lançar exceções em espaços que só aceitam expressões.

    Aqui vão alguns exemplos:

    match ($var) {
  1, 2, 3 => 'pin!',
  4, 5, 6 => 'pin!!',
  default => throw new InvalidArgumentException()
}

$conn = msqli_connect('...') || throw new DatabaseException();

    5) Arrow functions

    Arrow functions são funções de uma linha, que sempre retornam algum valor. Elas são extremamente úteis em conjunto com funções como array_map() e array_filter() por exemplo.

    Aqui vai um exemplo de como as arrow functions do PHP 7.4 funcionam em conjunto com a função array_map():

    $numeros = [0, 1, 2, 3, 4];
$dobrados = array_map(fn (int $n) => $n * 2, $numeros);

var_dump($dobrados);
/**
 * array(5) {
 *  [0] => int(0),
 *  [1] => int(2),
 *  [2] => int(4),
 *  [3] => int(6),
 *  [4] => int(8),
 * }
 */

    6) Números grandes com o separador _

    Ainda do PHP 7.4 nós tivemos uma adição à sintaxe que deixa muito mais fácil ler números grandes. O operador se separação de literais nos permite quebrar um número em diversas partes pra facilitar a leitura.

    Veja alguns exemplos:

    $decimal = 1_000_000;
$hexadecimal = 0xC0_DA_11_05;

    7) Operador nullsafe ?->

    O operador nullsafe foi introduzido na versão PHP 8.0 e vai nos ajudar a evitar uma porção de erros fatais!

    Sempre que uma variável ou retorno de função puder ser null você pode utilizar o operador ?-> pra invocar seus métodos. Se a variável for null, o método jamais será invocado e seu valor será null automaticamente. Veja:

    $date = new DateTime();
$date = null;

$formatada = $date?->format('Y-m-d');
var_dump($formatada);
/**
 * NULL
 */

    8) Objetos como valor padrão de funções e propriedades

    Desde há muito tempo era possível adotar valores padrão para parâmetros de funções e também para propriedades de classes assim:

    class MinhaClasse {
  private string $ola = 'mundo';
  
  public function meuMetodo(string $ola = 'mundo') {}
}

    Porém existe uma limitação quando o seu tipo é um objeto. O PHP 8.1 nos permite agora instanciar objetos como valor padrão para parâmetros e propriedades, como no exemplo a seguir:

    class MinhaClasse {
  private DateTimeInterface $data = new DateTimeImmutable();
  
  public function meuMetodo(DateTimeInterface $data = new DateTimeImmutable()) {}
}

    Conclusão

    O PHP tá voando e 2023 promete! Desde o PHP 7.0 nós vimos uma verdadeira revolução na linguagem e o PHP 8.2 está simplesmente incrível.

    Pra saber mais sobre novidades do PHP e outras dicas, fica de olho no blog Codamos e me segue lá no Twitter!

    Não esquece de compartilhar essas dicas de PHP nas suas redes, com a sua equipe e a quem mais puder interessar. Convenhamos, é uma informação de utilidade pública!

    No PHP Community Summit de 2020 eu falei um pouco sobre a história do PHP desde 1995 até 2020, quando saiu o PHP 8.0.

    Até a próxima!

    Categorias: Código aberto