(PHP 4、PHP 5、PHP 7、PHP 8)
empty — 确定变量是否为空
var要检查的变量
如果变量不存在，则不会生成任何警告。这意味着 empty() 本质上等同于 !isset($var) || $var == false 的简洁写法。
示例 #1 一个简单的 empty() / isset() 比较。
<?php
$var = 0;
// 由于 $var 为空，因此结果为真
if (empty($var)) {
echo '$var 既是 0，又是空的，或者根本没有设置';
}
// 由于 $var 已设置，因此结果为真
if (isset($var)) {
echo '$var 已设置，即使它为空';
}
?>示例 #2 在字符串偏移量上使用 empty()
<?php
$expected_array_got_string = 'somestring';
var_dump(empty($expected_array_got_string['some_key']));
var_dump(empty($expected_array_got_string[0]));
var_dump(empty($expected_array_got_string['0']));
var_dump(empty($expected_array_got_string[0.5]));
var_dump(empty($expected_array_got_string['0.5']));
var_dump(empty($expected_array_got_string['0 Mostel']));
?>上面的示例将输出
bool(true) bool(false) bool(false) bool(false) bool(true) bool(true)
<?php
/**
* @author : Nanhe Kumar <[email protected]>
* 所有空值的列表
**/
$testCase = array(
1 => '',
2 => "",
3 => null,
4 => array(),
5 => FALSE,
6 => NULL,
7=>'0',
8=>0,
);
foreach ($testCase as $k => $v) {
if (empty($v)) {
echo "<br> $k=>$v is empty";
}
}
/**
输出
1=> is empty
2=> is empty
3=> is empty
4=>Array is empty
5=> is empty
6=> is empty
7=>0 is empty
8=>0 is empty
**/
?>请注意，当在类的非现有/非公共变量上调用 empty() 时，如果使用魔术方法 __get（如 nahpeps 在 gmx 点 de 中之前提到的），结果会有点令人困惑。考虑这个例子
<?php
class Registry
{
protected $_items = array();
public function __set($key, $value)
{
$this->_items[$key] = $value;
}
public function __get($key)
{
if (isset($this->_items[$key])) {
return $this->_items[$key];
} else {
return null;
}
}
}
$registry = new Registry();
$registry->empty = '';
$registry->notEmpty = 'not empty';
var_dump(empty($registry->notExisting)); // true，到目前为止还不错
var_dump(empty($registry->empty)); // true，到目前为止还不错
var_dump(empty($registry->notEmpty)); // true，.. 说些什么？
$tmp = $registry->notEmpty;
var_dump(empty($tmp)); // false，符合预期
?>
empty($registry->notEmpty) 的结果有点出乎意料，因为该值显然已设置且非空。这是因为 empty() 函数在这些情况下使用 __isset() 魔术函数。虽然这在上面的文档中有所提及，但我认为有必要更详细地说明，因为这种行为并不直观。为了获得理想（预期？）的结果，您需要向类中添加 __isset() 魔术函数
<?php
class Registry
{
protected $_items = array();
public function __set($key, $value)
{
$this->_items[$key] = $value;
}
public function __get($key)
{
if (isset($this->_items[$key])) {
return $this->_items[$key];
} else {
return null;
}
}
public function __isset($key)
{
if (isset($this->_items[$key])) {
return (false === empty($this->_items[$key]));
} else {
return null;
}
}
}
$registry = new Registry();
$registry->empty = '';
$registry->notEmpty = 'not empty';
var_dump(empty($registry->notExisting)); // true, so far so good
var_dump(empty($registry->empty)); // true, so far so good
var_dump(empty($registry->notEmpty)); // false, finally!
?>
实际上，empty() 函数返回的是 __isset() 魔术函数结果的否定，因此上面的 __isset() 函数中 empty() 结果的否定。当您需要接受这些作为有效非空值时
- 0（作为整数的 0）
- 0.0（作为浮点数的 0）
- "0"（作为字符串的 0）
<?php
function is_blank($value) {
return empty($value) && !is_numeric($value);
}
?>
这类似于 Rails 的 blank? 方法。多个 empty()
<?php
/**
* 多个 empty()。
*
* @param mixed[] $vars 要测试的变量
* @return bool
*/
function multi_empty(& ...$vars)
{
// 没有提供回调，所有空值将被删除
return array_filter($vars) === [];
}
?>
示例
<?php
$notEmptyVar = 1;
$emptyVar = null;
// $undefinedVar - 未定义
multi_empty($emptyVar); // true
multi_empty($emptyVar, $undefinedVar); // true
multi_empty($notEmptyVar , $emptyVar); // false
multi_empty($notEmptyVar , $emptyVar, $undefinedVar); // false
?>我通常计算数组的个数，所以我想看看 empty() 的效果。
<?php
$test = array();
$test2 = array();
for ($x = 0; $x < 1000; $x++) $test[] = $x;
$ts = microtime(true);
for ($x = 0; $x < 100000000; $x++)
{
if (count($test))
{
}
}
echo "Time taken: " . (microtime(true) - $ts) . " sec\n";
?>
对于 100,000,000 次比较，以下是我的硬件上针对 PHP 7.2.16 的结果
count($test): 2.697 秒
count($test2): 2.596 秒
$test === array(): 2.579 秒
$test2 === array(): 2.552 秒
empty($test): 3.085 秒
empty($test2): 3.113 秒
简而言之，使用哪种方法并不重要，尽管 empty() 实际上只是稍微慢一点，尽管它是一个语言结构。YMMV。如果您想使用 empty() 来评估表达式（而不是变量），并且您没有 PHP 5.5+，您可以通过将对 empty 的调用包装在函数中来实现，如下所示
<?php
function is_empty($var) {
return empty($var);
}
?>
然后你可以做这样的事情
<?php
if(is_empty(NULL)) {
/* ... */
}
?>
没有问题，因为正在测试局部变量 $var 而不是函数调用本身的表达式。测试在
- Win 11
- Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz 2.21 GHz
- 64Gb RAM,
- PHP 8.1.10 (在 Tinkerwell 中)
反复显示 `empty` > `count` > `=== []`，但差距很小，不值得进行微优化。
注意：使用 onlinephp(dot)io 沙盒工具，PHP v7.4.33 的结果相同（使用 `$n = 10000000`）。
<?php
$test = range(0, 1000);
$test2 = [];
$n = 1000_000_000;
$t1 = microtime(true); for ($x = 0; $x < $n; $x++) if (count($test)) {}
$t2 = microtime(true); for ($x = 0; $x < $n; $x++) if (count($test2)) {}
$t3 = microtime(true); for ($x = 0; $x < $n; $x++) if ($test === []) {}
$t4 = microtime(true); for ($x = 0; $x < $n; $x++) if ($test2 === []) {}
$t5 = microtime(true); for ($x = 0; $x < $n; $x++) if (empty($test)) {}
$t6 = microtime(true); for ($x = 0; $x < $n; $x++) if (empty($test2)) {}
$t7 = microtime(true);
echo "count(\$test): " . ($t2 - $t1) . " sec\n";
echo "count(\$test2): " . ($t3 - $t2) . " sec\n";
echo "\$test === []: " . ($t4 - $t3) . " sec\n";
echo "\$test2 === []: " . ($t5 - $t4) . " sec\n";
echo "empty(\$test): " . ($t6 - $t5) . " sec\n";
echo "empty(\$test2): " . ($t7 - $t6) . " sec\n";
?>
结果
<?php
count($test): 18.034885168076 秒
count($test2): 17.133869886398 秒
$test === []: 20.059770107269 秒
$test2 === []: 14.204195022583 秒
empty($test): 13.583840847015 秒
empty($test2): 12.971315145493 秒
?>为了验证表单，并“阻止”诸如简单空格或其他字符的输入，我想到了以下组合
function isEmpty($string){
$val = preg_replace('#[^A-Za-z0-9]+#', '', $string) ;
$val = trim($string, '');
return ($string=='') ;
}
这可以防止诸如：' ' ,' - ', '. - +', ...等输入。对于诸如姓名、职业等输入，它非常有用回复 "admin at ninthcircuit dot info",
使用 str_replace 是不必要的。我建议使用 trim，它可能更快（尚未测试）且更易于使用。Trim 还处理其他空白字符，例如换行符和制表符。实际上，在我的大部分代码中，我使用带有 trim 的多维数组映射函数来处理超级全局变量，例如 $_POST、$_GET 和 $_COOKIE，因为到目前为止，还没有出现我希望用户输入以空白字符开头或结尾的情况。这样做的好处在于你永远不必担心“修剪”你的输入，这使得你的代码更简单、更可靠（以防你忘记修剪某些输入）。警告：一个“空”对象不被认为为空
<?php
$var = new stdClass(); // "空"对象
var_dump(empty($var)); // bool(false)
?>
我不知道是否有标准的方法来测试“空”对象，我个人使用数组转换
<?php
$var = new stdClass(); // "空"对象
$var = (array) $var; // 转换为空数组
var_dump(empty($var)); // bool(true)
?>（在 PHP 5.6.3 中有经验）`empty()` 无法显式地评估 `__get()` 的结果，因此下面的 `empty()` 语句始终为真
<?php
class Juice extends Liquid{
protected $apple;
protected $orange;
public function __get($name) {
return $this->$name;
}
public function __construct($apple, $orange) {
$this->apple = $apple;
$this->orange = $orange;
}
}
class Glass {
protected $liquid;
public function __get($name) {
return $name == "liquid" ? $this->liquid : false;
}
public function __construct() {
$this->juice = new Juice(3, 5);
}
}
$glass = new Glass();
var_dump(empty($this->liquid->apple));
/**
* 输出结果为：
* bool(true)
*/
?>
正确的方法是先强制评估 `__get()`，方法是在隐式语句周围使用额外的括号，如下所示
<?php
var_dump(empty(($this->liquid->apple)));
/**
* 输出结果为：
* bool(false)
*/
?>
因此，如果你使用的是使用面向对象设计和 `__get()` 等魔术方法的软件包，最好始终在 `empty()` 调用中使用双括号。调用不存在的对象属性，`empty($object->prop)`，将触发 `__isset()`，与 `isset($object->prop)` 一样，但有一个区别。如果 `__isset()` 返回 `TRUE`，则将进行对 `__get()` 的另一次调用，并且实际返回值将是 `empty()` 和 `__get()` 的结果。<?php
$str = ' ';
var_dump(empty($str)); // boolean false
?>
所以请记住，首先要修剪你的字符串！
<?php
$str = ' ';
$str = trim($str);
var_dump(empty($str)); // boolean true
?>我将总结关于 `empty()` 与不可访问属性的一些要点，希望可以节省其他人一些时间。使用 PHP 5.3.2。
<?php
class MyClass {
private $foo = 'foo';
}
$myClass = new MyClass;
echo $myClass->foo;
?>
正如预期的那样，这将给出“致命错误：无法访问私有属性 MyClass::$foo”。
但将以下行替换掉
if (empty($myClass->foo)) echo 'foo is empty'; else echo 'foo is not empty';
我们将得到误导性的结果“foo is empty”。
没有错误或警告，所以这是一个真正的陷阱。你的代码会默默地出错，我认为这算是一个错误。
如果你在类中添加两个魔术函数
public function __get($var) { return $this->$var; }
public function __isset($var) { return isset($this->$var); }
那么我们将得到预期的结果。你需要这两个函数。
对于 `empty($myClass->foo)`，我相信 PHP 会调用 `__isset`，如果为真，则返回 `empty` 对 `__get` 结果的结果。（一些早期帖子错误地建议 PHP 只返回 `__isset` 的否定）。
但是…
请参阅 php at lanar dot com 的早期帖子。我确认了那些结果，如果你使用 `isset($x->a->b->c)` 扩展测试，似乎 `__isset` 仅针对链中的最后一个属性被调用。这可能也是一个错误。`empty()` 的行为方式相同。所以事情不像我们希望的那样清晰。
另请参阅有关 `empty()` 的说明，位于
http://uk3.php.net/manual/en/language.oop5.overloading.php
一片混乱！我无法在所有情况下都使用 `empty()`，因为对我来说 '0' 通常不被认为是空的。我快速比较了一下最常见的测试方法。
<?php
$microtimeref = microtime(true);
$a = 0;
$b = 'asd';
for ($i = 0; $i < 5000000; $i++)
{
if (0 == mb_strlen ($b))
{
$a++;
}
}
echo "Total time 0 == mb_strlen(var): <b>" . round(microtime(true) - $microtimeref,3) . 's</b><br />';
?>
结果
Total time 0 == mb_strlen(var): 3.141s
Total time 0 === strlen(var): 2.904s
Total time 0 == strlen(var): 2.878s
Total time '' == var: 1.774s
Total time '' === var: 1.706s
Total time empty(var): 1.496s
因此，`'' === var` 将是我的零长度字符串测试。在 "0" 不打算为空的情况下，以下是一个安全测试空字符串（或混合变量）的简单函数
<?php
function _empty($string){
$string = trim($string);
if(!is_numeric($string)) return empty($string);
return FALSE;
}
?>补充anon的观点，john_jian例子中的情况看起来不寻常，因为我们没有看到幕后发生的隐式类型转换。实际上发生的是
$a = '';
$b = 0;
$c = '0';
(int)$a == $b -> true，因为任何不是数字的字符串都会被转换为0
$b==(int)$c -> true，因为字符串中的整数会被转换
和
$a==$c -> false，因为它们被当作字符串而不是整数进行比较。然而，(int)$a==(int)$c应该返回true。
注意：我不记得PHP是否支持类型转换，更不用说这个语法是否正确了。我只是为了举例说明而已。empty() 不一定返回 __isset() 魔法函数结果的否定，如果你将一个数据成员设置为 0，isset() 应该返回 true，empty 也应该返回 true。__isset 魔法函数的更简单的实现应该是
public function __isset($key) {
return isset($this->{$key});
}
我不明白为什么这没有包含在 stdClass 中，也没有默认继承。测试所有多维数组是否为空
<?php
function is_multiArrayEmpty($multiarray) {
if(is_array($multiarray) and !empty($multiarray)){
$tmp = array_shift($multiarray);
if(!is_multiArrayEmpty($multiarray) or !is_multiArrayEmpty($tmp)){
return false;
}
return true;
}
if(empty($multiarray)){
return true;
}
return false;
}
$testCase = array (
0 => '',
1 => "",
2 => null,
3 => array(),
4 => array(array()),
5 => array(array(array(array(array())))),
6 => array(array(), array(), array(), array(), array()),
7 => array(array(array(), array()), array(array(array(array(array(array(), array())))))),
8 => array(null),
9 => 'not empty',
10 => "not empty",
11 => array(array("not empty")),
12 => array(array(),array("not empty"),array(array()))
);
foreach ($testCase as $key => $case ) {
echo "$key is_multiArrayEmpty= ".is_multiArrayEmpty($case)."<br>";
}
?>
输出
========
0 is_multiArrayEmpty= 1
1 is_multiArrayEmpty= 1
2 is_multiArrayEmpty= 1
3 is_multiArrayEmpty= 1
4 is_multiArrayEmpty= 1
5 is_multiArrayEmpty= 1
6 is_multiArrayEmpty= 1
7 is_multiArrayEmpty= 1
8 is_multiArrayEmpty= 1
9 is_multiArrayEmpty=
10 is_multiArrayEmpty=
11 is_multiArrayEmpty=
12 is_multiArrayEmpty=<?php
/*"" (空字符串)
0 (整数 0)
0.0 (浮点数 0)
"0" (字符串 0)
NULL
FALSE
array() (空数组)*/
$anEmptyString = "";
empty($anEmptyString);
if(empty($anEmptyString) == TRUE){
echo "TRUE";
} else{
echo "FALSE";
}
echo "<hr>"; //换行
$anIntegerNumber = 0;
empty($anIntegerNumber);
if(empty($anIntegerNumber) == TRUE){
echo "TRUE";
} else{
echo "FALSE";
}
echo "<hr>"; //换行
$aFloatNumber = 0.0;
empty($aFloatNumber);
if(empty($aFloatNumber) == TRUE){
echo "TRUE";
} else{
echo "FALSE";
}
echo "<hr>"; //换行
$aZeroValuedString = "0";
empty($aZeroValuedString);
if(empty($aZeroValuedString) == TRUE){
echo "TRUE";
} else{
echo "FALSE";
}
echo "<hr>"; //换行
$aNULL = NULL;
empty($aNULL);
if(empty($aNULL) == TRUE){
echo "TRUE";
} else{
echo "FALSE";
}
echo "<hr>"; //换行
$aBooleanFALSE = FALSE;
empty($aBooleanFALSE);
if(empty($aBooleanFALSE) == TRUE){
echo "TRUE";
} else{
echo "FALSE";
}
echo "<hr>"; //换行
$anEmptyArray = array();
empty($anEmptyArray);
if(empty($anEmptyArray) == TRUE){
echo "TRUE";
} else{
echo "FALSE";
}
echo "<hr>"; //换行
?>注意，如果你的变量只包含一个“换行符”（也称为回车符），即 PHP_EOL，它不会被认为为空。由于换行符并不总是容易发现，这可能会让人感到困惑。我正在比较 `!` 和 `empty()` 的行为，在这里发现了一个未记录的行为。
就像转换为布尔值一样，`empty()` 会关心 SimpleXML 对象是否是由空标签创建的。
`empty(simplexml_load_string('<root />'))` 为 TRUE
此行为从 php 5.1.0~7 开始，在 5.0.x 中为 FALSE
证明在这里 => https://3v4l.org/74Tc4注意十进制数的例外情况
<?php
$a = 0.00;
$b = '0.00';
echo (empty($a)? "empty": "not empty"); //结果 empty
echo (empty($b)? "empty": "not empty"); //结果 not empty
//但是...
$c = intval($b);
echo (empty($c)? "empty": "not empty"); //结果 empty
?>
对于那些使用 MySQL 的人来说，如果你有一个包含 decimal 类型列的表，当你执行 SELECT 时，你的数据将作为字符串返回，因此你需要在测试为空之前应用 intval()。
例如
TABLE t 包含列 id MEDIUMINT 和 d DECIMAL(4,2)
并且包含 1 行，其中 id=1，d=0.00
<?php
$q = "SELECT * FROM t";
$res = mysql_query($q);
$row = mysql_fetch_assoc($res);
echo (empty($row['d'])? "empty": "not empty"); //结果 not empty
?>来自 CodeXplorer 的 David
>> 使用 empty() 的唯一原因是代码可读性。它与 IF/ELSE 检查相同。
>> 因此，不要在现实世界中使用 EMPTY。
这并非事实。如果你对未定义的变量进行测试，empty() 不会生成警告，而简单的布尔检查会生成警告。在生产系统中，警告通常被关闭，但它们在开发系统中经常处于活动状态。
你可以使用以下方法测试标志：
<?php if ($flagvar) ... ?>
但如果 $flagvar 未设置，这可能会生成警告。
而不是
<?php if (isset($flagvar) && $flagvar) ... ?>
你可以简单地使用
<?php if (!empty($flagvar)) ... ?>
以易于阅读的方式，而不会产生警告。注意，当子键不存在但父键存在并且是字符串时，检查数组子键的存在性将返回 false 以为空。
例如
<?php
$params = array('search'=>'1');
empty($params['search']['filter']); # 返回 false
?>
这是正确的，根据文档 (https://php.net/manual/en/language.types.string.php)；在页面下方有一段警告：“写入超出范围的偏移量会用空格填充字符串。非整数类型将转换为整数。”) 我没有收到警告，但这可能也是正确的......取决于是否将字符串 -> 整数转换视为“非法”：“非法偏移类型会发出 E_NOTICE。”
(例如，由于 $params['search'] 是一个字符串，'filter' 下标将被转换为 0，因此测试变为 empty($params['search'][0])，这显然是错误的)，但它让我误以为是错误，因此我提交了一个错误报告（我已经关闭了）。要创建一个仅接受数组的空函数，可以使用类型提示
<?php
// emptyArray :: [a] -> Bool
function emptyArray(array $xs){
return empty($xs);
}
?>
类型提示在代码中很有用，因为它使代码更易于理解。此外，它会自动为代码添加文档。注意，如果 "0"（作为字符串的零）、0（作为整数的零）和 -0（作为整数的负零）返回 true，"-0"（作为字符串的负零（是的，我遇到过一些客户在表单字段中输入 -0））返回 false。您需要在使用 empty() 函数测试之前将变量类型转换。
<?php
$var = "-0";
echo empty($var); // 返回 false
$var = (int) $var; // 将 $var 转换为整数
echo empty($vat); // 返回 true
?>针对“致命错误：无法在写入上下文中使用函数返回值...”的简单解决方案
<?php
function _empty($val) { return empty($val); }
?>由于我不喜欢 empty() 将 0 和 "0" 视为空（这很容易导致代码中的错误），而且它不处理空格，所以我创建了以下函数
<?php
function check_not_empty($s, $include_whitespace = false)
{
if ($include_whitespace) {
// 使包含空格的字符串也视为空
$s = trim($s);
}
return (isset($s) && strlen($s)); // 变量已设置，并且不是空字符串 ''
}
?>
您可以直接使用 if (check_not_empty($var)) { // 它不为空 } 来代替 if (!empty($var)) { // 它不为空 }。
如果您希望仅包含空格（例如制表符或空格）的字符串被视为空，则执行：check_not_empty($var, 1)
如果您要检查字符串是否为空，则执行：!check_not_empty($var)。
因此，每当您要检查表单字段是否同时存在且包含值时，只需执行：if (check_not_empty($_POST['foo'], 1)
不再需要使用 if (isset() && !empty()) 了 =]如果 $var 为空（根据上面对“空”的定义）并且 $var 未设置，则 empty($var) 将返回 TRUE。
我知道手册中“返回值”部分的语句已经反过来说了
"如果 var 具有非空且非零值，则返回 FALSE。"
但我当时想“为什么这个东西对未设置的变量返回 TRUE？？”...哦，我现在明白了...它应该对未设置的变量返回 TRUE！！！
<?php
ini_set('error_reporting',E_ALL);
ini_set('display_errors','1');
empty($var);
?>请注意，empty() 会对空字节返回 false。例如
<?php
// 保存到变量中，以便它在旧版本的 PHP 中也能工作
$null_byte = chr(0); // === \0
var_dump(
empty(null),
empty($null_byte)
);
/**
* 结果：
*
* bool(true)
* bool(false)
*/如果您测试数组中的元素（例如 $_POST['key']），它会测试键是否不存在，或者如果键存在，它的值是否为空，并且永远不会发出警告。
对于不想测试传递数组元素时会发生什么的人，以下是我的测试和结果。
<?php
$a = array();
$b = array('key');
$c = array('key' => false);
$d = array('key' => 'La verdad nos hace libres');
echo (empty($a['key'])?'A empty':'A not empty'), ' - ', (empty($b['key'])?'B empty':'B not empty'), ' - ', (empty($c['key'])?'C empty':'C not empty'), ' - ', (empty($d['key'])?'D empty':'D not empty');
?>
结果是
A empty - B empty - C empty - D not empty<?php
// empty() 与 isset() 的区别
$testCase = array(
1 => '',
2 => ' ',
3 => null,
4 => array(),
5 => false,
6 => true,
7 => '0',
8 => 0,
);
foreach ($testCase as $k => $v) {
echo "<br> $k => " . strval($v) . " " . (empty($v) ? "is empty" : "is not empty") . " / " . (isset($v) ? "is set" : "is not set");
}
/*
RESULT:
1 => is empty / is set
2 => is not empty / is set
3 => is empty / is not set
4 => Array is empty / is set
5 => is empty / is set
6 => 1 is not empty / is set
7 => 0 is empty / is set
8 => 0 is empty / is set
*/