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

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

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

preguntado el 07 de febrero de 10 a las 02:02

20 Respuestas

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 se hace para evitar explodeing cuerdas extrañas):

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

contestado el 18 de mayo de 16 a las 18:05

¿No deberías usar vacío? El recuento tardará más en realizarse para matrices grandes. - dan mcgrath

Hecho. También lo cambié por el hecho de que no tienes que usar isset y demás. - tyler carter

Dado su ejemplo de código, la variable se establecerá para que no necesite usar empty(). - De altura baja

¡CUIDADO! if(!isset($emptyarray)) is false pero if(empty($emptyarray)) devoluciones true. Eso solo me clavó Cañón de Kolob

@Kolob Canyon ... ¿qué esperabas? (asumiendo que realmente definiste una matriz ...). Para mí tiene sentido que algo se pueda 'configurar' y estar 'vacío'. - McAuley

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

<?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 falso (como array(), 0, null, falseEtc.).

En la mayoría de los casos, solo desea verificar !$emptyVar. Utilizar empty($emptyVar) si es posible que no se haya establecido la variable Y no se suele activar una E_NOTICE; En mi opinión, esto es generalmente una mala idea.

Respondido 11 Abr '17, 04:04

Espero que esto no cambie en algún estándar ... será doloroso - David Constantino

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


Notas principales:

Una matriz con una clave (o claves) se determinará como No vacío por PHP.

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, verificando una matriz con empty() no le dice simplemente 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 tener claves cuando un usuario envía su formulario HTML cuando cada campo de formulario tiene un nombre de matriz (es decir, name="array[]").
A no vacio Se producirá una matriz para cada campo, ya que habrá valores clave incrementados automáticamente para la matriz de cada campo de 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 de matriz y los valores de las matrices anteriores, obtiene lo siguiente:

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

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

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

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

ARRAY UNO:
$ ArrayOne no está vacío

MATRIZ DOS:
$ ArrayTwo no está vacío

MATRIZ TRES:
$ 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á TRUE cuando se use si empty() en lo anterior.

Entonces, si su matriz tiene claves, ya sea por ejemplo, los nombres de entrada de un formulario o si las asigna manualmente (es decir, crea una matriz con los nombres de columna 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 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 los valores existen. VERDADERO or 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 los requisitos exactos, así como de otras cosas, como lo que hace actualmente con la matriz (en todo caso).


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

Usar array_filter():
Repite cada valor de la matriz y los pasa 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
  }

Running 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 UNO:
$ arrayone no está vacío

MATRIZ DOS:
$ arraytwo no está vacío

MATRIZ TRES:
$ arraythree está vacío

Entonces, cuando no hay valores, ya sea que haya claves o no, usando 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 está un poco desordenado, 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 la verificación de gastos generales, pero sería bueno conocer las diferencias entre el uso de array_filter() y foreach comprobar si se encuentra un valor.

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

respondido 24 nov., 13:17

Muchas gracias por todo. Fue realmente informativo y pude resolver mi problema usando array_filter() - Brian Powell

vacío (matriz ()) siempre evaluará a FALSO, por lo que agregar count (matriz ()) == 0 producirá verdadero - timmz

@mboullouz count(array())==0 es falso cuando hay claves y no hay valores, por lo que esto no ayuda a verificar solo los valores. Su declaración es correcta, pero está forzando una prueba con count(array()) ya que, por supuesto, la matriz está vacía. Necesitamos verificar cuándo la matriz ha regresado de un formulario o de algún otro lugar para saber si está vacía (claves / valores) o simplemente tiene valores o no - James

Esta solución es perfecta para este tipo de matrices, por ejemplo, ayuda cuando desea validar un archivo de entrada. array_filter($_FILES["documento"]['name']) - Gendrith

Respondido 07 Feb 10, 05:02

la vieja escuela da lo mejor como siempre, solo verifique el índice de la matriz. - Danés

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

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

Respondido 25 ago 16, 02:08

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

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

array_filter(): Si no se proporciona ninguna devolución de llamada, se eliminarán todas las entradas de la matriz iguales a FALSE (ver conversión a booleano).

Si desea eliminar todas las cadenas NULL, FALSE y vacías (''), pero deje valores cero (0), puedes usar strlen como devolución de llamada, por ejemplo:

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

Respondido 31 Oct 18, 15:10

Ésta es la respuesta correcta a otra pregunta. El uso de un filtro de matriz destruirá los elementos existentes con valores falsos. Esto no es lo que pide el OP. - mickmackusa

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 == [] : borrador
  • (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 vacío y conversión 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 los resultados opuestos, pero la negación lógica es apenas suficiente para impulsar el casting 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";

Respondido el 21 de enero de 20 a las 14:01

Buen punto de referencia, pero lo olvidaste sizeof que es [no?] alias de empty... stackoverflow.com/a/51986794/1429432 - Yousha Aleayoub

FYI: Cuando ejecuté este punto de referencia usando PHP 7.4, obtuve resultados diferentes que indicaron que la comparación fue la más rápida. - nick merill

Realmente deberías estar usando === en lugar de ==. - Mente

¿Por qué nadie ha dicho esta respuesta?

$array = [];

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

respondido 11 nov., 17:06

Tu declaración no es correcta. Alguien dijo esta respuesta, Tim Ogilvy, un año antes. Usar llaves en lugar de array() es lo mismo. - mickmackusa

Mientras que bajo el capó es la misma respuesta ... técnicamente. Usé los corchetes en lugar de la función de matriz obsoleta. - Robar

Si usa este enfoque, también debe usar === en lugar de ==, ya que es más rápido. - Mente

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

es_matriz

Respondido 05 Oct 13, 00:10

Estos son controles innecesarios. El OP está llamando explode() : devuelve datos de tipo matriz. Comprobación empty() es una llamada de función innecesaria. Como dijo Cobby en 2012, if($detect) es todo lo que se requiere. Esta solución no debe implementarse para esta tarea u otras. Podría argumentar que está cubriendo situaciones más allá del alcance de esta pregunta, bueno, nunca es necesario llamar empty() DESPUÉS DE is_array() porque si la variable no está "configurada", entonces is_array() generará "Aviso: variable no definida", si isset() luego empty() es exagerado, solo usa la respuesta de Cobby. - mickmackusa

@mickmackusa ¿qué pasa si la variable está configurada (en una matriz vacía)? Tal vez desee verificar si los datos que va a evaluar son incluso una matriz y luego desea verificar si están vacíos o no. - Me esfuerzo mucho pero lloro más fuerte

@Intente nuevamente, si desea verificar si una variable declarada es una matriz y no está vacía, entonces esto es todo lo que se requiere: if (is_array($detect) && $detect) Si deseas fuerza una variable para que sea una matriz, luego puede convertirla como una matriz (lo que dejará una matriz como está, convertirá el primer nivel de un objeto en una matriz y convertirá cualquier valor escalar en una matriz de un solo elemento que contenga el valor) $detect = (array)$detect; if ($detect) - mickmackusa

si va a verificar el contenido de la matriz, puede usar:

$arr = array();

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

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

Respondido 22 Abr '15, 08:04

Como lo mostró Cobby en 2012, no es necesario llamar a una función para verificar si una matriz declarada está vacía o no. - mickmackusa

@mickmackusa No estoy de acuerdo contigo aquí. Siguiendo esa lógica, podríamos disolver empty (), ya que empty comprueba si una variable está configurada y si el valor es falso o no. Algunas personas prefieren crear la sobrecarga (apenas perceptible) para facilitar la lectura. - Me esfuerzo mucho pero lloro más fuerte

Si prefiere un estilo de codificación declarativa, use empty(). Mi punto es que no es necesario. - mickmackusa

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

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

Una condición 'si' en la matriz se evaluaría como verdadero si la matriz no está vacía y falso si la matriz está vacía. Es no aplicable a matrices asociativas.

Respondido 03 Abr '19, 18:04

Cobby declaró efectivamente esta técnica en 2012. Su respuesta actualmente tiene 133 votos a favor. - mickmackusa

Esto no es "más simple" como una cuestión de opinión, es más simple porque no hay una sintaxis que pueda ser más concisa y esto no tiene una sobrecarga de llamadas a funciones. NO HAY ABSOLUTAMENTE NINGUNA DIFERENCIA al acceder a una matriz con claves indexadas versus claves asociativas. Esta respuesta induce a error a los investigadores. Esta respuesta es redundante, entonces incorrecto. 3v4l.org/DSLha - mickmackusa

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í.

respondido 04 mar '16, 18:03

Como lo mostró Cobby en 2012, no es necesario llamar a una función para verificar si una matriz declarada está vacía o no. - mickmackusa

@mickmackusa No estoy de acuerdo contigo aquí. Siguiendo esa lógica, podríamos disolver empty (), ya que empty comprueba si una variable está configurada y si el valor es falso o no. Algunas personas prefieren crear la sobrecarga (apenas perceptible) para mejorar la legibilidad: Me esfuerzo mucho pero lloro más fuerte

Si prefiere un estilo de codificación declarativa, use count(). Mi punto es que no es necesario. - mickmackusa

Puedes usar array_filter() que 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';
}

Respondido 06 ago 18, 22:08

Esta respuesta está empleando controles innecesarios. En primer lugar, el OP no está interesado en filtrar ningún valor falso de la matriz antes de verificar su vacío, por lo que se ha desviado de la pregunta publicada. En segundo lugar, como lo mostró Cobby en 2012, no es necesario llamar a una función para verificar si una matriz declarada está vacía o no. - mickmackusa

@mickmackusa No estoy de acuerdo contigo aquí. Siguiendo esa lógica, podríamos disolver empty (), ya que empty comprueba si una variable está configurada y si el valor es falso o no. Algunas personas prefieren crear la sobrecarga (apenas perceptible) para mejorar la legibilidad: Me esfuerzo mucho pero lloro más fuerte

Si prefiere un estilo de codificación declarativa, use empty(). Mi punto es que no es necesario. - mickmackusa

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

  1. Si va a descalificar / ignorar / eliminar esta fila, entonces el primer punto de filtrado debe estar en la consulta de 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í.
  1. Si no está 100% seguro de si la columna existirá en el conjunto de resultados, debe verificar que la columna esté declarada. Esto significará llamar array_key_exists(), isset()o empty() en la columna. No me voy a molestar 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 tal vez tenga una "flexibilidad" excesiva en la aplicación y debería reconsiderar si vale la pena el problema de acceder potencialmente a datos de columna inexistentes. Efectivamente, estoy diciendo que nunca debería necesitar verificar si una columna está declarada; ergo, nunca debería necesitar empty() para esta tarea. Si alguien está argumentando que empty() es más apropiado, entonces están impulsando su propia opinión personal sobre la expresividad del guión. 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 yo no lo haría. La conclusión es que no hay ninguna ventaja programática al realizar la llamada a la función.

  2. ¿Podría el valor de su cadena contener un 0 que 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 Demo usar strlen(). Esto indicará si la cadena creará elementos de matriz significativos si se desglosa.

  1. Creo que es importante mencionar que al explotar incondicionalmente, está GARANTIZADO de generar una matriz no vacía. Aquí tienes la prueba: Demo En otras palabras, comprobar si la matriz está vacía es completamente inútil: no estará vacía cada vez.

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

  3. ... pero espera, ¿qué haces después de determinar el vacío de este valor? Si tiene algo en el guión que espera $playerlist, pero está declarando condicionalmente esa variable, entonces corre el riesgo de usar el valor de la fila anterior o volver a generar Avisos. Entonces, ¿necesitas declarar incondicionalmente? $playerlist as algo? Si no hay valores veraces en la cadena, ¿su aplicación se beneficia al 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 de tipo matriz volviendo a una matriz vacía; de esta manera, no importará si introduce esa variable en un bucle. Las siguientes declaraciones condicionales son todas equivalentes.

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

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

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

respondido 19 nov., 20:00

@ptr está aquí. - mickmackusa

 $gamerow = mysql_fetch_array($gameresult);

if (!empty(($gamerow['players'])) {
   $playerlist = explode(",", $gamerow['players']);
}else{

  // do stuf if array is empty
}

Respondido el 23 de diciembre de 16 a las 06:12

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

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

respondido 20 nov., 17:19

El count() la llamada se puede eliminar por completo; consulte la respuesta de Cobby. - mickmackusa

empty($gamerow['players'])

Respondido 07 Feb 10, 05:02

algunas veces no puedes saber el valor de la clave de la matriz de elementos $matches = preg_grep ( "/^$text (\w+)/i" , $array ) ; para comprobarlo utilizo if ( count ( $matches ) > 0 ) - Salem

Se supone que la columna existe en el conjunto de resultados, por lo que empty() está haciendo demasiado trabajo. - mickmackusa

@Salem, solía hacer lo mismo (es decir, 'contar') hasta que me convertí a PHP 7.2 .x. A pesar de la "regla" de que las versiones menores no deben implementar cambios retroactivos, esta versión de php lanza una advertencia cuando "count ($ myArray)" se realiza en una matriz vacía. Eso causa problemas (al menos en mi código, y sé que algunos marcos lo "actualizarán" a una excepción). Así que tenga en cuenta este "gotcha" de php. Ahora, tengo que lanzar mis matrices ((matriz) $ myArray aunque ya está definida como una matriz. Raro y tonto, en mi opinión. - McAuley

$status = "";

$new_array = array();

if(!empty($new_array)){
  $status = "1";   // not a blank array
}
else{
  $status = "0";   // blank array
}

Respondido 10 ago 20, 10:08

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

respondido 20 mar '18, 04:03

¡Bienvenido a Stack Overflow! Gracias por el fragmento de código, que puede proporcionar ayuda inmediata y limitada. Una explicación adecuada mejoraría enormemente su valor a largo plazo describiendo por qué esta es una buena solución al problema y lo haría más útil para futuros lectores con otras preguntas similares. Edite su respuesta para agregar alguna explicación, incluidas las suposiciones que hizo. - Sepehr

Esto parece funcionar para todos los casos.

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

Respondido el 13 de junio de 18 a las 14:06

Esto tiene demasiados gastos generales. Esta solución no debe ser implementada por ningún desarrollador por ningún motivo. - mickmackusa

@mickmackusa Gran punto, pero ¿cómo aprende un novato a identificar qué operaciones suponen demasiada sobrecarga? ¿Cuál es el obsequio o cuál es el valor nominal criterios para demasiada sobrecarga sin ejecutar pruebas de rendimiento? - ptrcao

@ptr hay un "costo" para cada llamada de función. Si una tarea se puede completar sin una llamada de función, superará a una técnica que usa una llamada de función. - mickmackusa

@ptr He publicado una respuesta completa para esta pregunta. Espero que aclare cualquier inquietud que tenga sobre esta página en particular. - mickmackusa

@mickmackusa ¿Querías incluir un enlace a otra publicación? - ptrcao

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.