Argomento non valido fornito per foreach ()

Mi capita spesso di gestire dati che possono essere una matrice o una variabile nulla e di alimentare alcuni foreachdi questi dati.

$values = get_values();

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

Quando si alimenta un foreach con dati che non sono un array, viene visualizzato un avviso:

Avviso: argomento non valido fornito per foreach () in [...]

Supponendo che non sia possibile riformattare la get_values()funzione per restituire sempre un array (compatibilità con le versioni precedenti, codice sorgente non disponibile, qualunque altra ragione), mi chiedo quale sia il modo più pulito ed efficiente per evitare questi avvisi:

• Casting $valuesin array
• Inizializzazione $valuesin array
• Confezione foreachcon unif
• Altro (si prega di suggerire)

Personalmente trovo che questo sia il più pulito, non sono sicuro che sia il più efficiente, mente!

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

Il motivo della mia preferenza è che non alloca un array vuoto quando non hai nulla con cui iniziare.

Che ne dici di questo? molto più pulito e tutto in linea singola.

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

Di solito uso un costrutto simile a questo:

/**
 * 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...
    }
}

Si noti che questa particolare versione non è stata testata, è stata digitata direttamente in memoria dalla memoria.

Edit: aggiunto Traversable controllo

Per favore, non dipendere dal cast come soluzione , anche se altri lo stanno suggerendo come un'opzione valida per prevenire un errore, potrebbe causarne un altro.

Attenzione: se si prevede di restituire una forma specifica di array, ciò potrebbe non riuscire. Per questo sono necessari ulteriori controlli.

Ad esempio, il cast di un valore booleano in un array (array)bool, NON comporta un array vuoto, ma un array con un elemento contenente il valore booleano come int: [0=>0]o [0=>1].

Ho scritto un test rapido per presentare questo problema . (Ecco un test di backup nel caso in cui il primo URL del test fallisca.)

Sono inclusi i test per: null, false, true, una class, una arraye undefined.

Testa sempre i tuoi input prima di usarli in foreach. suggerimenti:

1. Controllo rapido del tipo :$array = is_array($var) or is_object($var) ? $var : [] ;
2. Digitare array di suggerimenti nei metodi prima di utilizzare un foreach e specificare i tipi di ritorno
3. Avvolgimento foreach all'interno di if
4. Usando i try{}catch(){}blocchi
5. Progettazione di codice / test adeguati prima delle versioni di produzione
6. Per testare un array con la forma corretta, è possibile utilizzare array_key_existsun tasto specifico o testare la profondità di un array (quando è uno!) .
7. Estrai sempre i tuoi metodi di supporto nello spazio dei nomi globale in modo da ridurre il codice duplicato

Prova questo:

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

;)

$values = get_values();

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

Il problema è sempre nullo e la fusione è in realtà la soluzione di pulizia.

Prima di tutto, ogni variabile deve essere inizializzata. Sempre.
Casting non è un'opzione.
if get_values ​​(); può restituire variabili di tipo diverso, questo valore deve essere verificato, ovviamente.

Estensione più concisa del codice di @ Kris

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

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

soprattutto per l'utilizzo del codice template interno

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

Se stai usando php7 e vuoi gestire solo errori non definiti, questo è l'IMHO più pulito

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

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

Questo non controlla se si tratta di un array, ma salta il ciclo se la variabile è nulla o un array vuoto.

Non sono sicuro che sia così, ma questo problema sembra verificarsi più volte durante la migrazione di siti wordpress o la migrazione di siti dinamici in generale. In tal caso, assicurati che l'hosting a cui stai eseguendo la migrazione utilizzi la stessa versione di PHP utilizzata dal tuo vecchio sito.

Se non stai migrando il tuo sito e questo è solo un problema che si è verificato, prova ad aggiornare a PHP 5. Questo risolve alcuni di questi problemi. Potrebbe sembrare una soluzione sciocca, ma ha fatto il trucco per me.

Caso eccezionale per questo avviso si verifica se si imposta l'array su null all'interno del ciclo foreach

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

Che ne dici di questa soluzione:

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

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

Argomento di avviso non valido fornito per i foreach()tweet di visualizzazione. vai a /wp-content/plugins/display-tweets-php. Quindi inserire questo codice sulla riga numero 591, funzionerà perfettamente.

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

Sembra esserci anche una relazione con l'ambiente:

Ho avuto l'errore "argomento non valido fornito foreach ()" solo nell'ambiente di sviluppo, ma non in prod (sto lavorando sul server, non localhost).

Nonostante l'errore, var_dump ha indicato che l'array era ben presente (in entrambi i casi app e dev).

L' if (is_array($array))intorno alla foreach ($array as $subarray)risolto il problema.

Mi dispiace, non posso spiegare la causa, ma dato che mi ci è voluto un po 'per trovare una soluzione, ho pensato di condividerla meglio come osservazione.

Usa la funzione is_array, quando passerai l'array per ogni ciclo.

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

Che ne dite di definire un array vuoto come fallback se get_value()è vuoto?
Non riesco a pensare a un modo più breve.

$values = get_values() ?: [];

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

Userò una combinazione di empty, issete is_arraycome

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

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

farei la stessa cosa di Andy ma userò la funzione 'vuoto'.

così:

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
  } 
}