¿Cómo verificar si una matriz está vacía usando PHP?

playersestará vacío o una lista separada por comas (o un solo valor). ¿Cuál es la forma más fácil de verificar si está vacío? ¿Asumo que puedo hacerlo tan pronto como busque la $gameresultmatriz $gamerow? En este caso, probablemente sería más eficiente omitir la explosión $playerlistsi está vacío, pero por razones de argumento, ¿cómo verificaría si una matriz también está vacía?

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

Si solo necesita verificar si hay CUALQUIER elemento en la matriz

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

Si necesita limpiar los valores vacíos antes de verificar (generalmente para evitar explodela aparición de cadenas extrañas):

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

Una matriz vacía es falsey en PHP, por lo que ni siquiera necesita usarla empty()como otros han sugerido.

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

PHP empty()determina si una variable no existe o tiene un valor Falsey- (como array(), 0, null, false, etc).

En la mayoría de los casos, solo desea verificar !$emptyVar. Úselo empty($emptyVar)si la variable puede no haber sido establecida Y NO va a activar un E_NOTICE; En mi opinión, esto es generalmente una mala idea.

Algunas respuestas decentes, pero solo pensé en expandirme un poco para explicar más claramente cuando PHP determina si una matriz está vacía.

Notas principales:

PHP determinará una matriz con una clave (o claves) como NO vacía .

Como los valores de la matriz necesitan claves para existir, tener valores o no en una matriz no determina si está vacía, solo si no hay claves (Y, por lo tanto, no hay valores).

Por lo tanto, verificar una matriz con empty()no solo le dice si tiene valores o no, le dice si la matriz está vacía y las claves son parte de una matriz.

Así que considere cómo está produciendo su matriz antes de decidir qué método de verificación usar.
Por ejemplo, una matriz tendrá claves cuando un usuario envíe su formulario HTML cuando cada campo de formulario tenga un nombre de matriz (es decir name="array[]").
Se generará una matriz no vacía para cada campo, ya que habrá valores clave de incremento automático para la matriz de cada campo de formulario.

Tome estos arreglos por ejemplo:

/* 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 repite las claves y los valores de las matrices anteriores, obtendrá lo siguiente:

ARRAY ONE:
[UserKeyA] => [UserValueA]
[UserKeyB] => [UserValueB]

ARRAY TWO:
[0] => [UserValue01]
[1] => [UserValue02]

ARRAY TRES:
[0] => []
[1] => []

Y probar las matrices anteriores con empty()devuelve los siguientes resultados:

ARRAY ONE:
$ ArrayOne no está vacío

ARRAY TWO:
$ ArrayTwo no está vacío

ARRAY THREE:
$ ArrayThree no está vacío

Una matriz siempre estará vacía cuando asigne una matriz, pero no la use a partir de entonces, como por ejemplo:

$ArrayFour = array();

Esto estará vacío, es decir, PHP devolverá VERDADERO cuando se use if empty()en lo anterior.

Entonces, si su matriz tiene claves, ya sea por ejemplo, por los nombres de entrada de un formulario o si los asigna manualmente (es decir, cree una matriz con nombres de columnas de la base de datos como las claves pero sin valores / datos de la base de datos), entonces la matriz NO lo será empty().

En este caso, puede recorrer la matriz en un foreach, probando si cada clave tiene un valor. Este es un buen método si necesita ejecutar la matriz de todos modos, tal vez verificando las claves o desinfectando los datos.

Sin embargo, no es el mejor método si simplemente necesita saber "si existen valores" devuelve VERDADERO o FALSO . Existen varios métodos para determinar si una matriz tiene algún valor cuando se sabe que tendrá claves. Una función o clase puede ser el mejor enfoque, pero como siempre depende de su entorno y requisitos exactos, así como de otras cosas como lo que hace actualmente con la matriz (si corresponde).

Aquí hay un enfoque que usa muy poco código para verificar si una matriz tiene valores:

Uso array_filter():
Itera sobre cada valor en la matriz pasándolos a la función de devolución de llamada. Si la función de devolución de llamada devuelve verdadero, el valor actual de la matriz se devuelve a la matriz de resultados. Se conservan las claves de matriz.

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

La ejecución array_filter()en las tres matrices de ejemplo (creadas en el primer bloque de código en esta respuesta) da como resultado lo siguiente:

ARRAY ONE:
$ arrayone no está vacío

ARRAY TWO:
$ arraytwo no está vacío

ARRAY TRES:
$ arraythree está vacío

Entonces, cuando no hay valores, ya sea que haya claves o no, el uso array_filter()para crear una nueva matriz y luego verificar si la nueva matriz está vacía muestra si hubo valores en la matriz original.
No es ideal y un poco desordenado, pero si tiene una gran matriz y no necesita recorrerla por ningún otro motivo, entonces este es el más simple en términos de código necesario.

No tengo experiencia en verificar gastos generales, pero sería bueno saber las diferencias entre usar array_filter()y foreachverificar si se encuentra un valor.

Obviamente, el punto de referencia debería estar en varios parámetros, en matrices pequeñas y grandes y cuando hay valores y no, etc.

count($gamerow['players']) será 0.

Si desea determinar si la variable que está probando es realmente una matriz vacía, puede usar algo como esto:

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

Si desea excluir las filas falsas o vacías (como 0 => ''), donde el uso empty()fallará, puede intentar:

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

array_filter(): Si no se proporciona devolución de llamada, se eliminarán todas las entradas de la matriz igual a FALSO (consulte la conversión a booleana).

Si desea eliminar todas las cadenas NULL, FALSE y empty ( ''), pero deja valores cero ( 0), puede usarlas strlencomo callback, por ejemplo:

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

¿Por qué nadie ha dicho esta respuesta?

$array = [];

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

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

is_array

Ejecuté el punto de referencia incluido al final de la publicación. Para comparar los métodos:

• count($arr) == 0 : cuenta
• empty($arr) : vacío
• $arr == [] : comp
• (bool) $arr : emitir

y obtuve los siguientes resultados

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 diferencia entre vaciar y lanzar a un booleano es insignificante. He ejecutado esta prueba varias veces y parecen ser esencialmente equivalentes. El contenido de las matrices no parece jugar un papel importante. Los dos producen los resultados opuestos, pero la negación lógica es apenas suficiente para impulsar el lanzamiento a ganar la mayor parte del tiempo, por lo que personalmente prefiero vacío en aras de la legibilidad en cualquier caso.

#!/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 va a verificar el contenido de la matriz que puede usar:

$arr = array();

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

ver aquí: http://codepad.org/EORE4k7v

En mi opinión, la forma más simple para una matriz indexada sería simplemente:

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

Una condición 'if' en la matriz se evaluaría como verdadera si la matriz no está vacía y falsa si la matriz está vacía . Esto no es aplicable a las matrices asociativas.

Yo uso este codigo

$variable = array();

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

Pero tenga en cuenta que si la matriz tiene una gran cantidad de claves, este código pasará mucho tiempo contándolas, en comparación con las otras respuestas aquí.

Puede usar array_filter()cuál funciona muy bien para todas las situaciones:

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

Creo que la mejor manera de determinar si la matriz está vacía o no es usar count () de esta manera:

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

Tomar la decisión más adecuada requiere conocer la calidad de sus datos y qué procesos seguir.

1. Si va a descalificar / ignorar / eliminar esta fila, entonces el primer punto de filtración debe estar en la consulta mysql.

   • WHERE players IS NOT NULL
   • WHERE players != ''
   • WHERE COALESCE(players, '') != ''
   • WHERE players IS NOT NULL AND players != ''
   • ... depende de los datos de su tienda y habrá otras formas, me detendré aquí.

2. Si no está 100% seguro de si la columna existirá en el conjunto de resultados, debe verificar que la columna esté declarada. Esto significa llamar array_key_exists(), isset()o empty()en la columna. No voy a molestarme en delinear las diferencias aquí (hay otras páginas SO para ese desglose, aquí hay un comienzo: 1 , 2 , 3 ). Dicho esto, si no tiene el control total del conjunto de resultados, entonces quizás haya sobrecargado la "flexibilidad" de la aplicación y deba repensar si vale la pena el problema de acceder potencialmente a datos de columna inexistentes. Efectivamente, estoy diciendo que nunca debería necesitar verificar si se declara una columna; ergo, nunca debería necesitar empty()para esta tarea. Si alguien está discutiendo esoempty()es más apropiado, entonces están presionando su propia opinión personal sobre la expresividad de los scripts. Si encuentra que la condición en el n. ° 5 a continuación es ambigua, agregue un comentario en línea a su código, pero no lo haría. La conclusión es que no hay una ventaja programática para realizar la llamada a la función.

3. ¿Podría su valor de cadena contener un valor 0que desea considerar verdadero / válido / no vacío? Si es así, solo necesita verificar si el valor de la columna tiene longitud.

   Aquí hay una demostración usando strlen(). Esto indicará si la cadena creará o no elementos de matriz significativos si explota.

4. Creo que es importante mencionar que al explotar incondicionalmente, está GARANTIZADO de generar una matriz no vacía. Aquí está la prueba: Demostración En otras palabras, verificar si la matriz está vacía es completamente inútil; siempre estará no vacía.

5. Si su cadena NO POSIBLEMENTE contendrá un valor cero (porque, por ejemplo, este es un csv que consta de identificadores que comienzan desde 1y solo se incrementan), entonces if ($gamerow['players']) {es todo lo que necesita: fin de la historia.

6. ... pero espera, ¿qué haces después de determinar el vacío de este valor? Si tiene algo de script descendente que está esperando $playerlist, pero declara condicionalmente esa variable, entonces se arriesga a usar el valor de la fila anterior o generar nuevamente Avisos. Entonces, ¿necesitas declarar incondicionalmente $playerlistcomo algo ? Si no hay valores verdaderos en la cadena, ¿se beneficia su aplicación de declarar una matriz vacía? Lo más probable es que la respuesta sea sí. En este caso, puede asegurarse de que la variable sea del tipo de matriz volviendo a una matriz vacía; de esta manera, no importará si alimenta esa variable en un bucle. Las siguientes declaraciones condicionales son todas equivalentes.

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

¿Por qué me he tomado tanto tiempo para explicar esta tarea tan básica?

1. He denunciado casi todas las respuestas en esta página y es probable que esta respuesta obtenga votos de venganza (esto sucede a menudo a los denunciantes que defienden este sitio; si una respuesta tiene votos negativos y no hay comentarios, sea siempre escéptico).
2. Creo que es importante que Stackoverflow sea un recurso confiable que no envenene a los investigadores con información errónea y técnicas subóptimas.
3. Así es como muestro cuánto me importan los futuros desarrolladores para que aprendan cómo y por qué, en lugar de simplemente alimentar a una generación de programadores de copiar y pegar.
4. Frecuentemente uso páginas antiguas para cerrar nuevas páginas duplicadas; esto es responsabilidad de los voluntarios veteranos que saben cómo encontrar duplicados rápidamente. No puedo usar una página antigua con información mala / falsa / subóptima / engañosa como referencia porque entonces estoy haciendo un mal servicio a un nuevo investigador.

empty($gamerow['players'])

He resuelto este problema con el siguiente código.

$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);
}

Esto parece funcionar para todos los casos

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

Qué tal si:

DepartmentPerSchool = array ();
(vacío (is_array ($ DepartmentPerSchool)))? $ DepartmentPerSchool // o echo no está vacío: array ('not set' => 'Not set. Contact Admin'); // o echo está vacío