Comment vérifier si un tableau est vide en utilisant PHP?

playerssera soit vide, soit une liste séparée par des virgules (ou une seule valeur). Quelle est la façon la plus simple de vérifier s'il est vide? Je suppose que je peux le faire dès que je récupère le $gameresulttableau dans $gamerow? Dans ce cas, il serait probablement plus efficace de sauter l'explosion $playerlists'il est vide, mais pour les besoins de l'argument, comment vérifier si un tableau est également vide?

$gamerow = mysql_fetch_array($gameresult);
$playerlist = explode(",", $gamerow['players']);

Si vous avez juste besoin de vérifier s'il y a des éléments dans le tableau

if (empty($playerlist)) {
     // list is empty.
}

Si vous devez nettoyer les valeurs vides avant de vérifier (généralement pour éviter explodeles chaînes étranges):

foreach ($playerlist as $key => $value) {
    if (empty($value)) {
       unset($playerlist[$key]);
    }
}
if (empty($playerlist)) {
   //empty array
}

Un tableau vide est falsey en PHP, vous n'avez donc même pas besoin de l'utiliser empty()comme d'autres l'ont suggéré.

<?php
$playerList = array();
if (!$playerList) {
    echo "No players";
} else {
    echo "Explode stuff...";
}
// Output is: No players

PHP de empty()détermine si une variable n'existe pas ou a une valeur de Falsey (comme array(), 0, null, false, etc.).

Dans la plupart des cas, vous voulez juste vérifier !$emptyVar. À utiliser empty($emptyVar)si la variable n'a peut-être pas été définie ET que vous n'avez pas l'habitude de déclencher un E_NOTICE; OMI, c'est généralement une mauvaise idée.

Quelques réponses décentes, mais je pensais juste développer un peu pour expliquer plus clairement quand PHP détermine si un tableau est vide.

Notes principales:

Un tableau avec une clé (ou des clés) sera déterminé comme NON vide par PHP.

Comme les valeurs de tableau ont besoin de clés pour exister, avoir ou non des valeurs dans un tableau ne détermine pas s'il est vide, uniquement s'il n'y a pas de clés (ET donc pas de valeurs).

Donc, vérifier un tableau avec empty()ne vous dit pas simplement si vous avez des valeurs ou non, il vous dit si le tableau est vide et que les clés font partie d'un tableau.

Considérez donc comment vous produisez votre tableau avant de décider quelle méthode de vérification utiliser.
EG Un tableau aura des clés lorsqu'un utilisateur soumet votre formulaire HTML lorsque chaque champ de formulaire a un nom de tableau (c'est-à-dire name="array[]").
Un tableau non vide sera produit pour chaque champ car il y aura des valeurs de clé incrémentées automatiquement pour le tableau de chaque champ de formulaire.

Prenez ces tableaux par exemple:

/* Assigning some arrays */

// Array with user defined key and value
$ArrayOne = array("UserKeyA" => "UserValueA", "UserKeyB" => "UserValueB");

// Array with auto increment key and user defined value
// as a form field would return with user input
$ArrayTwo[] = "UserValue01";
$ArrayTwo[] = "UserValue02";

// Array with auto incremented key and no value
// as a form field would return without user input
$ArrayThree[] = '';
$ArrayThree[] = '';

Si vous faites écho aux clés et valeurs de tableau pour les tableaux ci-dessus, vous obtenez ce qui suit:

TABLEAU UN:
[UserKeyA] => [UserValueA]
[UserKeyB] => [UserValueB]

TABLEAU DEUX:
[0] => [UserValue01]
[1] => [UserValue02]

TABLEAU TROIS:
[0] => []
[1] => []

Et le test des tableaux ci-dessus avec empty()renvoie les résultats suivants:

ARRAY ONE:
$ ArrayOne n'est pas vide

TABLEAU DEUX:
$ ArrayTwo n'est pas vide

TABLEAU TROIS:
$ ArrayThree n'est pas vide

Un tableau sera toujours vide lorsque vous affectez un tableau mais ne l'utilisez pas par la suite, comme:

$ArrayFour = array();

Ce sera vide, c'est-à-dire que PHP retournera TRUE lors de l'utilisation de if empty()sur ce qui précède.

Donc, si votre tableau a des clés - par exemple par les noms d'entrée d'un formulaire ou si vous les affectez manuellement (c.-à-d. Créez un tableau avec des noms de colonnes de base de données comme clés mais pas de valeurs / données de la base de données), alors le tableau ne le sera PAS empty().

Dans ce cas, vous pouvez boucler le tableau dans un foreach, tester si chaque clé a une valeur. C'est une bonne méthode si vous devez quand même parcourir le tableau, peut-être en vérifiant les clés ou en désinfectant les données.

Cependant, ce n'est pas la meilleure méthode si vous avez simplement besoin de savoir "si des valeurs existent" renvoie VRAI ou FAUX . Il existe différentes méthodes pour déterminer si un tableau a des valeurs lorsqu'il sait qu'il aura des clés. Une fonction ou une classe peut être la meilleure approche, mais comme toujours, cela dépend de votre environnement et des exigences exactes, ainsi que d'autres choses telles que ce que vous faites actuellement avec le tableau (le cas échéant).

Voici une approche qui utilise très peu de code pour vérifier si un tableau a des valeurs:

Utilisation array_filter():
Itère sur chaque valeur du tableau en les passant à la fonction de rappel. Si la fonction de rappel renvoie true, la valeur actuelle du tableau est renvoyée dans le tableau résultat. Les clés de tableau sont conservées.

$EmptyTestArray = array_filter($ArrayOne);

if (!empty($EmptyTestArray))
  {
    // do some tests on the values in $ArrayOne
  }
else
  {
    // Likely not to need an else, 
    // but could return message to user "you entered nothing" etc etc
  }

L'exécution array_filter()sur les trois tableaux d'exemple (créés dans le premier bloc de code de cette réponse) entraîne les résultats suivants:

ARRAY ONE:
$ arrayone n'est pas vide

TABLEAU DEUX:
$ arraytwo n'est pas vide

TABLEAU TROIS:
$ arraythree est vide

Ainsi, lorsqu'il n'y a pas de valeurs, qu'il y ait des clés ou non, utiliser array_filter()pour créer un nouveau tableau, puis vérifier si le nouveau tableau est vide montre s'il y avait des valeurs dans le tableau d'origine.
Ce n'est pas idéal et un peu désordonné, mais si vous avez un énorme tableau et n'avez pas besoin de le parcourir pour toute autre raison, alors c'est le plus simple en termes de code nécessaire.

Je n'ai pas l'expérience de la vérification des frais généraux, mais il serait bon de connaître les différences entre l'utilisation array_filter()et la foreachvérification si une valeur est trouvée.

De toute évidence, le benchmark devrait être sur divers paramètres, sur de petits et grands tableaux et quand il y a des valeurs et non etc.

count($gamerow['players']) sera 0.

Si vous voulez vérifier si la variable que vous testez est en fait explicitement un tableau vide, vous pouvez utiliser quelque chose comme ceci:

if ($variableToTest === array()) {
    echo 'this is explicitly an empty array!';
}

Si vous souhaitez exclure les lignes fausses ou vides (telles que 0 => ''), où l'utilisation empty()échouera, vous pouvez essayer:

if (array_filter($playerlist) == []) {
  // Array is empty!
}

array_filter(): Si aucun rappel n'est fourni, toutes les entrées de tableau égales à FALSE (voir conversion en booléen) seront supprimées.

Si vous souhaitez supprimer toutes les chaînes NULL, FALSE et vides ( ''), mais laisser des valeurs nulles ( 0), vous pouvez les utiliser strlencomme rappel, par exemple:

$is_empty = array_filter($playerlist, 'strlen') == [];

Pourquoi personne n'a dit cette réponse:

$array = [];

if($array == []) {
    // array is empty
}

is_array($detect) && empty($detect);

is_array

J'ai couru le benchmark inclus à la fin du post. Pour comparer les méthodes:

• count($arr) == 0 : compter
• empty($arr) : vide
• $arr == [] : comp
• (bool) $arr : fonte

et a obtenu les résultats suivants

Contents  \method |    count     |    empty     |     comp     |     cast     |
------------------|--------------|--------------|--------------|--------------|
            Empty |/* 1.213138 */|/* 1.070011 */|/* 1.628529 */|   1.051795   |
          Uniform |/* 1.206680 */|   1.047339   |/* 1.498836 */|/* 1.052737 */|
          Integer |/* 1.209668 */|/* 1.079858 */|/* 1.486134 */|   1.051138   |
           String |/* 1.242137 */|   1.049148   |/* 1.630259 */|/* 1.056610 */|
            Mixed |/* 1.229072 */|/* 1.068569 */|/* 1.473339 */|   1.064111   |
      Associative |/* 1.206311 */|   1.053642   |/* 1.480637 */|/* 1.137740 */|
------------------|--------------|--------------|--------------|--------------|
            Total |/* 7.307005 */|   6.368568   |/* 9.197733 */|/* 6.414131 */|

La différence entre vide et transtypé en booléen est insignifiante. J'ai exécuté ce test plusieurs fois et ils semblent être essentiellement équivalents. Le contenu des tableaux ne semble pas jouer un rôle significatif. Les deux produisent les résultats opposés, mais la négation logique est à peine suffisante pour pousser le casting à gagner la plupart du temps, donc je préfère personnellement vide pour des raisons de lisibilité dans les deux cas.

#!/usr/bin/php
<?php

//    012345678
$nt = 90000000;

$arr0 = [];
$arr1 = [];
$arr2 = [];
$arr3 = [];
$arr4 = [];
$arr5 = [];

for ($i = 0; $i < 500000; $i++) {
    $arr1[] = 0;
    $arr2[] = $i;
    $arr3[] = md5($i);
    $arr4[] = $i % 2 ? $i : md5($i);
    $arr5[md5($i)] = $i;
}

$t00 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr0) == 0;
}
$t01 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr0);
}
$t02 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr0 == [];
}
$t03 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr0;
}
$t04 = microtime(true);

$t10 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr1) == 0;
}
$t11 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr1);
}
$t12 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr1 == [];
}
$t13 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr1;
}
$t14 = microtime(true);

/* ------------------------------ */

$t20 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr2) == 0;
}
$t21 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr2);
}
$t22 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr2 == [];
}
$t23 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr2;
}
$t24 = microtime(true);

/* ------------------------------ */

$t30 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr3) == 0;
}
$t31 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr3);
}
$t32 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr3 == [];
}
$t33 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr3;
}
$t34 = microtime(true);

/* ------------------------------ */

$t40 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr4) == 0;
}
$t41 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr4);
}
$t42 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr4 == [];
}
$t43 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr4;
}
$t44 = microtime(true);

/* ----------------------------------- */

$t50 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    count($arr5) == 0;
}
$t51 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    empty($arr5);
}
$t52 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    $arr5 == [];
}
$t53 = microtime(true);
for ($i = 0; $i < $nt; $i++) {
    (bool) $arr5;
}
$t54 = microtime(true);

/* ----------------------------------- */

$t60 = $t00 + $t10 + $t20 + $t30 + $t40 + $t50;
$t61 = $t01 + $t11 + $t21 + $t31 + $t41 + $t51;
$t62 = $t02 + $t12 + $t22 + $t32 + $t42 + $t52;
$t63 = $t03 + $t13 + $t23 + $t33 + $t43 + $t53;
$t64 = $t04 + $t14 + $t24 + $t34 + $t44 + $t54;

/* ----------------------------------- */

$ts0[1] = number_format(round($t01 - $t00, 6), 6);
$ts0[2] = number_format(round($t02 - $t01, 6), 6);
$ts0[3] = number_format(round($t03 - $t02, 6), 6);
$ts0[4] = number_format(round($t04 - $t03, 6), 6);

$min_idx = array_keys($ts0, min($ts0))[0];
foreach ($ts0 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts0[$idx] = "   $val   ";
    } else {
        $ts0[$idx] = "/* $val */";
    }

}

$ts1[1] = number_format(round($t11 - $t10, 6), 6);
$ts1[2] = number_format(round($t12 - $t11, 6), 6);
$ts1[3] = number_format(round($t13 - $t12, 6), 6);
$ts1[4] = number_format(round($t14 - $t13, 6), 6);

$min_idx = array_keys($ts1, min($ts1))[0];
foreach ($ts1 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts1[$idx] = "   $val   ";
    } else {
        $ts1[$idx] = "/* $val */";
    }

}

$ts2[1] = number_format(round($t21 - $t20, 6), 6);
$ts2[2] = number_format(round($t22 - $t21, 6), 6);
$ts2[3] = number_format(round($t23 - $t22, 6), 6);
$ts2[4] = number_format(round($t24 - $t23, 6), 6);

$min_idx = array_keys($ts2, min($ts2))[0];
foreach ($ts2 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts2[$idx] = "   $val   ";
    } else {
        $ts2[$idx] = "/* $val */";
    }

}

$ts3[1] = number_format(round($t31 - $t30, 6), 6);
$ts3[2] = number_format(round($t32 - $t31, 6), 6);
$ts3[3] = number_format(round($t33 - $t32, 6), 6);
$ts3[4] = number_format(round($t34 - $t33, 6), 6);

$min_idx = array_keys($ts3, min($ts3))[0];
foreach ($ts3 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts3[$idx] = "   $val   ";
    } else {
        $ts3[$idx] = "/* $val */";
    }

}

$ts4[1] = number_format(round($t41 - $t40, 6), 6);
$ts4[2] = number_format(round($t42 - $t41, 6), 6);
$ts4[3] = number_format(round($t43 - $t42, 6), 6);
$ts4[4] = number_format(round($t44 - $t43, 6), 6);

$min_idx = array_keys($ts4, min($ts4))[0];
foreach ($ts4 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts4[$idx] = "   $val   ";
    } else {
        $ts4[$idx] = "/* $val */";
    }

}

$ts5[1] = number_format(round($t51 - $t50, 6), 6);
$ts5[2] = number_format(round($t52 - $t51, 6), 6);
$ts5[3] = number_format(round($t53 - $t52, 6), 6);
$ts5[4] = number_format(round($t54 - $t53, 6), 6);

$min_idx = array_keys($ts5, min($ts5))[0];
foreach ($ts5 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts5[$idx] = "   $val   ";
    } else {
        $ts5[$idx] = "/* $val */";
    }

}

$ts6[1] = number_format(round($t61 - $t60, 6), 6);
$ts6[2] = number_format(round($t62 - $t61, 6), 6);
$ts6[3] = number_format(round($t63 - $t62, 6), 6);
$ts6[4] = number_format(round($t64 - $t63, 6), 6);

$min_idx = array_keys($ts6, min($ts6))[0];
foreach ($ts6 as $idx => $val) {
    if ($idx == $min_idx) {
        $ts6[$idx] = "   $val   ";
    } else {
        $ts6[$idx] = "/* $val */";
    }

}

echo "             |    count     |    empty     |     comp     |     cast     |\n";
echo "-------------|--------------|--------------|--------------|--------------|\n";
echo "       Empty |";
echo $ts0[1] . '|';
echo $ts0[2] . '|';
echo $ts0[3] . '|';
echo $ts0[4] . "|\n";

echo "     Uniform |";
echo $ts1[1] . '|';
echo $ts1[2] . '|';
echo $ts1[3] . '|';
echo $ts1[4] . "|\n";

echo "     Integer |";
echo $ts2[1] . '|';
echo $ts2[2] . '|';
echo $ts2[3] . '|';
echo $ts2[4] . "|\n";

echo "      String |";
echo $ts3[1] . '|';
echo $ts3[2] . '|';
echo $ts3[3] . '|';
echo $ts3[4] . "|\n";

echo "       Mixed |";
echo $ts4[1] . '|';
echo $ts4[2] . '|';
echo $ts4[3] . '|';
echo $ts4[4] . "|\n";

echo " Associative |";
echo $ts5[1] . '|';
echo $ts5[2] . '|';
echo $ts5[3] . '|';
echo $ts5[4] . "|\n";

echo "-------------|--------------|--------------|--------------|--------------|\n";
echo "       Total |";
echo $ts6[1] . '|';
echo $ts6[2] . '|';
echo $ts6[3] . '|';
echo $ts6[4] . "|\n";

si vous devez vérifier le contenu du tableau, vous pouvez utiliser:

$arr = array();

if(!empty($arr)){
  echo "not empty";
}
else 
{
  echo "empty";
}

voir ici: http://codepad.org/EORE4k7v

À mon avis, le moyen le plus simple pour un tableau indexé serait simplement:

    if ($array) {
      //Array is not empty...  
    }

Une condition «if» sur le tableau serait évaluée à true si le tableau n'est pas vide et false si le tableau est vide . Cela ne s'applique pas aux tableaux associatifs.

J'utilise ce code

$variable = array();

if( count( $variable ) == 0 )
{
    echo "Array is Empty";
}
else
{
    echo "Array is not Empty";
}

Mais notez que si le tableau a un grand nombre de clés, ce code passera beaucoup de temps à les compter, par rapport aux autres réponses ici.

Vous pouvez utiliser array_filter()ce qui fonctionne très bien dans toutes les situations:

$ray_state = array_filter($myarray);

if (empty($ray_state)) {
    echo 'array is empty';
} else {
    echo 'array is not empty';
}

 $gamerow = mysql_fetch_array($gameresult);

if (!empty(($gamerow['players'])) {
   $playerlist = explode(",", $gamerow['players']);
}else{

  // do stuf if array is empty
}

Je pense que la meilleure façon de déterminer si le tableau est vide ou non est d'utiliser count () comme ceci:

if(count($array)) {
    return 'anything true goes here';
}else {
    return 'anything false'; 
}

Prendre la décision la plus appropriée nécessite de connaître la qualité de vos données et les processus à suivre.

1. Si vous allez disqualifier / ignorer / supprimer cette ligne, le premier point de filtrage devrait être dans la requête mysql.

   • WHERE players IS NOT NULL
   • WHERE players != ''
   • WHERE COALESCE(players, '') != ''
   • WHERE players IS NOT NULL AND players != ''
   • ... cela dépend en quelque sorte des données de votre magasin et il y aura d'autres façons, je m'arrêterai ici.

2. Si vous n'êtes pas sûr à 100% si la colonne existera dans le jeu de résultats, vous devez vérifier que la colonne est déclarée. Cela signifie appeler array_key_exists(), isset()ou empty()sur la colonne. Je ne vais pas prendre la peine de délimiter les différences ici (il y a d'autres pages SO pour cette ventilation, voici un début: 1 , 2 , 3 ). Cela dit, si vous n'êtes pas en contrôle total de l'ensemble de résultats, alors vous avez peut-être trop de «flexibilité» d'application et devriez repenser si le problème d'accéder potentiellement à des données de colonne inexistantes en vaut la peine. En effet, je dis que vous ne devriez jamais avoir besoin de vérifier si une colonne est déclarée - ergo vous ne devriez jamais avoir besoin empty()pour cette tâche. Si quelqu'un fait valoir queempty()est plus approprié, alors ils poussent leur propre opinion personnelle sur l'expressivité des scripts. Si vous trouvez que la condition dans # 5 ci-dessous est ambiguë, ajoutez un commentaire en ligne à votre code - mais je ne le ferais pas. L'essentiel est qu'il n'y a aucun avantage programmatique à effectuer l'appel de fonction.

3. Votre valeur de chaîne peut-elle contenir un 0que vous souhaitez juger vrai / valide / non vide? Si c'est le cas, il vous suffit de vérifier si la valeur de la colonne a une longueur.

   Voici une démo utilisant strlen(). Cela indiquera si la chaîne créera ou non des éléments de tableau significatifs si elle est éclatée.

4. Je pense qu'il est important de mentionner qu'en explosant sans condition, vous êtes GARANTI de générer un tableau non vide. Voici la preuve: Démo En d'autres termes, vérifier si le tableau est vide est complètement inutile - il sera non vide à chaque fois.

5. Si votre chaîne ne contiendra PAS POSSIBLEMENT une valeur nulle (parce que, disons, il s'agit d'un csv composé d'ID qui commencent à partir 1et ne font qu'augmenter), alors if ($gamerow['players']) {c'est tout ce dont vous avez besoin - fin de l'histoire.

6. ... mais attendez, que faites-vous après avoir déterminé le vide de cette valeur? Si vous avez quelque chose de down-script attendu $playerlist, mais que vous déclarez conditionnellement cette variable, vous risquez d'utiliser la valeur de la ligne précédente ou de générer à nouveau des notifications. Alors , avez - vous besoin de déclarer inconditionnellement $playerlistcomme quelque chose ? S'il n'y a pas de valeurs véridiques dans la chaîne, votre application bénéficie-t-elle de la déclaration d'un tableau vide? Les chances sont, la réponse est oui. Dans ce cas, vous pouvez vous assurer que la variable est de type tableau en retombant dans un tableau vide - de cette façon, peu importe si vous introduisez cette variable dans une boucle. Les déclarations conditionnelles suivantes sont toutes équivalentes.

   • `if ($ gamerow ['players']) {$ playerlist = explode (',', $ gamerow ['players']); } else {$ playerlist = []; }
   • $playerlist = $gamerow['players'] ? explode(',', $gamerow['players']) : [];

Pourquoi suis-je allé si loin pour expliquer cette tâche très fondamentale?

1. J'ai dénoncé presque toutes les réponses sur cette page et cette réponse est susceptible d'attirer des votes de vengeance (cela arrive souvent aux lanceurs d'alerte qui défendent ce site - si une réponse a des votes négatifs et aucun commentaire, soyez toujours sceptique).
2. Je pense qu'il est important que Stackoverflow soit une ressource fiable qui n'empoisonne pas les chercheurs avec des informations erronées et des techniques sous-optimales.
3. C'est ainsi que je montre à quel point je me soucie des futurs développeurs afin qu'ils apprennent le comment et le pourquoi au lieu de simplement nourrir une génération de programmeurs copier-coller.
4. J'utilise fréquemment d'anciennes pages pour fermer de nouvelles pages en double - c'est la responsabilité des vétérans volontaires qui savent comment trouver rapidement des doublons. Je ne peux pas me résoudre à utiliser une ancienne page avec des informations incorrectes / fausses / sous-optimales / trompeuses comme référence, car alors je rends activement service à un nouveau chercheur.

empty($gamerow['players'])

J'ai résolu ce problème avec le code suivant.

$catArray=array();                          

$catIds=explode(',',$member['cat_id']);
if(!empty($catIds[0])){
foreach($catIds as $cat_id){
$catDetail=$this->Front_Category->get_category_detail($cat_id);
$catArray[]=$catDetail['allData']['cat_title'];
}
echo implode(',',$catArray);
}

Cela semble fonctionner pour tous les cas

if(!empty(sizeof($array)))