Com a disponibilização do PHP 7.1, novos recursos foram adicionados à linguagem, incluindo o pseudotype iterable. Este artigo apresenta uma introdução sobre este novo recurso, bem como exemplos de utilização.
Introdução
O pseudotype iterable foi adicionado a partir do aceite da PHP RFC: Iterable, baseada no pseudotype callable incluído na versão 5.4. Um pseudotype (pseudotipo, em tradução livre), é um tipo utilizado pelo PHP para efetuar verificações de tipagem em tempo de execução, sendo que o iterable é usado para verificação de elementos que devem ser iteráveis e podem ser utilizados como entrada em estruturas foreach.
Antes do Iterable
O exemplo abaixo apresenta um código-fonte para a classe de exemplo Foo\Bar que possui o método setOptions, responsável por configurar as possíveis opções internas de execução, que recebe como parâmetro um conjunto de opções que deve ser iterado através de uma estrutura foreach.
<?php
namespace Foo;
use InvalidArgumentException;
use Traversable;
/**
* Classe de Exemplo
*/
class Bar
{
/**
* Opções
* @type array
*/
protected $options = [];
/**
* Configura uma Opção
*
* @param string $name Nome
* @param string $value Valor
* @return self Próprio Objeto para Encadeamento
*/
public function setOption(string $name, string $value)
{
$this->options[$name] = $value;
return $this;
}
/**
* Configura um Conjunto de Opções
*
* @param array|Traversable Valores para Configuração
* @throws InvalidArgumentException Opções com Tipo Inválido
* @return self Próprio Objeto para Encadeamento
*/
public function setOptions($options) : self
{
// Tipagem Correta?
if (! is_array($options) || ! $options instanceof Traversable) {
throw new InvalidArgumentException('Invalid "$options" Type');
}
// Processamento
foreach ($options as $name => $value) {
$this->setOption($name, $value);
}
// Encadeamento
return $this;
}
}
Para tornar o código robusto, deve-se adicionar uma verificação antes da estrutura foreach, verificando se a variável $options é do tipo básico array ou é um objeto que pertence a uma classe que possui a interface Traversable implementada. Com esta condicional, há a garantia de que a iteração será executada com sucesso.
Aplicando o Iterable
Com a inclusão do pseudotype iterable na versão 7.1 do PHP, a verificação de tipo iterável pode ser efetuada diretamente pela linguagem de programação, melhorando a compreensão do código-fonte. O método Foo\Bar::setOptions pode ser definido conforme o exemplo abaixo.
<?php
// ...
/**
* Configura um Conjunto de Opções
*
* @param iterable Valores para Configuração
* @return self Próprio Objeto para Encadeamento
*/
public function setOptions(iterable $options) : self
{
// Processamento
foreach ($options as $name => $value) {
$this->setOptions($name, $value);
}
// Encadeamento
return $this;
}
// ...
Em resumo, a análise de tipagem do parâmetro $options fica a cargo da própria linguagem de programação, efetuando as mesmas verificações do exemplo anterior. Caso o parâmetro $options não seja do tipo básico array ou um objeto de uma classe que não implementa a interface Traversable, o PHP efetuará um throw de uma exceção do tipo TypeError.
Verificando Manualmente
Junto com o pseudotype iterable, adicionou-se a função is_iterable, que verifica se o argumento passado é do tipo iterable. O próximo código-fonte apresenta um exemplo de utilização desta função.
<?php
var_dump(is_iterable([])); // true
var_dump(is_iterable(new ArrayIterator())); // true
var_dump(is_iterable(1)); // false
var_dump(is_iterable('foobar')); // false
Conclusão
A criação do pseudotype iterator faz com que o código-fonte possua menos verificações de tipagem, fazendo com que ele seja mais robusto e compreensível através dos próprios recursos da linguagem de programação. Todavia, na data quando este artigo foi redigido, a documentação do PHP não recebeu informações sobre este novo recurso, somente apresentando a RFC de idealização.
Com a inclusão deste novo tipo, pode-se dizer que os autores do PHP estão abertos para mudanças, melhorando, assim, a tipagem fraca encontrada na linguagem.