La vérification de tableaux vides: le comte vs vide

Cette question sur " laComment savoir si un tableau PHP est vide' m'a fait penser à cette question

Est-il une raison que count doit être utilisé au lieu de empty au moment de déterminer si un tableau est vide ou pas?

Ma pensée personnelle serait le cas si les 2 sont équivalents pour le cas de tableaux vides, vous devez utiliser empty parce qu'il donne une valeur booléenne réponse à un booléen question. À partir de la question ci-dessus, il semble que count($var) == 0 est la méthode populaire. Pour moi, bien que techniquement correct, n'a pas de sens. E. g. Q: $var, êtes vous vide? A: 7. Hmmm...

Est-il une raison que je devrais utiliser count == 0 au lieu de cela ou tout simplement une question de goût personnel?

Comme souligné par d'autres dans les commentaires pour maintenant supprimé réponse, count aura un impact sur les performances pour les grands tableaux, car il devra compter tous les éléments, tandis que empty pouvez arrêter dès qu'il sait qu'il n'est pas vide. Donc, si ils donnent les mêmes résultats dans le cas présent, mais count est potentiellement inefficace, pourquoi n'aurions-nous jamais utiliser count($var) == 0?

  • Je suis en supposant que votre intention est de limiter la conversation exclusivement à des tableaux, mais il pourrait être intéressant de noter que le jeu change du tout au tout si vous travaillez avec des objets (par exemple, qui mettent en œuvre Dénombrable, Itérateur, etc.).
  • Un tableau vide est égale à false en PHP, pas besoin de empty() ou count().
  • Le Code s'il vous plaît.
  • Comme dans, il suffit de faire: if (!$myArray) { echo "array is empty"; } sandbox.onlinephpfunctions.com/code/...
  • De nos jours, l'option populaire dans la question est à l'aide de empty().
InformationsquelleAutor Dan McGrath | 2010-02-07
  1. 91

    J'utilise généralement empty. Je ne sais pas pourquoi les gens utiliseraient comptent vraiment - Si le tableau est grand alors le comte prend plus de temps a plus de frais généraux. Si vous avez simplement besoin de savoir si le tableau est vide, puis utilisez vide.

    • Ces fonctions diffèrent en effet lorsque le tableau est pas vide.
    • Im ne conteste pas que. Mais si vous êtes entrain de tester son vide, je ne vois pas quel rapport a - une question avec un résultat booléen qui est ce que la fonction sera de retour. En ce qui concerne ce qui est considéré comme vide ne vois pas comment ces critères permettrait de produire de la mauvaise réponse, à moins que le var votre test n'est pas un tableau auquel cas c'est une tout autre question.
    • Je dirais que le comte est O(1), depuis PHP stocke le nombre d'éléments à l'interne. Découvrez cette réponse stackoverflow.com/a/5835419/592454
    • mais encore - même si il n'y a pas ou peu de différence dans la performance, pourquoi utiliser le comte, si vous n'avez pas besoin de les compter?
    • Bon point, merci.
    • aussi, à l'aide de count() avec des formes ayant plusieurs les entrées avec le même nom le comte champs vides, conduisant à des erreurs.
    • La raison en est simple. Cela dépend de ce que vous avez besoin. Principal problème, c'est que même tableau(0) ou array(") est considérée comme vide, cependant le comte retourne 1. La Question est, si vous voulez considérer cela comme vide, ou si vous voulez distinctes vraiment vide array d'array(0).
    • C'est la meilleure réponse pour la norme de tableaux, mais pas pour des collections d'une classe plus large d'objets.
    • empty() est trop indulgents à l'égard des erreurs. Je viens de passer 2 heures de débogage d'une sous-classe qui l'a testé empty() sur une variable membre privée de sa super-classe (le champ d'application de la super-classe de la variable membre DOIT avoir été protégé, mais vide() a renvoyé aucune erreur — le résultat a été tout simplement que quelque chose doit se passer, ce n'était pas le cas: la non-existence de la variable membre de la classe a été traité exactement de la même façon que si cette variable membre, un tableau, était vide à — dire, comme si elle n'avait pas d'éléments). C'est problématique, et un autre exemple de PHP d'être trop indulgent.
    • dans ce cas, je voudrais l'utiliser normalement isset($this->member) && !empty($this->member)
    • Vous ne voulez pas utiliser empty() parce que c'est de la merde. Trop indulgent, a un comportement étrange comme retourner false, même pour string('0'), etc. Si vous avez un tableau et que vous souhaitez vérifier si elle est vide, soit utiliser count() === 0 ce qui est bien lisible et plus claire ou - si vous absolument besoin de la vitesse - utilisation $array === [] (aka $array === array()) qui est presque aussi rapide que empty(). À l'aide de count() a, cependant, un avantage de plus - si vous décidez plus tard que vous souhaitez échanger votre tableau pour quelque chose de plus intelligent (comme dans l'objet de la mise en œuvre d'au moins Countable) vous n'aurez pas à changer quoi que ce soit.
    • Je viens de découvrir que count(0) === int(1). J'ai une fonction qui a retourné 0 au lieu d'une chaîne vide en cas d'erreur. Ce pourrait être la mise en œuvre de la faute, mais je m'attends à un "lâche l'égalité pour une chaîne vide (false)" sera count à 0. Peut-être que le mieux est $array === [] et n'utilisant aucun des deux
    • array(0) ou array(") est considérée comme vide": vous Ne savez pas à propos dans le passé, mais à vérifier avec le PHP 7.0, empty() renvoie la valeur false pour ces deux cas, comme prévu.

    InformationsquelleAutor prodigitalson
  2. 43

    J'étais curieux de voir qui était vraiment le plus rapide alors j'ai fait un simple script de test de ces fonctions.

    <?php
function benchmark($name, $iterations, $action){
$time=microtime(true);
for($i=0;$i<=$iterations;++$i){
$action();
}
echo $name . ' ' . round(microtime(true)-$time, 6) . "\n";
}
$iterations = 1000000;
$x = array();
$y = range(0, 10000000);
$actions = array(
"Empty empty()" => function() use($x){
empty($x);
},
"Empty count()" => function() use($x){
count($x);
},
"Full empty()" => function() use($y){
empty($y);
},
"Full count()" => function() use($y){
count($y);
},
############
"IF empty empty()" => function() use($x){
if(empty($x)){ $t=1; }
},
"IF empty count()" => function() use($x){
if(count($x)){ $t=1; }
},
"IF full empty()" => function() use($y){
if(empty($y)){ $t=1; }
},
"IF full count()" => function() use($y){
if(count($y)){ $t=1; }
},
############
"OR empty empty()" => function() use($x){
empty($x) OR $t=1;
},
"OR empty count()" => function() use($x){
count($x) OR $t=1;
},
"OR full empty()" => function() use($y){
empty($y) OR $t=1;
},
"OR full count()" => function() use($y){
count($y) OR $t=1;
},
############
"IF/ELSE empty empty()" => function() use($x){
if(empty($x)){ $t=1; } else { $t=2; }
},
"IF/ELSE empty count()" => function() use($x){
if(count($x)){ $t=1; } else { $t=2; }
},
"IF/ELSE full empty()" => function() use($y){
if(empty($y)){ $t=1; } else { $t=2; }
},
"IF/ELSE full count()" => function() use($y){
if(count($y)){ $t=1; } else { $t=2; }
},
############
"( ? : ) empty empty()" => function() use($x){
$t = (empty($x) ? 1 : 2);
},
"( ? : ) empty count()" => function() use($x){
$t = (count($x) ? 1 : 2);
},
"( ? : ) full empty()" => function() use($y){
$t = (empty($y) ? 1 : 2);
},
"( ? : ) full count()" => function() use($y){
$t = (count($y) ? 1 : 2);
}
);
foreach($actions as $name => $action){
benchmark($name, $iterations, $action);
}
//END

    Depuis que je le faisais j'ai aussi essayé de vérifier les performances de faire les opérations qui sont normalement associés avec count()/empty()

    À l'aide de PHP 5.4.39:

    Empty empty() 0.118691
Empty count() 0.218974
Full empty() 0.133747
Full count() 0.216424
IF empty empty() 0.166474
IF empty count() 0.235922
IF full empty() 0.120642
IF full count() 0.248273
OR empty empty() 0.123875
OR empty count() 0.258665
OR full empty() 0.157839
OR full count() 0.224869
IF/ELSE empty empty() 0.167004
IF/ELSE empty count() 0.263351
IF/ELSE full empty() 0.145794
IF/ELSE full count() 0.248425
( ? : ) empty empty() 0.169487
( ? : ) empty count() 0.265701
( ? : ) full empty() 0.149847
( ? : ) full count() 0.252891

    À l'aide de HipHop VM 3.6.1 (dbg)

    Empty empty() 0.210652
Empty count() 0.212123
Full empty() 0.206016
Full count() 0.204722
IF empty empty() 0.227852
IF empty count() 0.219821
IF full empty() 0.220823
IF full count() 0.221397
OR empty empty() 0.218813
OR empty count() 0.220105
OR full empty() 0.229118
OR full count() 0.221787
IF/ELSE empty empty() 0.221499
IF/ELSE empty count() 0.221274
IF/ELSE full empty() 0.221879
IF/ELSE full count() 0.228737
( ? : ) empty empty() 0.224143
( ? : ) empty count() 0.222459
( ? : ) full empty() 0.221606
( ? : ) full count() 0.231288

    Conclusions si vous utilisez PHP:

    1. empty() est beaucoup plus rapide que la fonction count() dans les deux scénarios, avec un vide et remplie tableau

    2. count() effectue le même avec une pleine ou vide.

    3. Faisant un simple SI ou tout simplement d'une opération Booléenne est le même.

    4. If/ELSE est très légèrement plus efficace que le ( ? : ). Sauf si vous êtes en train de faire des milliards d'itérations avec des expressions dans le milieu, il est totalement insignifiant.

    Conclusions si vous utilisez HHVM:

    1. empty() est une teeny-weeny peu plus rapide que la fonction count (), mais d'une manière insignifiante, donc.

      [ Le reste est le même que dans PHP ]

    En conclusion de la conclusion, si vous avez juste besoin de savoir si le tableau est vide toujours utiliser empty();

    C'était juste un curieux essai fait simplement, sans prendre beaucoup de choses en compte. C'est juste une preuve de concept et pourrait ne pas refléter les opérations de production.

    • Merci pour l'exemple de code de test.... Je l'ai peu utilisé et a constaté que if($x){ est plus rapide que if(empty($x)){ (fonctionne uniquement si vous savez que $x a été déclaré).
    InformationsquelleAutor Satake
  3. 15

    Je pense que c'est juste une préférence personnelle. Certaines personnes pourraient dire empty est plus rapide (par exemple,http://jamessocol.com/projects/count_vs_empty.php), tandis que d'autres pourraient dire count est mieux depuis qu'il a été à l'origine fait pour les tableaux. empty est plus générale et peut être appliquée à d'autres types.

    php.net donne l'avertissement suivant à count si :

    count() peut retourner 0 pour une variable qui n'est pas défini, mais il peut aussi retourner la valeur 0 pour une variable a été initialisée avec un tableau vide. Utiliser la fonction isset() pour tester si une variable est définie.

    En d'autres termes, si la variable n'est pas définie, vous recevrez un avis de PHP en disant que c'est pas défini. Par conséquent, avant d'utiliser count, il serait préférable de vérifier la variable avec isset. Ce n'est pas nécessaire avec empty.

    • Il est intéressant qu'un argument en faveur de count est qu'il a été à l'origine fait pour les tableaux... et pourtant, les objets peuvent mettre en œuvre Countable, et vous pouvez passer des valeurs scalaires à count() et d'obtenir un résultat valable.
    • count() peut return 0 pour une variable qui n'est pas défini, mais il peut aussi.... La documentation officielle à l'aide de verbes modaux pour exprimer son incertitude :p
    • Juste un commentaire sur le isset() point. Si vous êtes inquiet au sujet de avis en PHP, tu devrais déjà avoir déclaré votre tableau. Si vous laissez PHP dynamiquement déclarer votre tableau, vous obtenez un avis à ce point. Je pense que le vrai point de la mise en garde sur php.net c'est que vous ne devriez pas utiliser count pour déterminer si un tableau a été déclarée ou non car il donne le même résultat comme un tableau vide serait.
    InformationsquelleAutor Laurent le Beau-Martin
  4. 10

    Est-il une raison que le comte doit être utilisé au lieu de vide au moment de déterminer si un tableau est vide ou pas?

    Il est, quand vous avez besoin de faire quelque chose sur la non-vide en sachant qu'il est de taille:

    if( 0 < ( $cnt = count($array) ) )
{
echo "Your array size is: $cnt";
}
else
echo "Too bad, your array is empty :(";

    Mais je ne recommanderais pas à l'aide de compter, sauf si vous êtes sûr à 100%, que ce que vous êtes de comptage est un tableau. Dernièrement, j'ai été mise au point du code, où sur la fonction d'erreur est de retour FALSE au lieu de tableau vide, et de ce que j'ai découvert était:

    var_dump(count(FALSE));

    de sortie:

    int 1

    Donc, depuis lors, je suis en utilisant empty ou if(array() === $array) pour être sûr que j'ai tableau qui est vide.

    InformationsquelleAutor dev-null-dweller
  5. 6

    count() semble mieux travailler avec l'ensemble-comme des interfaces de mettre en œuvre ArrayAccess/Countable. empty() retourne true pour ces sortes d'objets, même si ils n'ont pas d'éléments. Généralement, ces classes permettent de mettre en œuvre les Countable interface, donc si la question est "est-ce de la collection contiennent des éléments?" sans faire d'hypothèse sur la mise en œuvre, puis count() est une meilleure option.

    • Voulez-vous dire "empty retourne false pour ces sortes d'objets, même si ils n'ont pas d'éléments"?
    • Oui. Il n'y a pas d'interface pour permettre à une classe pour définir si elle est "vide" ou pas. Et il n'aurait pas vraiment de sens d'en être un.
    • +1 à l'Aide de count serait un plus flexible et extensible solution si jamais il fait sens pour que votre code à accepter une collection mise en œuvre d'un "bien commun" de la sorte... de l'OMI qui pourrait être les seuls critères pertinents pour définir si vous utilisez count ou d'autres moyens...
    • L'énorme inconvénient de count() que de 7,2, c'est qu'il n'a plus vide de variables.
    InformationsquelleAutor Ryan
  6. 5

    Alternativement, vous pouvez lancer la variable booléenne (implicitement ou explicitement):

    if( $value )
{
//array is not empty
}
if( (bool) $value )
{
//array is still not empty
}

    Cette méthode génère un E_NOTICE si la variable n'est pas définie, de même pour count().

    Pour plus d'informations, voir le Manuel PHP de la page sur les comparaisons de type.

    • C'est la meilleure façon de le vérifier, utilisez uniquement empty() si vous êtes explicitement en essayant d'éviter le déclenchement d'une alerte de type E_NOTICE (qui est généralement une mauvaise idée, de l'OMI). De façon flagrante à l'aide de vide conduira à code bogué.
    InformationsquelleAutor
  7. 3

    Ma préférence personnelle est plus pour le codage de l'élégance (par rapport à mon cas d'utilisation). Je suis d'accord avec Dan McG en ce qui count() n'est pas de répondre avec le bon type de données (dans ce cas, boolean) pour le test en question de forcer les développeurs à écrire plus de code pour remplir une déclaration "if".

    Si cela a un impact important sur les performances est seulement discutable pour les très grandes matrices (dont vous n'aurez probablement pas assez de mémoire pour l'allocation de toute façon dans la plupart des configurations).

    En particulier quand il s'agit de PHP $_POST tableau, il semble beaucoup plus "logique" à mon avis, pour écrire à voir:

    if ( !empty ( $_POST ) ) {
//deal with postdata
}
    InformationsquelleAutor simonhamp
  8. 3

    Espère que cela peut aider quelqu'un, même s'il a déjà été répondu (et ont discuté des ce). Dans mon scénario, je sais que tous mes tableaux ont tous 7 éléments (vérifications ont été faites plus tôt dans mon code) et je suis de l'exécution d'une array_diff qui, bien sûr, retourne un tableau de zéro, lorsque l'égalité.

    J'ai eu 34 sec pour count et 17 sec pour empty. Les deux me donner les mêmes calculs pour que mon code est toujours bien.

    Cependant, vous pouvez également essayer les == ou === comme dans PHP - Vérifier si deux matrices sont égales. Le mieux que je voudrais dire, c'est essayer count vs empty vs == empty array, puis voir ce qui donne à votre propre meilleur perfs. Dans mon cas, count était le plus lent, de sorte je suis en utilisant empty maintenant... allons vérifier serialize prochaine

    InformationsquelleAutor xchiltonx
  9. 1

    Il n'y a aucune raison de préférer count($myArray) == 0 sur empty($myArray). Ils ont la même sémantique. Certains pourraient trouver un plus lisible que l'autre. On peut effectuer un peu meilleure que l'autre, mais il n'est pas susceptible d'être un facteur important dans la grande majorité des applications php. À toutes fins pratiques, le choix est une question de goût.

    • Ce sujet de la "performance" chose? À l'aide de l'explication de "pratique commerciale" conduit à de mauvaises habitudes. Utilisation count lorsque vous avez besoin de compter, utiliser empty lorsque vous avez besoin de vérifier si la collection est vide. Bien sûr il y a des cas limites comme les chaînes ou les valeurs null, mais le programmeur doit penser à son code. Vous pouvez être en désaccord, vous êtes autorisé à le faire.
    • quelques fois, avec count($montableau) si $montableau est un booleen comme une valeur FALSE, le comte ne fonctionne pas (testé sur php5.3).
    InformationsquelleAutor Asaph
  10. 1

    Parfois à l'aide de vide est un must. Par exemple ce code:

    $myarray = array();
echo "myarray:"; var_dump($myarray); echo "<br>";
echo "case1 count: ".count($myarray)."<br>";
echo "case1 empty: ".empty($myarray)."<br>";
$glob = glob('sdfsdfdsf.txt');
echo "glob:"; var_dump($glob); echo "<br>";
echo "case2 count: ".count($glob)."<br>";
echo "case2 empty: ".empty($glob);

    Si vous exécutez ce code comme ceci: http://phpfiddle.org/main/code/g9x-uwi

    Vous obtenez ce résultat:

    myarray:array(0) { } 
case1 count: 0
case1 empty: 1
glob:bool(false) 
case2 count: 1
case2 empty: 1

    Donc, si vous count le vide glob sortie vous mal sortie. Vous devriez vérifier le vide.

    De glob documentation:

    Retourne un tableau contenant les paires de fichiers/répertoires, un vide
    tableau si aucun nom de fichier correspond ou FALSE en cas d'erreur.

    Remarque: Sur certains systèmes, il
    est impossible de distinguer entre le vide de match et une erreur.

    Également vérifier à cette question:
    Pourquoi le comte(false) return 1?

    InformationsquelleAutor trante
  11. 0

    J'ai refait mon esprit les gars, merci.

    Ok, il n'y a pas de différence entre l'utilisation de empty et count. Techniquement, count doit être utilisé pour les tableaux, et empty pourrait être utilisé pour les tableaux ainsi que des chaînes de caractères. Donc, dans la plupart des cas, ils sont interchangeables et si vous voyez le php docs, vous verrez la liste de suggestion de count si vous êtes à empty et vice versa.

    InformationsquelleAutor Sarfraz
  12. 0

    Depuis une variable analysée comme négatif serait de retour int(1) avec count()

    Je préfère ($array === [] || !$array) de test pour un tableau vide.

    Oui, nous devrions nous attendre à un tableau vide, mais il ne faut pas s'attendre à une bonne mise en œuvre sur les fonctions sans retour forcé types.

    Exemples avec count()

    var_dump(count(0));
> int(1)
var_dump(count(false));
> int(1)
    InformationsquelleAutor Sdlion