9 novidades da versão 7.1 do PHP

1 – Aritmética de strings

O PHP, por normalmente lidar com a web e os valores costumam chegar ao servidor em geral como sequência de caracteres, permitia a execução de cálculos entre valores string, como abaixo demonstrado:

// PHP 5.6
var_dump("1" + "2");           //int(3)
var_dump("1" + "string");      //int(1)
var_dump("1" + "2 e string");  //int(3)

No entanto este comportamento foi alterado, conforme exemplo abaixo:

// PHP 7.1
var_dump("1" + "2");           //int(3)
var_dump("1" + "string");      //int(1) - Warning: A non-numeric value encountered in index.php on line 2
var_dump("1" + "2 e string");  //int(3) - Notice: A non well formed numeric value encountered in index.php on line 3

2 – Catching múltiplos tipos de exceções
Foi adicionado a feature que permite tratar múltiplas exceções de tipos diferentes num mesmo catch. Abaixo, uma demonstração de como utilizar este novo recurso:

try {
    $classe->metodo($variavel);
} catch (TipoException | OutroTipoException $ex) {
    DB::rollBack();

    return $ex->getMessage();
}

3 – Adicionado visibilidade para const de classes
Alteração aparentemente pequena, mas muito significativa para manter a coerência estrutural de visibilidade de atributos, métodos, etc de classes PHP.

class Drall{
    private const SITE = "https://www.drall.com.br";
    protected const DEVBLOG = "https://devblog.drall.com.br";
}

4 – Adicionado suporte ao tipo de retorno void para funções
Adicionado o novo tipo de retorno de funções, void, onde uma função passa a ser obrigada a não retornar nada.

function salvar_no_log($msg): void {
    file_put_contents("arquivo_de.log",$msg."\n",FILE_APPEND);
}

5 – Closure de funções Callable
O novo método fromCallable fornece uma maneira eficiente e compacta de criar objetos Clojures a partir de callables. Abaixo um exemplo:

$callback = Closure::fromCallable([$this, 'funcao']);

6 – Tipo Iterable
O pseudo-tipo Iterable foi incluído para unir o tipo primitivo do array e a interface Traversable que é usada para tornar um valor iterável. O código abaixo é um exemplo:

// PHP 5.6

function dump(array $items)
{
    var_dump($items);
}

dump([2, 3, 4]);
dump(new Collection());

//Output
/*
array(3) {
  [0]=>
  int(2)
  [1]=>
  int(3)
  [2]=>
  int(4)
}

Catchable fatal error: Argument 1 passed to dump() must be of the type array, object given...
*/

Neste caso, a função não aceitará um valor iterável e irá lançar um erro. A modificação feita no PHP 7.1 permite que seja use iterable para descrever um valor iterável em vez de definí-lo manualmente.

// PHP 7.1
function dump(iterable $items)
{
    var_dump($items);
}

dump([2, 3, 4]);
dump(new Collection());

//Output
/*
array(3) {
  [0]=>
  int(2)
  [1]=>
  int(3)
  [2]=>
  int(4)
}
object(Collection)#2 (0) {
}
*/

7 – Destructuring Arrays

//PHP 5.6
list($a, $b, $c) = [1, 2, 3];
var_dump($a, $b, $c); // int(1) int(2) int(3)

list($a, $b, $c) = ["a" => 1, "b" => 2, "c" => 3];
var_dump($a, $b, $c); // NULL NULL NULL

Mas na nova versão do PHP, foi adicionado maior controle sobre a estrutura do array, como podemos ver abaixo:

list("a" => $a, "b" => $b, "c" => $c) = ["a" => 1, "b" => 2, "c" => 3];
var_dump($a, $b, $c); // int(1) int(2) int(3)

["a" => $a, "b" => $b, "c" => $c] = ["a" => 1, "b" => 2, "c" => 3];
var_dump($a, $b, $c); // int(1) int(2) int(3)]

//Multi-dimension arrays
[[$a, $b], [$c, $d]] = [[1, 2], [3, 4]];
var_dump($a, $b, $c, $d); // int(1) int(2) int(3) int(4)

[["b" => $b], ["c" => $c]] = [["a" => 1, "b" => 2], ["c" => 3, "d" => 4]];
var_dump($b, $c); // int(2) int(3)

8 – Nullable Types
Foi adicionado a possibilidade tipar returnos de função e seus parâmetros como pertencentes a um tipo e também a nulo. Antes não existia esta possibilidade. Para isto, basta utilizar o operador ‘?’ antes do tipo, como nos exemplos abaixo:

function sum(int $a, int $b): ?int
{
    return $a + $b;
}

function sum(?int $a, ?int $b): ?int
{
    if ($a == null || $b == null) {
        return null;
    }

    return $a + $b;
}

Atenção apenas que null não significa que o paramêtro pode ser ignorado, conforme demonstrado pelo exemplo abaixo:

var_dump(sum(null, null)); // NULL
var_dump(sum()); // throw ArgumentCountError exception

9 – ArgumentCountError Exception
Observe o comportamento do código abaixo:

// PHP 5.6

function sum($a, $b)
{
    return $a + $b;
}

sum(); 
// Warning: Missing argument 1 for sum()
// Warning: Missing argument 2 for sum()

sum(3);
// Warning: Missing argument 2 for sum()

sum(3, 4);

Warnings não são úteis neste caso, e o desenvolvedor deverá verificar se todos os argumentos estão definidos corretamente. No PHP 7.1, esses avisos foram convertidos em uma exceção ArgumentCountError.

// PHP 7.1

function sum($a, $b)
{
    return $a + $b;
}

sum(); 
// Fatal error: Uncaught ArgumentCountError: Too few arguments to function sum(), 0 passed in index.php on line 14 and exactly 2 expected in /index.php:7

sum(3); // skipped

sum(3, 4); // skipped

Gostou? Tire um minutinho e dê sua contribuição para Drall Dev Community no Patreon!

Artigos relacionados: