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


471

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']);

2
No use count (), sizeof (), empty (). Matriz vacía devuelve falso: if ($ matriz) {
Limitrof

Respuestas:


774

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
}

2
¿No deberías usar vacío? el recuento tardará más en realizarse para matrices grandes.
Dan McGrath

1
Hecho. También lo cambié por el hecho de que no tienes que usar isset y esas cosas.
Tyler Carter

55
Dado su ejemplo de código, la variable se establecerá para que no necesite usarla empty().
Cobby

44
¡CUIDADO! if(!isset($emptyarray))es falsepero if(empty($emptyarray))vuelve true. Eso me clavó
Kolob Canyon

161

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.


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

79

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.


2
Muchas gracias por todo. Fue realmente informativo y fue capaz de resolver mi problema usandoarray_filter()
Brian Powell

empty (array ()) siempre se evaluará como FALSE, por lo que agregar count (array ()) == 0 producirá true
timmz

1
@mboullouz count(array())==0es 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 count(array())ya que la matriz está, por supuesto, vacía. Necesitamos verificar cuándo la matriz ha regresado de un formulario o de otro lugar para saber si está vacía (claves / valores) o si solo 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


12

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!';
}

11

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') == [];

Esta es la respuesta correcta a una pregunta diferente. El uso del filtro de matriz destruirá los elementos existentes con valores falsey. Esto no es lo que pide el OP.
mickmackusa

8

¿Por qué nadie ha dicho esta respuesta?

$array = [];

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

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

Mientras está bajo el capó es la misma respuesta ... técnicamente. Usé los corchetes en lugar de la función de matriz obsoleta.
Rob

Si usa este enfoque, también debe usarlo en ===lugar de hacerlo ==, ya que es más rápido.
Minding hace

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

is_array


Estos son controles innecesarios. El OP está llamando explode(): devuelve datos de tipo matriz. La comprobación empty()es una llamada de función innecesaria. Como lo indicó Cobby en 2012, if($detect)es todo lo que se requiere. Esta solución no debe implementarse para esta tarea u otras. Se podría argumentar que se está cubriendo situaciones más allá del alcance de esta pregunta, bueno, nunca hay una necesidad de llamar empty()DESPUÉS is_array()porque si la variable no es "conjunto", a continuación, is_array()va a generar "Aviso: Undefined variable", si isset()a continuación, empty()es un exceso, el uso justo La respuesta de Cobby.
mickmackusa

6

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";

Buen punto de referencia, pero olvidó sizeofcuál 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 Merrill

Realmente deberías estar usando en ===lugar de ==.
Minding hace

5

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


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

5

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.


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 sobrecarga de llamadas a funciones. ABSOLUTAMENTE NO HAY DIFERENCIA para acceder a una matriz con claves indexadas versus claves asociativas. Esta respuesta es engañosa a los investigadores. Esta respuesta es redundante , entonces incorect . 3v4l.org/DSLha
mickmackusa

3

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


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

3

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

1
Esta respuesta está empleando controles innecesarios. En primer lugar, el OP no está interesado en filtrar ningún valor de falsey 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

2
 $gamerow = mysql_fetch_array($gameresult);

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

  // do stuf if array is empty
}

2

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

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

2

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.

@ptr está aquí.
mickmackusa

1
empty($gamerow['players'])

a veces no se puede saber el valor de la clave de matriz de elementos $matches = preg_grep ( "/^$text (\w+)/i" , $array ) ; para comprobarlo. Usoif ( count ( $matches ) > 0 )
Salem

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

-1

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

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

-3

Esto parece funcionar para todos los casos

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

3
Esto tiene demasiada sobrecarga. 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 constituyen demasiados gastos generales? ¿Cuál es el sorteo, o cuáles son los criterios de valor nominal para una sobrecarga excesiva sin ejecutar pruebas de rendimiento?
ptrcao

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

@ptr He publicado una respuesta integral 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

-4

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
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.