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é!
About the author
My name is Kaique Garcia, but you can call me Kiko. I'm a developer since 2014, a guitar player since 2008, a World Wide Web explorer since 2000 and a living guy since 1992 (haha). My hobby is to have hobbies (I can tell you more than 20 hobbies I got from my childhood). My pleasure is to solve problems, that's the way I came to the development area. Ok, lemme finish it... I like to meet people, so don't worry about speaking to me!
Comments
Join the discussionEsse operador ?-> me deu um susto ontem quando lia um artigo sobre o padrão Factory. Mais uma vez obrigado! Salvou a lavoura! kkk
Hahuahuhuahua os operadores mais recentes precisam ser mais ressaltados, ainda não está listado nem na documentação oficial. Ainda bem que te serviu na hora quase perfeita!
Inté!
PHP para Iniciantes
Neste mini-curso, irei falar sobre todos os pontos básicos sobre o PHP, de forma que qualquer pessoa que nunca viu a linguagem poderá conhecer o básico do básico sobre ela.