(PHP 4, PHP 5, PHP 7, PHP 8)
empty — 确定变量是否为空
var要检查的变量
如果变量不存在，则不会生成警告。这意味着empty()本质上是!isset($var) || $var == false的简洁等价物。
示例 #1 一个简单的empty() / isset()比较。
<?php
$var = 0;
// 因为$var为空，所以计算结果为true
if (empty($var)) {
echo '$var 为 0、empty 或根本未设置';
}
// 因为$var已设置，所以计算结果为true
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 为空";
}
}
/**
输出
1=> 为空
2=> 为空
3=> 为空
4=>数组为空
5=> 为空
6=> 为空
7=>0 为空
8=>0 为空
**/
?>测试于
- 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 sec
count($test2): 17.133869886398 sec
$test === []: 20.059770107269 sec
$test2 === []: 14.204195022583 sec
empty($test): 13.583840847015 sec
empty($test2): 12.971315145493 sec
?>请注意，如果使用魔术方法`__get`，在对类的非存在/非公开变量调用`empty()`时，结果可能会令人困惑（正如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, so far so good
var_dump(empty($registry->empty)); // true, so far so good
var_dump(empty($registry->notEmpty)); // true, .. say what?
$tmp = $registry->notEmpty;
var_dump(empty($tmp)); // false as expected
?>
对于`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 5.5+，可以通过将`empty()` 的调用包装在一个函数中来实现，如下所示
<?php
function is_empty($var) {
return empty($var);
}
?>
然后你可以这样做
<?php
if(is_empty(NULL)) {
/* ... */
}
?>
不会有任何问题，因为测试的是局部变量$var，而不是函数调用本身的表达式。警告：“空”对象不被认为是空的
<?php
$var = new stdClass(); // “空”对象
var_dump(empty($var)); // bool(false)
?>
我不知道是否有标准的方法来测试“空”对象，我个人使用数组转换
<?php
$var = new stdClass(); // “空”对象
$var = (array) $var; // 转换为空数组
var_dump(empty($var)); // bool(true)
?>我通常计算数组的数量，所以我想看看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()实际上只是稍微慢一点，尽管它是一个语言结构。你的里程可能会有所不同。回复“admin at ninthcircuit dot info”，
使用str_replace是不必要的。我建议使用trim，它可能更快（未经测试）且更容易。Trim还处理其他空白字符，如换行符和制表符。实际上，在我编写的许多应用程序中，我使用了一个带有trim的多维数组映射函数来处理超级全局变量，例如$_POST、$_GET和$_COOKIE，因为到目前为止，还没有出现我希望任何用户输入以空格开头或结尾的情况。这样做的好处是，您不必担心“修剪”您的输入，这使得您的代码更易于维护和更可靠（以防您忘记修剪某些输入）。(在PHP 5.6.3中经验丰富) `empty()`不能显式地评估`__get()`的结果，因此下面的`empty()`语句总是返回true
<?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()`的结果。如果将数据成员设置为0，则`empty()`不应返回`__isset()`魔术函数结果的反义，`isset()`应返回true，`empty`也应返回true。`__isset`魔术函数的更简单的实现如下所示：
public function __isset($key) {
return isset($this->{$key});
}
我不明白为什么这没有包含在stdClass中并默认继承。<?php
$str = ' ';
var_dump(empty($str)); // boolean false
?>
因此，请记住首先修剪您的字符串！
<?php
$str = ' ';
$str = trim($str);
var_dump(empty($str)); // boolean true
?>为了验证表单，以“阻止”诸如简单的空格或其他之类的条目，我想到了这种组合
function isEmpty($string){
$val = preg_replace('#[^A-Za-z0-9]+#', '', $string) ;
$val = trim($string, '');
return ($string=='') ;
}
这可以防止诸如' '、' - '、'. - +'之类的条目……在姓名、职业等条目中，这很有帮助我不能在所有情况下都使用empty()，因为'0'通常不被我视为为空。我对测试它的最常见方法进行了快速基准测试。'' == var 存在'' == 0 为 true 的问题，所以它只是出于好奇。
<?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 />';
?>
结果
总时间 0 == mb_strlen(var): 3.141 秒
总时间 0 === strlen(var): 2.904 秒
总时间 0 == strlen(var): 2.878 秒
总时间 '' == var: 1.774 秒
总时间 '' === var: 1.706 秒
总时间 empty(var): 1.496 秒
因此，'' === var 将是我的零长度字符串测试。我总结了关于带有不可访问属性的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”。
没有错误或警告，所以这是一个真正的陷阱。你的代码只会默默地出错，我会说这相当于一个bug。
如果向类中添加两个魔术函数
public function __get($var) { return $this->$var; }
public function __isset($var) { return isset($this->$var); }
然后我们得到预期的结果。你需要这两个函数。
对于 empty($myClass->foo)，我相信PHP会调用__isset，如果为真则返回对__get结果的empty结果。（一些早期的帖子错误地认为PHP只是返回__isset的反值）。
但是……
参见lanar dot com上php的早期帖子。我确认了这些结果，如果你用isset($x->a->b->c)扩展测试，__isset似乎只对链中的最后一个属性调用。可以说是另一个bug。empty()的行为方式相同。所以事情不像我们希望的那样清晰。
另请参见关于empty()的说明：
http://uk3.php.net/manual/en/language.oop5.overloading.php
一团糟！在“0”不被认为为空的情况下，这里有一个简单的函数来安全地测试空字符串（或混合变量）
<?php
function _empty($string){
$string = trim($string);
if(!is_numeric($string)) return empty($string);
return FALSE;
}
?>注意十进制数的例外情况
<?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的用户，如果你的表有一列十进制类型，当你执行SELECT时，你的数据将作为字符串返回，所以你需要在测试为空之前应用intval()。
例如：
表t包含列id MEDIUMINT和d DECIMAL(4,2)
并包含一行，其中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
?>补充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是否*有*类型转换，更不用说这是否是正确的语法了。我只是为了举例。测试所有多维数组是否为空
<?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>"; //换行
?>我正在比较`!`和`empty()`的行为，发现了一个未记录的行为。
就像强制转换为布尔值一样，`empty()`会关心 SimpleXML 对象是否由空标签创建。
`empty(simplexml_load_string('<root />'))` 的结果为 TRUE
此行为从 PHP 5.1.0~7 开始出现，在 5.0.x 中结果为 FALSE
证据在此 => https://3v4l.org/74Tc4来自 CodeXplorer 的 David
>> 使用 `empty()` 的唯一原因是为了代码可读性。它与 IF/ELSE 检查相同。
>> 所以，不要在实际应用中使用 `EMPTY`。
这是错误的。如果测试的是未定义的变量，`empty()` 不会产生警告，而简单的布尔检查则会。在生产系统中，警告通常会被关闭，但在开发系统中通常是启用的。
您可以使用以下代码测试标志：
<?php if ($flagvar) ... ?>
但是，如果 `$flagvar` 未设置，这可能会产生警告。
与其使用
<?php if (isset($flagvar) && $flagvar) ... ?>
您可以简单地使用
<?php if (!empty($flagvar)) ... ?>
实现易于阅读且不会产生警告的代码。请注意，当子键不存在但父键存在且是字符串时，检查数组子键的存在性将使 `empty()` 返回 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])`，这显然是 false），但这足以让我错误地提交了一个错误报告（我现在已经关闭了）。如果 `$var` 为空（根据上面对“空”的定义）并且 `$var` 未设置，则 `empty($var)` 将返回 TRUE。
我知道手册“返回值”部分的语句已经反过来说了这一点
“如果 `var` 的值非空且非零，则返回 FALSE。”
但是我当时想“为什么这个东西对未设置的变量返回 TRUE？？？”…哦，我现在明白了…它应该对未设置的变量返回 TRUE！！！
<?php
ini_set('error_reporting',E_ALL);
ini_set('display_errors','1');
empty($var);
?>要创建一个只接受数组的空函数，可以使用类型提示
<?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 (!empty($var)) { // 它不是空的 }`，您可以简单地说 `if (check_not_empty($var)) { // 它不是空的 }`。
如果您希望仅包含空格（例如制表符或空格）的字符串被视为为空，则执行：`check_not_empty($var, 1)`。
如果您想检查字符串是否为空，则执行：`!check_not_empty($var)`。
因此，每当您想要检查表单字段是否存在并包含值时，只需执行：`if (check_not_empty($_POST['foo'], 1))`
不再需要执行 `if (isset() && !empty())` 了 =]请注意，`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关于下面自建的 empty 函数的说明
`function_exists()` 对语言结构返回 false，而 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) ? "为空" : "不为空") . " / " . (isset($v) ? "已设置" : "未设置");
}
/*
结果：
1 => 为空 / 已设置
2 => 不为空 / 已设置
3 => 为空 / 未设置
4 => 数组为空 / 已设置
5 => 为空 / 已设置
6 => 1 不为空 / 已设置
7 => 0 为空 / 已设置
8 => 0 为空 / 已设置
*/