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

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

empty($gamerow['players'])

如果你只需要检查数组中是否有任何元素，你可以使用数组本身，因为PHP的松散类型，或者-如果你喜欢更严格的方法-使用count():

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

如果你需要在检查之前清理空值(通常是为了防止explodeing奇怪的字符串):

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

在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);在我看来，这是个坏主意。

如果你要检查数组内容，你可以使用:

$arr = array();


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

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

is_array

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

主要记录:

带有键(或多个键)的数组将被PHP确定为非空。

由于数组值需要键才能存在，数组中是否有值并不决定数组是否为空，只有在没有键(因此也没有值)的情况下才会决定数组是否为空。

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

以这些数组为例:

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

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

< br > < p >数组: [UserKeyA] => [UserValueA]
. [UserKeyA] => [UserValueA]
. [UserKeyB] => [UserValueB]

. < p >数组二:< br > [0] => [UserValue01]
[1] => [UserValue02]

< p >三个数组:< br > [0] => []
[1] => []

并且使用empty()测试上述数组将返回以下结果:

< br > < p >数组: $ArrayOne不为空

< p >数组二:< br > $ArrayTwo不是空的

< p >三个数组:< br > $ArrayThree不是空的

当你赋值一个数组但之后不使用它时，数组将始终为空，例如:

$ArrayFour = array();

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

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

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

下面是一种方法，它使用很少的代码来检查数组是否有值:

$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()(在这个答案的第一个代码块中创建)，结果如下:

< br > < p >数组: $arrayone不是空的

< p >数组二:< br > $arraytwo不是空的

< p >三个数组:< br > $arraythree为空

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

显然，基准测试需要在各种参数上，在大小数组上，当有值时，等等。

我使用这个代码

$variable = array();


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

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

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

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

 $gamerow = mysql_fetch_array($gameresult);


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

// do stuff if array is empty
}

你可以使用array_filter()，它适用于所有情况:

$ray_state = array_filter($myarray);


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

为什么没有人回答:

$array = [];


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

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

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

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

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

这似乎适用于所有情况

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

如果你想排除错误或空行(如0 => '')，其中使用empty()将失败，你可以尝试:

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

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

如果你想删除所有的NULL, FALSE和空字符串('')，但留下零值(0)，你可以使用strlen作为回调，例如:

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

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

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

数组上的if条件将计算为如果数组不为空，则为和如果数组为空则为False。这是适用于关联数组的不。

我运行了文章末尾包含的基准测试。比较方法:

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

做出最恰当的决策需要了解数据的质量以及要遵循的流程。

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

• # EYZ0
• # EYZ0
• # EYZ0
• # EYZ0
• .．.这取决于你的存储数据，还有其他方法，我就讲到这里。

2. 如果您不能100%确定该列是否存在于结果集中，那么您应该检查该列是否已声明。这意味着在列上调用array_key_exists()、isset()或empty()。我不打算在这里费心描述差异(还有其他SO页面可以分解，这里是一个开始:1， 2， 3.)。也就是说，如果你不能完全控制结果集，那么你可能过度沉溺于应用的“灵活性”。并且应该重新考虑访问不存在的列数据的麻烦是否值得。如果有人认为empty()更合适，那么他们是在推动自己对脚本表达性的个人观点。如果您发现下面第5条中的条件不明确，请在代码中添加内联注释——但我不会这样做。最重要的是，进行函数调用在编程上没有任何优势。

3. 可能你的字符串值包含一个0，你想认为真/有效/非空?如果是，那么您只需要检查列值是否有长度。

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

4. 换句话说，检查数组是否为空是完全没有用的——它每次都是非空的。

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

6. < p >…但是等等，在确定这个值的空值之后要做什么?如果您有一些期望使用$playerlist的下脚本，但您是有条件地声明该变量，那么您可能会使用前一行的值或再次生成notice。那么你是否需要无条件地将$playerlist声明为某物?如果字符串中没有真值，您的应用程序是否受益于声明一个空数组?答案很可能是肯定的。在这种情况下，可以通过回退到空数组来确保变量是数组类型的——这样就不会影响是否将该变量提供给循环。下面的条件声明都是等价的。

• # EYZ0
• # EYZ0

为什么我要花这么长时间来解释这个非常基本的任务?

1. 我几乎检举了本页上的每一个答案，这个答案很可能会引来报复性投票(这种情况经常发生在捍卫这个网站的检举者身上——如果一个答案被否决，没有评论，那就一直保持怀疑态度)。
2. 我认为重要的是，Stackoverflow是一个值得信赖的资源，它不会用错误的信息和次优的技术毒害研究人员。
3. 这就是我如何表达我对即将到来的开发人员的关心，以便他们学习如何和为什么，而不是只是填鸭式地灌输一代复制粘贴的程序员。
4. 我经常用旧的页面来关闭新的重复的页面——这是资深志愿者的职责，他们知道如何快速找到重复的页面。我不能让自己使用一个有坏的/虚假的/次优的/误导性信息的旧页面作为参考，因为这样我就主动地对一个新的研究人员造成了伤害。

$status = "";


$new_array = array();


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

已经讨论了许多检查数组是否为空或不包含值的选项

# EYZ0

# EYZ0

# EYZ0

各有利弊。

还有另一个选项，这可能是可行的，如果你确定，你的数组只有数字键，从0开始(即如果你explode()一个字符串):

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

这甚至比其他解还要快一点。

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

使用empty()函数

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

OUTPUT:数组为空

使用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。

数组为空。

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

我不会重复这里已经说过的话，只是测试和在PHP-7.3上更有效的方法是!empty($myARR)或isset($myARR[0])，两者都显示相同的速度。其他的都比较慢，包括array_key_exists($myARR[0])和只是比较$myARR !== Array() | $myARR !== []。所以，我更喜欢empty()，简单而快速。