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

playersestará vacía o será una lista separada por comas (o un valor único). ¿Cuál es la forma más sencilla de comprobar si está vacío? ¿Supongo que puedo hacerlo tan pronto como obtenga la $gameresultmatriz $gamerow? En este caso, probablemente sería más eficiente omitir la explosión $playerlistsi está vacía, pero por el bien del argumento, ¿cómo puedo verificar si una matriz también está vacía?

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

Jan 01 '70 08:01 aslum

Si solo necesita verificar si hay CUALQUIER elemento en la matriz, puede usar la matriz misma, debido a la imprecisión de PHP, o, si prefiere un enfoque más estricto, usar count():

if (!$playerlist) {
     // list is empty.
}
if (count($playerlist) === 0) {
     // list is empty.
}

Si necesita limpiar valores vacíos antes de verificar (generalmente se hace para evitar explodecadenas extrañas):

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

Feb 07 '2010 05:02 Tyler Carter

Una matriz vacía es falsa en PHP, por lo que ni siquiera es necesario utilizarla empty()como han sugerido otros.

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

PHP determina si una empty()variable no existe o tiene un valor falso (como ,,,, array()etc. ).0nullfalse

En la mayoría de los casos sólo querrás comprobarlo !$emptyVar. Úselo empty($emptyVar)si es posible que la variable no se haya configurado Y no desea activar un E_NOTICE; En mi opinión, esta es generalmente una mala idea.

Aug 30 '2012 01:08 Cobby

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

Notas principales:

PHP determinará que una matriz con una clave (o claves) NO está 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).

Entonces, verificar una matriz con empty()no solo le dice si tiene valores o no, sino que 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 utilizar.
Por ejemplo, una matriz tendrá claves cuando un usuario envíe su formulario HTML cuando cada campo del formulario tenga un nombre de matriz (es decir name="array[]"). Se producirá
una matriz no vacía para cada campo, ya que habrá valores clave incrementados automáticamente para la matriz de cada campo del formulario.

Tome estas matrices, 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 la matriz para las matrices anteriores, obtendrá lo siguiente:

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

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

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

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

ARRAY UNO:
$ArrayOne no está vacío

ARRAY DOS:
$ArrayTwo no está vacío

ARRAY TRES:
$ArrayThree no está vacío

Una matriz siempre estará vacía cuando la asigne pero no la use después, como por ejemplo:

$ArrayFour = array();

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

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

En este caso, puede realizar un bucle en 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 podría ser el mejor enfoque, pero como siempre depende de su entorno y de los requisitos exactos, así como de otras cosas como lo que hace actualmente con la matriz (si es que hace algo).

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

Usando 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. Las claves de matriz se conservan.

$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()de las tres matrices de ejemplo (creadas en el primer bloque de código de esta respuesta) da como resultado lo siguiente:

ARRAY UNO:
$arrayone no está vacío

ARRAY DOS:
$arraytwo no está vacío

ARRAY TRES:
$arraytres está vacío

Entonces, cuando no hay valores, haya claves o no, usar array_filter()para crear una nueva matriz y luego verificar si la nueva matriz está vacía muestra si había algún valor en la matriz original.
No es ideal y es un poco complicado, pero si tiene una matriz enorme 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 basarse en varios parámetros, en matrices pequeñas y grandes y cuando hay valores y no, etc.

Nov 24 '2013 17:11 James

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

Feb 07 '2010 05:02 Ignacio Vazquez-Abrams

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

count($arr) == 0: contar
empty($arr): vacío
$arr == []: comp
(bool) $arr: elenco

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 convertir a booleano es insignificante. He realizado esta prueba varias veces y parecen ser esencialmente equivalentes. El contenido de las matrices no parece jugar un papel significativo. Los dos producen resultados opuestos, pero la negación lógica apenas es suficiente para impulsar el casting a ganar la mayor parte del tiempo, por lo que personalmente prefiero estar vacío por razones de 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";

Jan 21 '2020 12:01 kaan_a