如何使用 PHP 检查数组是否为空？

Question

players 将为空或以逗号分隔的列表（或单个值）。检查它是否为空的最简单方法是什么？我假设只要我将$gameresult 数组提取到$gamerow 中，我就可以这样做？在这种情况下，如果 $playerlist 为空，则跳过爆炸可能会更有效，但为了争论，我将如何检查数组是否也为空？

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

Answer 1

count($gamerow['players']) 将为 0。

Answer 2

empty($gamerow['players'])

Answer 3

如果你只需要检查数组中是否有任何元素

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

如果您需要在检查之前清除空值（通常这样做是为了防止explodeing 奇怪的字符串）：

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

Answer 4

空数组在 PHP 中是错误的，因此您甚至不需要像其他人建议的那样使用 empty()。

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

PHP 的empty() 确定变量是否不存在或是否具有虚假值（如array()、0、null、false 等）。

在大多数情况下，您只想检查!$emptyVar。如果变量可能尚未设置并且您不会触发E_NOTICE，请使用empty($emptyVar)； IMO 这通常是个坏主意。

Answer 5

如果你要检查你可能使用的数组内容：

$arr = array();

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

请看这里： http://codepad.org/EORE4k7v

Answer 6

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

is_array

Answer 7

一些不错的答案，但只是想我会扩展一点，以便在 PHP 确定数组是否为空时更清楚地解释。

---

主要说明：

带有一个键（或多个键）的数组将被 PHP 确定为 非空。

由于数组值需要存在键，因此数组中是否存在值并不能确定它是否为空，只有在没有键的情况下（因此没有值）。

因此，使用empty() 检查数组并不仅仅告诉您是否有值，它会告诉您数组是否为空，并且键是数组的一部分。

---

因此，在决定使用哪种检查方法之前，请考虑您是如何生成数组的。
EG 当用户提交您的 HTML 表单时，当每个表单字段都有一个数组名称（即name="array[]"）时，数组将有键。
将为每个字段生成一个 非空 数组，因为每个表单字段的数组都有自动递增的键值。

以这些数组为例：

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

如果您回显上述数组的数组键和值，您会得到以下结果：

阵列一：
[UserKeyA] => [UserValueA]
[UserKeyB] => [UserValueB]

阵列二：
[0] => [用户值01]
[1] => [用户值02]

阵列三：
[0] => []
[1] => []

使用empty() 测试上述数组会返回以下结果：

阵列一：
$ArrayOne 不为空

阵列二：
$ArrayTwo 不为空

阵列三：
$ArrayThree 不为空

当你分配一个数组但之后不再使用它时，一个数组总是为空的，例如：

$ArrayFour = array();

这将为空，即在上面使用empty() 时，PHP 将返回TRUE。

因此，如果您的数组有键 - 例如通过表单的输入名称或手动分配它们（即创建一个以数据库列名称作为键但没有来自数据库的值/数据的数组），那么该数组将不会是empty()。

在这种情况下，您可以在 foreach 中循环数组，测试每个键是否有值。如果您无论如何都需要遍历数组，这是一个很好的方法，也许是检查键或清理数据。

但是，如果您只需要知道“如果值存在”返回 TRUE 或 FALSE，这不是最好的方法。 当知道数组有键时，有多种方法可以确定数组是否有任何值。函数或类可能是最好的方法，但它始终取决于您的环境和确切要求，以及其他事情，例如您当前对数组所做的事情（如果有的话）。

---

这是一种使用非常少的代码来检查数组是否有值的方法：

使用array_filter():
遍历数组中的每个值，将它们传递给回调函数。如果回调函数返回 true，则将数组中的当前值返回到结果数组中。数组键被保留。

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

在所有三个示例数组（在此答案的第一个代码块中创建）上运行 array_filter() 会产生以下结果：

阵列一：
$arrayone 不为空

阵列二：
$arraytwo 不为空

阵列三：
$arraythree 为空

所以当没有值的时候，不管有没有key，使用array_filter()创建一个新数组，然后检查新数组是否为空，显示原数组中是否有值。
这并不理想而且有点混乱，但是如果您有一个巨大的数组并且不需要出于任何其他原因循环遍历它，那么就所需的代码而言，这是最简单的。

---

我在检查开销方面没有经验，但最好知道使用 array_filter() 和 foreach 检查是否找到值之间的区别。

显然，基准测试需要针对各种参数、大小数组以及有值和没有值等。

Answer 8

我用这个代码

$variable = array();

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

但请注意，如果数组有大量键，则与此处的其他答案相比，此代码将花费大量时间来计算它们。

Answer 9

如果你想确定你正在测试的变量是否实际上是一个空数组，你可以使用这样的东西：

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

Answer 10

 $gamerow = mysql_fetch_array($gameresult);

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

Answer 11

您可以使用array_filter()，它适用于所有情况：

$ray_state = array_filter($myarray);

if (empty($ray_state)) {
    echo 'array is empty';
} else {
    echo 'array is not empty';
}

Answer 12

为什么没有人说出这个答案：

$array = [];

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

Answer 13

我认为确定数组是否为空的最佳方法是像这样使用 count()：

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

Answer 14

我已经用下面的代码解决了这个问题。

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

Answer 15

这似乎适用于所有情况

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

Answer 16

如果您想排除使用empty()会失败的错误或空行（例如0 => ''），您可以尝试：

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

array_filter()：如果没有提供回调，所有等于 FALSE 的数组条目（请参阅转换为布尔值）将被删除。

如果您想删除所有 NULL、FALSE 和空字符串 ('')，但保留零值 (0)，您可以使用 strlen 作为回调，例如：

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

Answer 17

在我看来，索引数组最简单的方法是：

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

如果数组不为空，则数组上的“if”条件将评估为 true，如果数组为空，则评估为 false。这不适用于关联数组。

Answer 18

我运行了帖子末尾包含的基准测试。比较方法：

• count($arr) == 0：计数
• empty($arr)：空
• $arr == []：比较
• (bool) $arr：演员表

得到以下结果

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 */|

空和转换为布尔值之间的区别是微不足道的。我已经多次运行这个测试，它们看起来基本上是等价的。数组的内容似乎没有发挥重要作用。两者产生相反的结果，但逻辑上的否定几乎不足以在大多数情况下推动选角获胜，所以我个人更喜欢空的，以方便阅读。

#!/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";

Answer 19

做出最合适的决定需要了解数据的质量以及要遵循的流程。

1. 如果您要取消/忽略/删除此行，那么最早的过滤点应该在 mysql 查询中。

• WHERE players IS NOT NULL
• WHERE players != ''
• WHERE COALESCE(players, '') != ''
• WHERE players IS NOT NULL AND players != ''
• ...这有点取决于您的商店数据，还有其他方法，我会在这里停止。

1. 如果您不能 100% 确定该列是否存在于结果集中，那么您应该检查该列是否已声明。这意味着在列上调用array_key_exists()、isset() 或empty()。我不打算在这里描述差异（还有其他 SO 页面用于该细分，这是一个开始：1、2、3）。也就是说，如果您不能完全控制结果集，那么您可能过度沉迷于应用程序的“灵活性”，并且应该重新考虑是否值得为访问不存在的列数据而带来麻烦。 实际上，我是说您永远不需要检查是否声明了列 - 因此，您永远不需要 empty() 来执行此任务。 如果有人认为 empty() 更合适，然后他们就脚本的表现力提出了自己的个人意见。如果您发现下面 #5 中的条件不明确，请在您的代码中添加内联注释——但我不会。底线是进行函数调用没有编程优势。

2. 您的字符串值是否可能包含您希望将其视为真实/有效/非空的0？如果是，那么您只需要检查列值是否有长度即可。

这是使用strlen() 的Demo。这将指示字符串在分解时是否会创建有意义的数组元素。

4. 我认为很重要的一点是，通过无条件爆炸，您可以保证生成一个非空数组。 这是证明：Demo 换句话说，检查数组是否为空是完全没用——每次都不是空的。

5. 如果您的字符串不可能包含零值（因为，比如说，这是一个由从 1 开始且仅递增的 id 组成的 csv，那么您只需要 if ($gamerow['players']) { 即可——故事结束。

6. ...但是等等，确定这个值的空性后你在做什么？如果您有一些期待$playerlist 的脚本，但您有条件地声明该变量，那么您可能会冒使用前一行的值或再次生成通知的风险。那么你需要无条件地将$playerlist 声明为something吗？如果字符串中没有真值，您的应用程序是否受益于声明一个空数组？机会是，答案是肯定的。在这种情况下，您可以通过回退到一个空数组来确保该变量是数组类型的——这样，您是否将该变量提供给一个循环就无关紧要了。以下条件声明都是等价的。

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

我为什么要花这么多篇幅来解释这个非常基本的任务？

1. 我已经举报了此页面上的几乎所有答案，并且此答案可能会招来报复性投票（这经常发生在为该网站辩护的举报人身上 - 如果答案有否决票且没有 cmets，请始终持怀疑态度）。
2. 我认为 Stackoverflow 是一种值得信赖的资源，不会因错误信息和次优技术而毒害研究人员，这一点很重要。
3. 这就是我如何表明我对即将到来的开发人员的关心，以便他们了解如何和为什么，而不是仅仅用勺子喂养一代复制粘贴程序员。
4. 我经常使用旧页面关闭新的重复页面——这是知道如何快速找到重复页面的资深志愿者的责任。我不能让自己使用包含错误/错误/次优/误导性信息的旧页面作为参考，因为这样我就在积极地损害新研究人员。

Answer 20

$status = "";

$new_array = array();

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

Answer 21

已经讨论了许多选项来检查数组是空还是不包含值，因为有

if ($playerlist) {}

if (!empty($playerlist)) {}

if (count($playerlist) > 0) {}

各有利弊。

但是还有另一种选择，如果您确定您的数组只有数字键，从零开始（即explode() 字符串，则会发生这种情况）：

if (isset($playerlist[0])) {
  // do something
}

这甚至比其他解决方案还要快。

Answer 22

您可以使用以下php函数来检查数组是否为空

使用empty()函数

$variable = array();
    if(empty($variable)){
    echo("The array is empty.");
    }

输出：数组为空

使用sizeof()函数

$variable = array();
$arraysize = sizeof($variable);
echo("The size of the array is $arraysize. \n");
if(sizeof($variable) == 0)
echo("The array is empty.");

输出：

数组的大小为0。

数组为空。

Answer 23

array_filter 递归和计数

function array_filter_recursive(array $arr) 
  { 
    array_walk($arr,function(&$item){if (is_array($item))  { $item = array_filter_recursive($item);}});
    return array_filter($arr); 
  } 
   
  function is_empty_array(array $arr):bool{
    return count(array_filter_recursive($arr)) == 0;
  }

测试

$c=['b'=>2,'c'=>3];
$a=[];
$b=[[]];
$d=['a'=>[]];
$e=['a'=>[],[]];
$f=['a'=>[[],[],[]],[]];
$g=[[[],[[],[[],[[],[]]]]],[]];
$i=[[[],[[],[[],[[],['s'=>1]]]]],[]];
var_dump(is_empty_array($c));//false
var_dump(is_empty_array($a));//true
var_dump(is_empty_array($b));//true
var_dump(is_empty_array($d));//true
var_dump(is_empty_array($e));//true
var_dump(is_empty_array($f));//true
var_dump(is_empty_array($g));//true
var_dump(is_empty_array($i));//false