Vérification des tableaux vides: count vs empty

j'étais curieux de voir lequel était en fait plus rapide, donc j'ai fait un script simple pour comparer 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 en effectuant des opérations qui seraient normalement associées à count () / empty ()

utilisant 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

utilisant 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. faire une opération simple si ou juste une opération booléenne est la même.

4. if/ELSE est très légèrement plus efficace que le ( ? : ). Sauf vous faites des milliards d'itérations avec des expressions au milieu, c'est complètement 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.

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

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

c'était juste un curieux test fait sans tenir compte de beaucoup de choses. Il s'agit simplement d'une validation de principe qui pourrait ne pas refléter les opérations de production.

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

php.net donne l'avertissement suivant pour count cependant:

count() peut retourner 0 pour un variable qui n'est pas définie, mais qui peut aussi retourner 0 pour une variable qui a été initialisée avec un tableau vide. Utilisez 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 disant qu'elle n'est pas définie. Par conséquent, avant d'utiliser count , il serait préférable de vérifier la variable isset . Ce n'est pas nécessaire avec empty .

y a-t-il une raison pour que count soit utilisé au lieu de empty pour déterminer si un tableau est vide ou non?

il y a, quand vous avez besoin de faire quelque chose sur le tableau non vide sachant que c'est la taille:

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

mais je ne recommande pas d'utiliser count, sauf si vous êtes sûr à 100%, que ce que vous comptez est un tableau. Dernièrement j'ai débogué du code, où sur la fonction d'erreur retournait FALSE à la place de tableau vide, et ce que j'ai découvert était:

var_dump(count(FALSE));

sortie:

int 1

donc depuis lors j'utilise empty ou if(array() === $array) pour être sûr que j'ai tableau qui est vide.

alternativement, vous pouvez lancer la variable comme un booléen (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 la même façon que count() .

pour plus d'informations, voir la page du manuel PHP sur les comparaisons de type .

count() semble mieux fonctionner avec des interfaces de type tableau qui implémentent ArrayAccess/Countable . empty() retourne true pour ces sortes d'objets, même si ils n'ont pas d'éléments. Typiquement, ces classes vont implémenter l'interface Countable , donc si la question Est " cette collection contient-elle des éléments?"sans faire une hypothèse sur la mise en œuvre, alors count() est une meilleure option.

ma préférence personnelle est plus pour l'élégance de codage (en relation avec mon cas d'utilisation spécifique). Je suis D'accord avec Dan McG dans la mesure où count() ne répond pas avec le type de données correct (dans ce cas booléen) pour le test en question forçant le développeur à écrire plus de code pour remplir une déclaration "si".

si cela a un impact significatif sur la performance est seulement discutable pour des tableaux extrêmement grands (que vous n'aurez probablement pas assez d'allocation de mémoire pour de toute façon dans la plupart des configurations).

particulièrement quand il s'agit du tableau $_POST de PHP, il semble beaucoup plus "logique" à mon avis d'écrire/ voir:

if ( !empty ( $_POST ) ) {
    // deal with postdata
}

J'espère que cela pourrait aider quelqu'un même si cela a déjà été répondu (et discuté de quelque chose). Dans mon propre scénario, je sais que tous mes tableaux ont 7 éléments (les vérifications ont été faites plus tôt dans mon code) et je réalise un array_diff qui retourne naturellement un tableau de zéro quand égal.

j'ai eu 34 sec pour count et 17 sec pour empty . Les deux me donnent les mêmes calculs pour que mon code soit encore correct.

comme vous pouvez essayez aussi le == ou === comme dans PHP - vérifiez si deux tableaux sont égaux . Le mieux que je dirais est d'essayer count vs empty vs == empty array , puis voir ce qui donne vos propres meilleurs perfs. Dans mon cas count était le plus lent ainsi j'utilise empty maintenant ... va vérifier serialize suivant

il n'y a aucune raison de préférer count($myArray) == 0 à empty($myArray) . Ils ont la même sémantique. Certains pourraient trouver un plus lisible que l'autre. L'une pourrait être légèrement meilleure que l'autre, mais ce n'est probablement pas un facteur significatif dans la grande majorité des applications php. À toutes fins pratiques, le choix est une question de goût.

utiliser parfois 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 utilisez 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 la sortie glob vide vous obtenez la mauvaise sortie. Vous devriez vérifier le vide.

à Partir de glob de la documentation:

retourne un tableau contenant les fichiers/répertoires appariés, un empty tableau si aucun fichier ne correspond ou FALSE sur erreur.

Remarque: Sur certains systèmes, il il est impossible de distinguer une correspondance vide d'une erreur.

aussi vérifier cette question: Pourquoi le comte(false) return 1?

j'ai refait mes esprits, merci.

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

Puisqu'une variable considérée comme négative retournerait int(1) avec count()

je préfère ($array === [] || !$array) pour tester un tableau vide.

Oui, nous devrions nous attendre à un tableau vide, mais nous ne devrions pas nous attendre à une bonne implémentation sur les fonctions sans types de retour forcé.

exemples avec count()

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