archived-doc-pt-br/appendices/migration70/new-features.xml

<?xml version="1.0" encoding="utf-8"?>
<!-- EN-Revision: 1422d543bf028003a543fd1ce920c6a301a93a51 Maintainer: ae Status: ready --><!-- CREDITS: fabioluciano,adiel,ae,airtonzanon,leonardolara -->

<sect1 xml:id="migration70.new-features" xmlns:xlink="http://www.w3.org/1999/xlink">
 <title>Novos Recursos</title>

 <sect2 xml:id="migration70.new-features.scalar-type-declarations">
  <title>Declarações de tipos escalares</title>

  <para>

   <link linkend="language.types.declarations">Declarações de tipos</link> escalares
   vêm em dois sabores: coercivo (padrão) e estrito. Para parâmetros os seguintes tipos
   agora podem ser forçados (tanto coercivamente quanto estritamente): strings
   (<type>string</type>), inteiros (<literal>int</literal>), números
   de ponto flutuante (<type>float</type>) e booleanos (<literal>bool</literal>). Eles
   incrementam os outros tipos introduzidos no PHP 5: nomes de classe, interfaces,
   <type>array</type> e <type>callable</type>.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// Modo coercivo
function sumOfInts(int ...$ints)
{
    return array_sum($ints);
}

var_dump(sumOfInts(2, '3', 4.1));
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
int(9)
]]>
   </screen>
  </informalexample>

  <para>
   Para habilitar o modo estrito, uma única diretiva &declare; deve ser colocada no
   topo do arquivo. Isto significa que a rigorosidade de tipificação para escalares é
   configurada por arquivo. Esta diretiva não afeta somente as declarações de tipo
   de parâmetros, mas também do tipo de retorno de funções (veja
   <link linkend="language.types.declarations">declarações de tipo de retorno</link>),
   funções internas do PHP e funções de extensões
   carregadas.
  </para>

  <para>
   A documentação completa e exemplos de declarações de tipo escalar podem ser encontradas
   na referência de
   <link linkend="language.types.declarations">declaração de tipo
   </link>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.return-type-declarations">
  <title>Declarações de tipo de retorno</title>

  <para>
   O PHP 7 adiciona suporte a
   <link linkend="language.types.declarations">declarações de tipo de retorno</link>.
   Similar às
   <link linkend="language.types.declarations">declarações de tipo de argumento</link>
   as declarações de tipo de retorno especificam o tipo do valor que será
   retornado por uma função. Os mesmos
   <link linkend="language.types.declarations">tipos</link>
   estão disponíveis para declarações de tipo de retorno assim como estão disponíveis para declarações
   de tipo de argumentos.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

function arraysSum(array ...$arrays): array
{
    return array_map(function(array $array): int {
        return array_sum($array);
    }, $arrays);
}

print_r(arraysSum([1,2,3], [4,5,6], [7,8,9]));
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Array
(
    [0] => 6
    [1] => 15
    [2] => 24
)
]]>
   </screen>
  </informalexample>

  <para>
   A documentação completa e exemplos de declarações de tipo de retorno podem ser encontradas
   na referência de
   <link linkend="language.types.declarations">declarações de tipo de retorno
   </link>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.null-coalesce-op">
  <title>Operador de coalescência nula</title>

  <para>
   O operador de coalescência nula (<literal>??</literal>) foi adicionado como
   um truque sintático para o caso trivial de precisar usar um ternário em
   conjunto com a função <function>isset</function>. Ele retorna o primeiro operando
   se este existir e não for &null;; caso contrário retorna o segundo operando.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// Obtém o valor de $_GET['user'] e retorna 'nobody'
// se ele não existir.
$username = $_GET['user'] ?? 'nobody';
// Isto equivale a:
$username = isset($_GET['user']) ? $_GET['user'] : 'nobody';

// A coalescência pode ser encadeada: isto irá retornar o primeiro
// valor definido entre $_GET['user'], $_POST['user'] e
// 'nobody'.
$username = $_GET['user'] ?? $_POST['user'] ?? 'nobody';
?>
]]>
   </programlisting>
  </informalexample>

  <!-- TODO: we don't need further details here, but this still has to be
       added to the operator precedence table -->
 </sect2>

 <sect2 xml:id="migration70.new-features.spaceship-op">
  <title>Operador "nave espacial" (spaceship)</title>
  <para>
   O operador nave espacial é utilizado para comparar duas expressões. Ele retorna -1, 0
   ou 1 quando <varname>$a</varname> for respectivamente menor que, igual a ou maior
   que <varname>$b</varname>. As comparações são feitas de acordo com as já conhecidas
   <link linkend="types.comparisons">regras de comparação de tipos</link> do PHP.
  </para>
  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// Inteiros
echo 1 <=> 1; // 0
echo 1 <=> 2; // -1
echo 2 <=> 1; // 1

// Números de ponto flutuante
echo 1.5 <=> 1.5; // 0
echo 1.5 <=> 2.5; // -1
echo 2.5 <=> 1.5; // 1

// Strings
echo "a" <=> "a"; // 0
echo "a" <=> "b"; // -1
echo "b" <=> "a"; // 1
?>
]]>
   </programlisting>
  </informalexample>

  <!-- TODO: we don't need further details here, but this still has to be
       added to the operator precedence table -->
 </sect2>

 <sect2 xml:id="migration70.new-features.define-array">
  <title>Arrays de constantes utilizando a função <function>define</function></title>

  <para>
   Constantes do tipo <type>array</type> agora podem ser definidas com a função
   <function>define</function>. No PHP 5.6 elas só poderiam ser definidas com
   &const;.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
define('ANIMALS', [
    'dog',
    'cat',
    'bird'
]);

echo ANIMALS[1]; // imprime "cat"
?>
]]>
   </programlisting>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.anonymous-classes">
  <title>Classes Anônimas</title>

  <para>
   O suporte a classes anônimas foi adicionado utilizando <literal>new
   class</literal>. Estas podem ser utilizadas no lugar de definições completas de classes para
   objetos descartáveis.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
interface Logger {
    public function log(string $msg);
}

class Application {
    private $logger;

    public function getLogger(): Logger {
         return $this->logger;
    }

    public function setLogger(Logger $logger) {
         $this->logger = $logger;
    }
}

$app = new Application;
$app->setLogger(new class implements Logger {
    public function log(string $msg) {
        echo $msg;
    }
});

var_dump($app->getLogger());
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
object(class@anonymous)#2 (0) {
}
]]>
   </screen>
  </informalexample>

  <para>
   A documentação completa pode ser encontrada na
   <link linkend="language.oop5.anonymous">referência de classes anônimas</link>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.unicode-codepoint-escape-syntax">
  <title>Sintaxe de escape de códigos Unicode</title>

  <para>
   Toma um código Unicode em sua forma hexadecimal e imprime
   esse código em UTF-8 em uma string delimitada por aspas ou um heredoc. Qualquer código
   válido é aceito, com os zeros à esquerda sendo opcionais.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

echo "\u{aa}", PHP_EOL;
echo "\u{0000aa}", PHP_EOL;

echo "\u{9999}", PHP_EOL;

echo <<<EOT
\u{01f418}
EOT;

?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
ª
ª (o mesmo que antes mas com os zeros à esquerda opcionais)
香
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.closure-call-method">
  <title><methodname>Closure::call</methodname></title>

  <para>
   O método <methodname>Closure::call</methodname> é uma forma mais eficaz
   e abreviada de associar temporariamente um escopo de objeto a uma closure e invocá-la.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
class A {private $x = 1;}

// Código anterior ao PHP 7
$getXCB = function() {return $this->x;};
$getX = $getXCB->bindTo(new A, 'A'); // intermediate closure
echo $getX();

// Código do PHP 7+
$getX = function() {return $this->x;};
echo $getX->call(new A);
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
1
1
]]>
   </screen>
  </informalexample>
 </sect2>
 <sect2 xml:id="migration70.new-features.filtered-unserialize">
  <title><function>unserialize</function> filtrado</title>

  <para>
   Esse recurso busca prover uma melhor segurança ao desserializar objetos
   com informações não confiáveis. Ele impede possíveis injeções de código ao permitir que o
   desenvolvedor liste as classes que podem ser desserializadas.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

// converte todos os objetos em objetos __PHP_Incomplete_Class
$data = unserialize($foo, ["allowed_classes" => false]);

// converte todos os objetos em objetos __PHP_Incomplete_Class exceto aqueles de MyClass e MyClass2
$data = unserialize($foo, ["allowed_classes" => ["MyClass", "MyClass2"]]);

// comportamento padrão (o mesmo que omitir o segundo argumento) que aceita todas as classes
$data = unserialize($foo, ["allowed_classes" => true]);
]]>
   </programlisting>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.intlchar">
  <title><classname>IntlChar</classname></title>

  <para>
   A nova classe <classname>IntlChar</classname> busca expor funcionalidades adicionais
   da ICU. A classe define alguns métodos estáticos e
   constantes que podem ser utilizados para manipular caracteres Unicode.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

printf('%x', IntlChar::CODEPOINT_MAX);
echo IntlChar::charName('@');
var_dump(IntlChar::ispunct('!'));
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
10ffff
COMMERCIAL AT
bool(true)
]]>
   </screen>
  </informalexample>

  <para>
   Para utilizar esta classe a extensão <link linkend="book.intl">Intl</link> deve estar instalada.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.expectations">
  <title>Expectations</title>

  <para>
   Expectations são
   aprimoramentos compatíveis com versões anteriores para a antiga função <function>assert</function>.
   Permitem asserções com custo zero em código em produção e
   fornecem a capacidade de lançar exceções personalizadas quando a asserção falha.
  </para>

  <para>
   Enquanto a API antiga continua sendo mantida por motivos de compatibilidade,
   <function>assert</function> agora é um construtor de linguagem, permitindo que
   o primeiro parâmetro seja uma expressão, em vez de somente uma <type>string</type> a ser
   avaliada ou um valor <type>bool</type> a ser testado.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
ini_set('assert.exception', 1);

class CustomError extends AssertionError {}

assert(false, new CustomError('Alguma mensagem de erro'));
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
Fatal error: Uncaught CustomError: Alguma mensagem de erro
]]>
   </screen>
  </informalexample>

  <para>
   Mais detalhes sobre este recurso, incluindo como configurá-lo tanto no
   ambiente de desenvolvimento quanto em produção, podem ser encontrados no pagina do manual
   do construtor de linguagem <function>assert</function>;
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.group-use-declarations">
  <title>Agrupamento de declarações <literal>use</literal></title>

  <para>
   Classes, funções e constantes importadas do mesmo &namespace;,
   agora podem ser agrupadas em uma única declaração &use.namespace;
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
// Código anterior ao PHP 7
use some\namespace\ClassA;
use some\namespace\ClassB;
use some\namespace\ClassC as C;

use function some\namespace\fn_a;
use function some\namespace\fn_b;
use function some\namespace\fn_c;

use const some\namespace\ConstA;
use const some\namespace\ConstB;
use const some\namespace\ConstC;

// Código do PHP 7+
use some\namespace\{ClassA, ClassB, ClassC as C};
use function some\namespace\{fn_a, fn_b, fn_c};
use const some\namespace\{ConstA, ConstB, ConstC};
?>
]]>
   </programlisting>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.generator-return-expressions">
  <title>Expressões de Retorno nos Geradores</title>

  <para>
   Este recurso foi construído em cima da funcionalidade de geradores introduzida no PHP 5.5.
   Ele permite que uma declaração <literal>return</literal> seja usada dentro de um
   gerador para permitir que uma expressão final seja retornada (retornar por
   referência não é permitido). Este valor pode ser obtido usando o novo método
   <literal>Generator::getReturn()</literal>, que deve ser usado somente
   quando o gerador terminar a geração dos valores.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php

$gen = (function() {
    yield 1;
    yield 2;

    return 3;
})();

foreach ($gen as $val) {
    echo $val, PHP_EOL;
}

echo $gen->getReturn(), PHP_EOL;
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
1
2
3
]]>
   </screen>
  </informalexample>

  <para>
   A habilidade de retornar explicitamente o valor final de um gerador é
   conveniente de se ter. Ela permite que o retorno do valor final do
   gerador (pode ser de uma computação concorrente) possa ser manipulado
   especificamente pelo código cliente que executa o gerador. Isso é bem mais
   simples que forçar o código cliente a primeiro checar se o valor final
   já foi gerado, e em caso afirmativo, manipular esse valor especificamente.
  </para>
 </sect2>
 <sect2 xml:id="migration70.new-features.generator-delegation">
  <title>Delegação de geradores</title>

  <para>
   Geradores agora podem delegar para outros geradores,
   objetos <classname>Traversable</classname> ou <type>array</type>
   automaticamente, sem a necessidade de escrever código repetitivo no gerador externo
   utilizando o construtor &yield.from;
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
function gen()
{
    yield 1;
    yield 2;
    yield from gen2();
}

function gen2()
{
    yield 3;
    yield 4;
}

foreach (gen() as $val)
{
    echo $val, PHP_EOL;
}
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
1
2
3
4
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.intdiv">
  <title>Divisão de inteiros com <function>intdiv</function></title>

  <para>
   A nova função <function>intdiv</function> realiza a divisão de inteiros
   de seus operandos e a retorna.
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
var_dump(intdiv(10, 3));
?>
]]>
   </programlisting>
   &example.outputs;
   <screen>
<![CDATA[
int(3)
]]>
   </screen>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.session-options">
  <title>Opções de sessões</title>

  <para>
   A função <function>session_start</function> agora aceita um <type>array</type> de
   opções que sobrescrevem as
   <link linkend="session.configuration">diretivas de configuração de sessões</link>
   normalmente configuradas no php.ini.
  </para>

  <para>
   Estas opções também foram expandidas para suportar
   <link linkend="ini.session.lazy-write">session.lazy_write</link>, que está
   habilitada por padrão e faz com que o PHP somente sobrescreva um arquivo de sessão se
   a informação da sessão foi modificada, e <literal>read_and_close</literal>, que é
   uma opção que só pode ser passada para a função <function>session_start</function> para
   indicar que os dados da sessão devem ser lidos e, em seguida, a sessão deve
   ser imediatamente fechada sem alterações.
  </para>

  <para>
   Por exemplo, para configurar
   <link linkend="ini.session.cache-limiter">session.cache_limiter</link> para
   <literal>private</literal> e fechar imediatamente a sessão após
   lê-la:
  </para>

  <informalexample>
   <programlisting role="php">
<![CDATA[
<?php
session_start([
    'cache_limiter' => 'private',
    'read_and_close' => true,
]);
?>
]]>
   </programlisting>
  </informalexample>
 </sect2>

 <sect2 xml:id="migration70.new-features.preg-repace-callback-array-function">
  <title><function>preg_replace_callback_array</function></title>

  <para>
   A nova função <function>preg_replace_callback_array</function> permite
   que o código seja escrito de forma mais limpa com a utilização da função
   <function>preg_replace_callback</function>. Antes do PHP 7,
   callbacks que precisam ser executadas por expressões regulares exigiam que a
   função de callback fosse poluída com muitas ramificações.
  </para>

  <para>
   Agora, funções de callback podem ser registradas em cada expressão regular utilizando um
   array associativo, onde a chave é uma expressão regular e o valor é uma
   função de callback.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.csprng-functions">
  <title>Funções CSPRNG</title>

  <para>
   Duas novas funções foram adicionadas para gerar inteiros e strings
   criptograficamente seguros de maneira multiplataforma:
   <function>random_bytes</function> e <function>random_int</function>.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.list-arrayaccess">
  <title>
   A função <function>list</function> pode sempre desempacotar objetos que implementam
   <classname>ArrayAccess</classname>
  </title>

  <para>
   Antes a função <function>list</function> não garantia corretude
   em operações com objetos que implementam <classname>ArrayAccess</classname>.
   Isso foi corrigido.
  </para>
 </sect2>

 <sect2 xml:id="migration70.new-features.others">
  <title>Outros Recursos</title>
  <itemizedlist>
   <listitem>
    <simpara>
     Acesso a membros de classe na clonagem foi adicionado,
     por exemplo, <literal>(clone $foo)-&gt;bar()</literal>.
    </simpara>
   </listitem>
  </itemizedlist>
 </sect2>
</sect1>

<!-- Keep this comment at the end of the file
Local variables:
mode: sgml
sgml-omittag:t
sgml-shorttag:t
sgml-minimize-attributes:nil
sgml-always-quote-attributes:t
sgml-indent-step:1
sgml-indent-data:t
indent-tabs-mode:nil
sgml-parent-document:nil
sgml-default-dtd-file:"~/.phpdoc/manual.ced"
sgml-exposed-tags:nil
sgml-local-catalogs:nil
sgml-local-ecat-files:nil
End:
vim600: syn=xml fen fdm=syntax fdl=2 si
vim: et tw=78 syn=sgml
vi: ts=1 sw=1
-->