generate - php array key value

Comprobación de matrices vacías: contar frente a vacío

Question

Esta pregunta sobre '' Cómo saber si una matriz PHP está vacía '' me hizo pensar en esta pregunta

¿Hay alguna razón por la que el count deba usarse en lugar de estar empty para determinar si una matriz está vacía o no?

Mi pensamiento personal sería si los 2 son equivalentes para el caso de matrices vacías, debería usar empty porque da una respuesta booleana a una pregunta booleana. De la pregunta vinculada anteriormente, parece que count($var) == 0 es el método popular. Para mí, aunque técnicamente correcto, no tiene sentido. Por ejemplo, Q: $ var, ¿estás vacío? A: 7 . Hmmm ...

¿Hay alguna razón por la que deba usar el count == 0 lugar o solo una cuestión de gusto personal?

Como señalaron otros en los comentarios de una respuesta ahora eliminada, el count tendrá un impacto en el rendimiento para las matrices grandes porque tendrá que contar todos los elementos, mientras que las empty pueden detenerse tan pronto como sepan que no están vacías. Entonces, si dan los mismos resultados en este caso, pero el count es potencialmente ineficiente, ¿por qué alguna vez usaríamos count($var) == 0 ?

Answer 1

¿Hay alguna razón por la que el recuento deba usarse en lugar de estar vacío para determinar si una matriz está vacía o no?

Hay, cuando necesitas hacer algo en una matriz no vacía sabiendo su tamaño:

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

Pero no recomendaría usar count, a menos que esté 100% seguro de que lo que está contando es una matriz. Últimamente he estado depurando código, donde la función de error devolvía FALSE lugar de Empty Array, y lo que descubrí fue:

var_dump(count(FALSE));

salida:

int 1

Entonces desde entonces estoy usando empty o if(array() === $array) para asegurarme de que tengo una matriz que está vacía.

Answer 2

A veces, usar el vacío es una necesidad. Por ejemplo, este código:

$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 ejecuta este código de esta manera: http://phpfiddle.org/main/code/g9x-uwi

Obtienes esta salida:

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

Entonces, si count la salida global vacía, obtendrá un resultado incorrecto. Debes verificar si hay vacío.

De la documentación glob :

Devuelve una matriz que contiene los archivos / directorios coincidentes, una matriz vacía si ningún archivo coincide o FALSO en caso de error.
Nota: En algunos sistemas, es imposible distinguir entre una coincidencia vacía y un error.

También verifique esta pregunta: ¿Por qué contar (falso) devolver 1?

Answer 3

Alternativamente, puede convertir la variable como un booleano (implícita o explícitamente):

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

Este método genera un E_NOTICE si la variable no está definida, de manera similar a count() .

Para obtener más información, consulte la página Manual de PHP sobre comparaciones de tipos .

Answer 4

Creo que es solo preferencia personal. Algunas personas podrían decir que el empty es más rápido (por ejemplo, http://jamessocol.com/projects/count_vs_empty.php ), mientras que otros podrían decir que el count es mejor, ya que se creó originalmente para las matrices. empty es más general y se puede aplicar a otros tipos.

php.net da la siguiente advertencia para el count :

count () puede devolver 0 para una variable que no está establecida, pero también puede devolver 0 para una variable que se ha inicializado con una matriz vacía. Use isset () para probar si se establece una variable.

En otras palabras, si la variable no está configurada, recibirás un aviso de PHP diciendo que no está definido. Por lo tanto, antes de usar el count , sería preferible verificar la variable con isset . Esto no es necesario con el empty .

Answer 5

Dado que una variable analizada como negativa devolvería int(1) con count()

Prefiero ($array === [] || !$array) para probar una matriz vacía.

Sí, deberíamos esperar una matriz vacía, pero no deberíamos esperar una buena implementación en las funciones sin tipos de devolución forzada.

Ejemplos con count()

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

Answer 6

Espero que esto pueda ayudar a alguien a pesar de que ya ha sido respondida (y debatido algo). En mi propia situación, sé que todas mis matrices tienen 7 elementos (las comprobaciones se hicieron anteriormente en mi código) y estoy ejecutando un array_diff que, por supuesto, devuelve una matriz de cero cuando es igual.

Tenía 34 segundos para count y 17 segundos para empty . Ambos me dan los mismos cálculos, así que mi código todavía está bien.

Sin embargo, también puede probar el == o === como en PHP - Verifique si dos matrices son iguales . Lo mejor que diría es try count vs empty vs == empty array , luego ver cuál da tus mejores perfs. En mi caso, el count fue el más lento, así que estoy usando el empty ahora ... voy a verificar la serialize siguiente

Answer 7

Mi preferencia personal es más para codificar la elegancia (en relación con mi caso de uso específico). Estoy de acuerdo con Dan McG en cuanto a que count () no responde con el tipo de datos correcto (en este caso booleano) para la prueba en cuestión, lo que obliga al desarrollador a escribir más código para completar una declaración ''if''.

Si esto tiene algún impacto significativo en el rendimiento solo es debatible para arreglos extremadamente grandes (de los que probablemente no tendrá suficiente asignación de memoria de todos modos en la mayoría de las configuraciones).

Particularmente cuando se trata de la matriz $ _POST de PHP, parece mucho más "lógico" en mi opinión escribir / ver:

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

Answer 8

No hay una buena razón para preferir el count($myArray) == 0 sobre el empty($myArray) . Tienen una semántica idéntica. Algunos pueden encontrar uno más legible que el otro. Uno podría funcionar marginalmente mejor que el otro, pero no es probable que sea un factor significativo en la gran mayoría de las aplicaciones de PHP. Para todos los propósitos prácticos, la elección es una cuestión de gusto.

Answer 9

Por lo general, uso empty . No estoy seguro de por qué las personas usarían el conteo realmente. Si el conjunto es grande, el recuento demorará más / tendrá más sobrecarga. Si simplemente necesita saber si la matriz está vacía o no, utilice Empty.

Answer 10

Rehice mi mente chicos, gracias.

Ok, no hay diferencia entre el uso de empty y count . Técnicamente, count debe usarse para arrays, y empty podría usarse para arrays y strings. Entonces, en la mayoría de los casos, son intercambiables y si ves los documentos de php, verás la lista de sugerencias de count si estás empty y viceversa.

Answer 11

Tenía curiosidad por ver cuál era realmente más rápido, así que hice un guión simple para comparar esas funciones.

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

Como lo estaba haciendo, también traté de verificar el rendimiento haciendo operaciones que normalmente estarían asociadas con count () / empty ()

Usando 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

Usando 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

Conclusiones si estás usando PHP:

1. empty () es mucho más rápido que count () en ambos escenarios, con una matriz vacía y poblada

2. count () realiza lo mismo con una matriz completa o vacía.

3. Hacer un IF simple o simplemente una operación Boolean es lo mismo.

4. IF / ELSE es ligeramente más eficiente que (?:). A menos que estés haciendo miles de millones de iteraciones con expresiones en el medio, es completamente insignificante.

Conclusiones si estás usando HHVM:

1. empty () es un poco más rápido que count () pero insignificante.

   [El resto es lo mismo que en PHP]

Como conclusión de la conclusión, si solo necesita saber si la matriz está vacía, siempre use empty ();

Esta fue solo una curiosa prueba simplemente hecha sin tomar muchas cosas en cuenta. Es solo una prueba de concepto y podría no reflejar las operaciones en producción.

Answer 12

count() parece funcionar mejor con interfaces tipo array que implementan ArrayAccess/Countable . empty() devuelve verdadero para este tipo de objetos, incluso si no tienen elementos. Normalmente, estas clases implementarán la interfaz Countable , por lo que si la pregunta es "¿Esta colección contiene elementos?" sin hacer una suposición sobre la implementación, entonces count() es una mejor opción.