Argumento inválido fornecido para foreach ()

Muitas vezes acontece comigo lidar com dados que podem ser uma matriz ou uma variável nula e alimentar alguns foreachcom esses dados.

$values = get_values();

foreach ($values as $value){
  ...
}

Ao alimentar um foreach com dados que não são uma matriz, você recebe um aviso:

Aviso: argumento inválido fornecido para foreach () em [...]

Supondo que não seja possível refatorar a get_values()função para sempre retornar uma matriz (compatibilidade com versões anteriores, código-fonte não disponível, qualquer que seja o motivo), estou me perguntando qual é a maneira mais limpa e eficiente de evitar esses avisos:

• Transmitindo $valuespara matriz
• Inicializando $valuesna matriz
• Envolvendo o foreachcom umif
• Outro (por favor, sugira)

Pessoalmente, acho que isso é o mais limpo - não tenho certeza se é o mais eficiente, mente!

if (is_array($values) || is_object($values))
{
    foreach ($values as $value)
    {
        ...
    }
}

A razão da minha preferência é que ela não aloca uma matriz vazia quando você não tem nada para começar.

Que tal este? muito mais limpo e tudo em linha única.

foreach ((array) $items as $item) {
 // ...
 }

Eu costumo usar uma construção semelhante a esta:

/**
 * Determine if a variable is iterable. i.e. can be used to loop over.
 *
 * @return bool
 */
function is_iterable($var)
{
    return $var !== null 
        && (is_array($var) 
            || $var instanceof Traversable 
            || $var instanceof Iterator 
            || $var instanceof IteratorAggregate
            );
}

$values = get_values();

if (is_iterable($values))
{
    foreach ($values as $value)
    {
        // do stuff...
    }
}

Observe que esta versão em particular não é testada, é digitada diretamente no SO a partir da memória.

Editar: adicionada verificação Traversable

Por favor, não dependa da conversão como uma solução , mesmo que outros estejam sugerindo isso como uma opção válida para evitar um erro, isso pode causar outro.

Esteja ciente: se você espera que uma forma específica de matriz seja retornada, isso poderá falhar. Mais verificações são necessárias para isso.

Por exemplo moldando uma booleana para uma matriz (array)bool, se não resultar em uma matriz vazia, mas uma matriz com um elemento que contém o valor booleano como um int: [0=>0]ou [0=>1].

Eu escrevi um teste rápido para apresentar esse problema . (Aqui está um teste de backup , caso o primeiro URL de teste falhe.)

Incluem-se testes para: null, false, true, um class, um arraye undefined.

Sempre teste sua entrada antes de usá-la no foreach. Sugestões:

1. Verificação rápida de tipo :$array = is_array($var) or is_object($var) ? $var : [] ;
2. Digite matrizes de dicas nos métodos antes de usar um foreach e especificar tipos de retorno
3. Envolvendo foreach dentro se
4. Usando try{}catch(){} blocos
5. Projetando código / teste adequados antes dos lançamentos de produção
6. Para testar uma matriz contra a forma correta, você pode usar array_key_existsuma chave específica ou testar a profundidade de uma matriz (quando for uma!) .
7. Sempre extraia seus métodos auxiliares para o espaço de nomes global de forma a reduzir o código duplicado

Tente o seguinte:

//Force array
$dataArr = is_array($dataArr) ? $dataArr : array($dataArr);
foreach ($dataArr as $val) {
  echo $val;
}

;)

$values = get_values();

foreach ((array) $values as $value){
  ...
}

O problema é sempre nulo e a fundição é de fato a solução de limpeza.

Antes de tudo, todas as variáveis ​​devem ser inicializadas. Sempre.
A transmissão não é uma opção.
se get_values ​​(); pode retornar variável de tipo diferente, esse valor deve ser verificado, é claro.

Extensão mais concisa do código de @ Kris

function secure_iterable($var)
{
    return is_iterable($var) ? $var : array();
}

foreach (secure_iterable($values) as $value)
{
     //do stuff...
}

especialmente para usar o código interno do modelo

<?php foreach (secure_iterable($values) as $value): ?>
    ...
<?php endforeach; ?>

Se você estiver usando o php7 e quiser lidar apenas com erros indefinidos, este é o IMHO mais limpo

$array = [1,2,3,4];
foreach ( $array ?? [] as $item ) {
  echo $item;
}

foreach ($arr ? $arr : [] as $elem) {
    // Does something 
}

Isso não verifica se é uma matriz, mas ignora o loop se a variável for nula ou vazia.

Não tenho certeza se esse é o caso, mas esse problema parece ocorrer várias vezes ao migrar sites wordpress ou sites dinâmicos em geral. Se esse for o caso, verifique se a hospedagem para a qual você está migrando usa a mesma versão PHP usada pelo site antigo.

Se você não está migrando seu site e este é apenas um problema que surgiu, tente atualizar para o PHP 5. Isso soluciona alguns desses problemas. Pode parecer uma solução boba, mas fez o truque para mim.

Ocorre um caso excepcional para este aviso se você definir a matriz como nula dentro do loop foreach

if (is_array($values))
{
    foreach ($values as $value)
    {
        $values = null;//WARNING!!!
    }
}

Que tal esta solução:

$type = gettype($your_iteratable);
$types = array(
    'array',
    'object'
);

if (in_array($type, $types)) {
    // foreach code comes here
}

Argumento de aviso inválido fornecido para foreach()exibição de tweets. vá para /wp-content/plugins/display-tweets-php. Em seguida, insira esse código na linha número 591, ele funcionará perfeitamente.

if (is_array($tweets)) {
    foreach ($tweets as $tweet) 
    {
        ...
    }
}

Parece também haver uma relação com o meio ambiente:

Eu tive esse erro "argumento inválido fornecido foreach ()" apenas no ambiente de desenvolvimento, mas não no prod (estou trabalhando no servidor, não no host local).

Apesar do erro, um var_dump indicou que a matriz estava bem lá (nos dois casos, app e dev).

A if (is_array($array))volta do foreach ($array as $subarray)resolveu o problema.

Desculpe, mas não posso explicar a causa, mas como demorei um pouco para encontrar uma solução, pensei em compartilhar isso melhor como uma observação.

Use a função is_array quando passar o array para o loop foreach.

if (is_array($your_variable)) {
  foreach ($your_variable as $item) {
   //your code
}
}

Que tal definir uma matriz vazia como fallback se get_value()estiver vazia?
Não consigo pensar no caminho mais curto.

$values = get_values() ?: [];

foreach ($values as $value){
  ...
}

Vou usar uma combinação de empty, issete is_arraycomo

$array = ['dog', 'cat', 'lion'];

if (!empty($array) && isset($array) && is_array($array) {
    //loop
    foreach ($array as $values) {
        echo $values; 
    }
}

eu faria o mesmo que Andy, mas usaria a função 'vazia'.

igual a:

if(empty($yourArray))
{echo"<p>There's nothing in the array.....</p>";}
else
{
foreach ($yourArray as $current_array_item)
  {
    //do something with the current array item here
  } 
}