players将为空或以逗号分隔的列表（或单个值）。检查它是否为空的最简单方法是什么？我假设我可以在将$gameresult数组提取到$gamerow后立即执行此操作？在这种情况下，如果$playerlist为空，则跳过爆炸可能会更有效，但为了参数，我如何检查数组是否也为空？
$gamerow = mysql_fetch_array($gameresult);
$playerlist = explode(",", $gamerow['players']);
答案 0 :(得分：637)
如果您只需要检查数组中是否有任何元素
if (empty($playerlist)) {
// list is empty.
}
如果你需要在检查前清除空值（通常是为了防止explode奇怪的字符串）：
foreach ($playerlist as $key => $value) {
if (empty($value)) {
unset($playerlist[$key]);
}
}
if (empty($playerlist)) {
//empty array
}
答案 1 :(得分：135)
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。如果可能未设置变量并且您不会触发empty($emptyVar)，请使用E_NOTICE; IMO这通常是一个坏主意。
答案 2 :(得分：74)
一些不错的答案，但我想我会扩展一点，以便在PHP确定数组是否为空时更清楚地解释。
主要说明：
带有一个或多个键的数组将被PHP确定为非空。
由于数组值需要存在键，因此只有没有键（因此没有值）时，在数组中具有值或不存在值不会确定它是否为空。
因此，使用empty()检查数组不会简单地告诉您是否有值，它会告诉您数组是否为空，并且键是数组的一部分。
在决定使用哪种检查方法之前，请考虑如何生成阵列
EG当每个表单字段具有数组名称（即name="array[]"）时，当用户提交HTML表单时，数组将具有键。
将为每个字段生成非空数组，因为每个表单字段的数组都会有自动递增的键值。
以这些数组为例：
/* 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[] = '';
如果您回显出上述数组的数组键和值，则会得到以下内容：
ARRAY ONE：
[UserKeyA] =＆gt; [UserValueA]
[UserKeyB] =＆gt; [UserValueB]ARRAY TWO：
[0] =＆gt; [UserValue01]
[1] =＆gt; [UserValue02]ARRAY THREE：
[0] =＆gt; []
[1] =＆gt; []
使用empty()测试上述数组会返回以下结果：
ARRAY ONE：
$ ArrayOne不为空ARRAY TWO：
$ ArrayTwo不为空ARRAY THREE：
$ ArrayThree不为空
当您分配数组但之后不使用数组时，数组将始终为空，例如：
$ArrayFour = array();
这将是空的，即在上面使用if 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()（在此答案的第一个代码块中创建）会产生以下结果：
ARRAY ONE：
$ arrayone不为空ARRAY TWO：
$ arraytwo不为空ARRAY THREE：
$ arraythree是空的
因此，当没有值，是否有键时，使用array_filter()创建一个新数组，然后检查新数组是否为空，显示原始数组中是否有任何值。 />
它不理想而且有点乱，但是如果你有一个巨大的数组并且不需要因任何其他原因而循环它，那么就所需的代码来说这是最简单的。
我在检查间接费用方面没有经验，但最好知道使用array_filter()和foreach检查是否找到值之间的差异。
显然，基准测试需要在各种参数上，小型和大型阵列以及有值而不是等等。
答案 3 :(得分：17)
答案 4 :(得分：9)
如果你想确定你正在测试的变量是否实际上是一个空数组，你可以使用这样的东西：
results = (SELECT * FROM location WHERE location.latitude BETWEEN 14.223 AND 14.5 )
AND location.longitude BETWEEN 121.5 AND 122
haversine(results, user_point)
答案 5 :(得分：8)
我运行了帖子结尾处包含的基准。比较方法：
count($arr) == 0：计数empty($arr)：为空$arr == []：comp (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 */|
empty和强制转换为布尔值之间的区别是微不足道的。我已经多次运行了此测试，它们看起来基本上是等效的。数组的内容似乎没有扮演重要的角色。两者产生相反的结果，但逻辑上的否定仅足以在大多数情况下推动演员获胜，因此出于个人可读性考虑，我个人更倾向于空着。
#!/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";
答案 6 :(得分：6)
为什么没有人说这个答案：
.navbar-center, .navbar-right {
display: flex;
flex-direction: row;
justify-content: space-around;
}
.navbar-center li, .navbar-right li {
align-self: center;
}
答案 7 :(得分：6)
is_array($detect) && empty($detect);
答案 8 :(得分：4)
如果您想排除错误的行或空行（例如0 => ''），在使用empty()会失败的情况下，可以尝试：
if (array_filter($playerlist) == []) {
// Array is empty!
}
array_filter()：如果未提供回调，则将删除所有等于FALSE的数组条目（请参阅转换为布尔值）。
如果您想删除所有NULL，FALSE和空字符串（''），但保留零值（0），则可以使用strlen作为回调，例如：
$is_empty = array_filter($playerlist, 'strlen') == [];
答案 9 :(得分：4)
如果要检查可能使用的阵列内容：
$arr = array();
if(!empty($arr)){
echo "not empty";
}
else
{
echo "empty";
}
答案 10 :(得分：3)
$gamerow = mysql_fetch_array($gameresult);
if (!empty(($gamerow['players'])) {
$playerlist = explode(",", $gamerow['players']);
}else{
// do stuf if array is empty
}
答案 11 :(得分：3)
我使用此代码
$variable = array();
if( count( $variable ) == 0 )
{
echo "Array is Empty";
}
else
{
echo "Array is not Empty";
}
但请注意，如果数组中有大量的键，则此代码将花费大量时间计算它们，与此处的其他答案相比。
答案 12 :(得分：3)
empty($gamerow['players'])
答案 13 :(得分：2)
您可以使用适用于所有情况的sprintf：
array_filter()答案 14 :(得分：2)
WHERE players IS NOT NULL WHERE players != '' WHERE COALESCE(players, '') != '' WHERE players IS NOT NULL AND players != '' 如果不确定100％该列是否将存在于结果集中，则应检查该列是否已声明。这意味着在列上调用array_key_exists()，isset()或empty()。我不会在这里描述差异（还有其他用于细分的SO页面，这是一个开始：1，2，3）。就是说，如果您不能完全控制结果集，则可能是您过度沉迷于应用程序的“灵活性”，因此应该重新考虑是否值得潜在地访问不存在的列数据。 有效地说，我是说您永远不需要检查是否已声明一列，因此，您永远不需要empty()来完成此任务。如果有人在争论empty()更合适，那么他们会就脚本的表达力发表自己的个人看法。如果您发现以下＃5中的条件不明确，请在代码中添加内联注释，但我不会。最重要的是，进行函数调用没有程序上的优势。
您的字符串值可能包含要视为真/有效/非空的0吗？如果是这样，那么您只需检查列值是否具有长度。
这里是Demo，使用strlen()。这将指示该字符串爆炸后是否会创建有意义的数组元素。
我认为重要的是要提到，通过无条件爆炸，可以保证您生成一个非空数组。这是证明：Demo换句话说，检查是否数组为空是完全没用的-每次都会为非空。
如果您的字符串不会包含零值（例如，这是一个由1开头且仅递增的id组成的csv），那么if ($gamerow['players']) {就是您的全部需要-故事的结尾。
...但是等等，确定此值的空度后您在做什么？如果您有一些期望$playerlist的下标脚本，但有条件地声明该变量，则可能会冒用前一行的值或再次生成通知的风险。那么，您是否需要无条件地将$playerlist声明为 something ？如果字符串中没有真值，那么声明空数组是否会使您的应用程序受益？答案是肯定的。在这种情况下，您可以通过退回到空数组来确保该变量为数组类型-这样，如果您将该变量馈入循环中就没有关系了。以下条件声明都是等效的。
if ($gamerow['players']) { $playerlist = explode(',', $gamerow['players']); } else { $playerlist = []; } $playerlist = $gamerow['players'] ? explode(',', $gamerow['players']) : []; 为什么我要花这么长时间来解释这个非常基本的任务？
答案 15 :(得分：1)
在我看来，建立索引数组的最简单方法是：
if ($array) {
//Array is not empty...
}
如果数组不为空，则数组上的“ if”条件将评估为 true ，如果数组为空，则评估为 false 。 不不适用于关联数组。
答案 16 :(得分：1)
已经讨论了许多选项来检查数组是否空或不包含值，因为有
if ($playerlist) {}
if (!empty($playerlist)) {}
if (count($playerlist) > 0) {}
各有优缺点。
但是还有另一种选择，如果您确定您的数组只有数字键，从零开始，这可能是可行的（即，如果您 explode() 一个字符串，则会发生这种情况） :
if (isset($playerlist[0])) {
// do something
}
这甚至比其他解决方案快一点。
答案 17 :(得分：0)
这似乎适用于所有情况
if(!empty(sizeof($array)))
答案 18 :(得分：0)
我认为确定数组是否为空的最佳方法是使用count（），如下所示：
if(count($array)) {
return 'anything true goes here';
}else {
return 'anything false';
}
答案 19 :(得分：0)
$status = "";
$new_array = array();
if(!empty($new_array)){
$status = "1"; // not a blank array
}
else{
$status = "0"; // blank array
}
答案 20 :(得分：-1)
我已用以下代码解决了这个问题。
$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);
}
答案 21 :(得分：-2)
怎么样：
DepartmentPerSchool = array();
(empty(is_array($DepartmentPerSchool))) ? $DepartmentPerSchool //or echo is not empty : array('not set'=>'Not set. Contact Admin'); //or echo is empty