Primeiramente, preciso te contar que esse artigo não existe na documentação oficial do PHP. Eu inventei esse título - o que pode parecer genial e ao mesmo tempo estúpido - baseado no que acredito fazer sentido sobre o assunto da vez. E por ser um nome inventado, depois de ler tudo, comenta aí se fez sentido, pode ser? Obrigado desde já.
Esse é o último artigo da seção que fala sobre Operadores e eu já falei sobre tudo o que será mencionado aqui.
Ué, Kiko... Se você já falou, por que escrever um artigo?
Por que o artigo onde escrevi foi o Operador de Controle de Erro, o que pode levar a entender que os operadores que quero apresentar só servem para evitar erros e não é esse o ponto. Eu apenas mencionei formas de se fazer tratativas, assim como faço em todo artigo, não é mesmo?
Então hoje nós vamos falar sobre dois operadores relativamente recentes na linguagem:
- null coalescing operator, que chamarei de operador de alternativa de anulidade (mas a tradução correta é operador de coalescência nula);
- nullsafe operator, que vou traduzir para operador de prevenção de anulidade.
Vale ressaltar que ninguém os chama como as traduções que fiz, então se for comentar com alguém, usa o nome em inglês, beleza? Gosto de traduzir dessa forma para que iniciantes possam ter uma ideia clara do motivo da existência desses operadores e ter uma certa clareza no próprio nome.
Começando pela ordem cronológica de lançamentos...
Operador ?? (alternativa de anulidade)
Esse operador surgiu na versão 7 do PHP e veio para abalar as equações ternárias. Basicamente, existia um monte de apliações PHP que, para evitar valores negativos (os false quando convertido para booleano), escrevia ternários redundantes. Por exemplo:
<?php
$pessoa = ['nome' => null]; // essa pessoa não tem nome :O
$nomeDaPessoa = $pessoa['nome'] ? $pessoa['nome'] : 'Sem Nome';
var_dump($nomeDaPessoa); // string(Sem Nome);
Para quem não sabe, uma equação ternária é o equivalente a if-else que serve somente para atribuir um valor numa mesma variável. O código acima é o equivalente a:
<?php
$pessoa = ['nome' => null];
if ($pessoa['nome']) {
$nomeDaPessoa = $pessoa['nome'];
} else {
$nomeDaPessoa = 'Sem Nome';
}
var_dump($nomeDaPessoa); // string(Sem Nome);
O benéficio de utilizar equação ternária nesses casos é que você não repete a declaração da variável $nomeDaPessoa duas vezes. E apesar de, nesse exemplo, a ternária estar relativamente legível, na prática não é bem assim.
O padrão é que o ternário acabe sendo uma linha extensa. Tem quem coloque ternários dentro de ternários (confesso que já cometi esse crime). Então a coisa vai ficando feia.
Daí veio o PHP 7 com essa solução maravilhosa. Se a intenção é usar o ternário para dar um comando "use esse valor ou o outro se o primeiro não estiver definido", você pode resumir isso com o operador de alternativa de anulidade (daí essa tradução):
<?php
$pessoa = ['nome' => null];
$nomeDaPessoa = $pessoa['nome'] ?? 'Sem Nome';
var_dump($nomeDaPessoa); // string(Sem Nome)
Com isso, você não precisa repetir o $pessoa['nome'] duas vezes. Além disso, você pode fazer uma cadeia de alternativas, que vão sendo "testadas" da esquerda pra direita (se você não isolar um grupo com parênteses):
<?php
// não me pergunte por que alguém teria três nomes...
$pessoa = ['nome1' => null, 'nome2' => null, 'nome3' => 'Cleyton'];
$nomeDaPessoa = $pessoa['nome1'] ?? $pessoa['nome2'] ?? $pessoa['nome3'] ?? 'Sem Nome';
var_dump($nomeDaPessoa); // string(Cleyton)
Legal?! Então vamos para o próximo.
Operador ?-> (prevenção de anulidade)
Este operador veio ainda mais tarde que anterior, chegando bem fresquinho no PHP 8. Sua principal função é garantir que o que quer que esteja querendo acessar de um objeto só seja acessado se o objeto não for nulo.
Como assim, Kiko?
E lá vamos nós... :hehe:
<?php
class Exemplo
{
public function echo(): void
{
echo 'Deu sorte, gerou uma instância' . PHP_EOL;
}
public static function getInstance(): self|null
{
if (rand(0,1)) {
return null;
}
return new self;
}
}
for($index = 0; $index < 10000; $index++) {
$exemplo = Exemplo::getInstance();
$exemplo->echo();
}
No código acima, você chama o método estático getInstance para obter uma nova instância da classe Exemplo. O que acontece é: você tem 50% de chance de receber null ou a tal nova instância.
O que acontece na linha seguinte se você receber null? Bom, vai encerrar a execução com um Fatal Error, pois não tem como acessar o método echo de um null.
<b>Fatal Error</b>: Uncaught Error: Call to a member function echo() on null in [...]
Então pode ser interessante se prevenir contra esse cenário. E com esse operador isso é extremamente fácil: basta adicionar uma interrogação antes da chamada do método, ficando ?->echo():
<?php
class Exemplo
{
public function echo(): void
{
echo 'Deu sorte, gerou uma instância' . PHP_EOL;
}
public static function getInstance(): self|null
{
if (rand(0,1)) {
return null;
}
return new self;
}
}
for($index = 0; $index < 10000; $index++) {
$exemplo = Exemplo::getInstance();
$exemplo?->echo();
}
Assim, quando $exemplo for null, o interpretador não irá executar mais nada, apenas retornar null.
Ele retorna
nullpra quem, Kiko?
Pra quem estiver recebendo o resultado da chamada. No caso acima, como o método echo é void, não esperamos retorno algum. Mas poderíamos estar retornando boolean e esse fluxo adicionaria um caso de exceção que aplica null.
Dito isso, é preciso estar atento(a) sobre onde você irá aplicar esse operador, pois se o cenário não prever um valor null, tudo pode virar uma catástrofe, talvez pior do que sem o operador, rs.
Observação importante: esse operador serve SOMENTE para leitura de dados. Se você o chamar num fluxo de atribuição ou tentar criar uma referência a partir dele, será recebido(a) com um belíssimo Fatal Error. Tenta aí:
<?php
class Exemplo
{
public string $nome = 'Cleyton';
public static function getInstance(): self|null
{
if (rand(0,1)) {
return null;
}
return new self;
}
}
$exemplo = Exemplo::getInstance();
$exemplo?->nome = 'Clarissa'; // Fatal Error
// comente a linha de cima pra ver o Fatal Error debaixo
$nome = &$exemplo?->nome; // Fatal Error
Assim como o null coalescing, você também pode fazer uma cadeia de prevenções...
<?php
$pessoa = null; // tá explícito que é null só por causa do exemplo, ok?!
$resultado = $pessoa?->buscaPai()?->buscaTelefone()?->mandaSms('Seu filho bateu nos moleques da escola');
var_dump($resultado); // NULL
E é isso! Um artigo bem curtinho pra conhecer esses operadores que merecem sim um artigo exclusivo pra falar sobre eles.
Curtiu? Comenta e compartilha! Chama os amigos pra estudar PHP e tirar dúvidas comigo, hehe. No próximo artigo, começaremos a próxima seção: Estruturas de Controle.
Inté!