PHP 8.1.6 Released!

比较运算符

比较运算符,如同它们名称所暗示的,允许对两个值进行比较。还可以参考 PHP 类型比较表看不同类型相互比较的例子。

比较运算符
例子 名称 结果
$a == $b 等于 true,如果类型转换后 $a 等于 $b
$a === $b 全等 true,如果 $a 等于 $b,并且它们的类型也相同。
$a != $b 不等 true,如果类型转换后 $a 不等于 $b
$a <> $b 不等 true,如果类型转换后 $a 不等于 $b
$a !== $b 不全等 true,如果 $a 不等于 $b,或者它们的类型不同。
$a < $b 小与 true,如果 $a 严格小于 $b
$a > $b 大于 true,如果 $a 严格大于 $b
$a <= $b 小于等于 true,如果 $a 小于或者等于 $b
$a >= $b 大于等于 true,如果 $a 大于或者等于 $b
$a <=> $b 太空船运算符(组合比较符) $a小于、等于、大于 $b时 分别返回一个小于、等于、大于0的 int 值。

当两个操作对象都是 数字字符串, 或一个是数字另一个是 数字字符串, 就会自动按照数值进行比较。 此规则也适用于 switch 语句。 当比较时用的是 ===!==, 则不会进行类型转换——因为不仅要对比数值,还要对比类型。

警告

PHP 8.0.0 之前,如果 string 与数字或者数字字符串进行比较, 则在比较前会将 string 转化为数字。 在如下示例中会出现不可预料的结果:

<?php
var_dump
(== "a");
var_dump("1" == "01");
var_dump("10" == "1e1");
var_dump(100 == "1e2");

switch (
"a") {
case 
0:
    echo 
"0";
    break;
case 
"a":
    echo 
"a";
    break;
}
?>

以上例程在 PHP 7 中的输出:

bool(true)
bool(true)
bool(true)
bool(true)
0

以上例程在 PHP 8 中的输出:

bool(false)
bool(true)
bool(true)
bool(true)
a

<?php
// 整数
echo <=> 1// 0
echo <=> 2// -1
echo <=> 1// 1

// 浮点数
echo 1.5 <=> 1.5// 0
echo 1.5 <=> 2.5// -1
echo 2.5 <=> 1.5// 1

// 字符串
echo "a" <=> "a"// 0
echo "a" <=> "b"// -1
echo "b" <=> "a"// 1

echo "a" <=> "aa"// -1
echo "zz" <=> "aa"// 1

// 数组
echo [] <=> []; // 0
echo [123] <=> [123]; // 0
echo [123] <=> []; // 1
echo [123] <=> [121]; // 1
echo [123] <=> [124]; // -1

// 对象
$a = (object) ["a" => "b"];
$b = (object) ["a" => "b"];
echo 
$a <=> $b// 0

$a = (object) ["a" => "b"];
$b = (object) ["a" => "c"];
echo 
$a <=> $b// -1

$a = (object) ["a" => "c"];
$b = (object) ["a" => "b"];
echo 
$a <=> $b// 1

// 不仅仅比较值,而且也会匹配键
$a = (object) ["a" => "b"];
$b = (object) ["b" => "b"];
echo 
$a <=> $b// 1

?>

对于多种类型,比较运算符根据下表比较(按顺序)。

比较多种类型
运算数 1 类型 运算数 2 类型 结果
nullstring string null 转换为 "",进行数字或词汇比较
boolnull 任何其它类型 转换为 boolfalse < true
object object 内置类可以定义自己的比较,不同类不能比较,相同类和数组同样方式比较属性(PHP 4 中),PHP 5 有其自己的说明
stringresourceintfloat stringresourceintfloat 将字符串和资源转换成数字,按普通数学比较
array array 具有较少成员的数组较小,如果运算数 1 中的键不存在于运算数 2 中则数组无法比较,否则挨个值比较(见下例)
object 任何其它类型 object 总是更大
array 任何其它类型 array 总是更大

示例 #1 Boolean/null comparison

<?php
// Bool 和 null 总是作为 bool 比较
var_dump(== TRUE);  // TRUE - same as (bool)1 == TRUE
var_dump(== FALSE); // TRUE - same as (bool)0 == FALSE
var_dump(100 TRUE); // FALSE - same as (bool)100 < TRUE
var_dump(-10 FALSE);// FALSE - same as (bool)-10 < FALSE
var_dump(min(-100, -10NULL10100)); // NULL - (bool)NULL < (bool)-100 is FALSE < TRUE
?>

示例 #2 标准数组比较代码

<?php
// 数组是用标准比较运算符这样比较的
function standard_array_compare($op1$op2)
{
    if (
count($op1) < count($op2)) {
        return -
1// $op1 < $op2
    
} elseif (count($op1) > count($op2)) {
        return 
1// $op1 > $op2
    
}
    foreach (
$op1 as $key => $val) {
        if (!
array_key_exists($key$op2)) {
            return 
null// uncomparable
        
} elseif ($val $op2[$key]) {
            return -
1;
        } elseif (
$val $op2[$key]) {
            return 
1;
        }
    }
    return 
0// $op1 == $op2
}
?>

警告

比较浮点数

由于浮点数 float 的内部表达方式,不应比较两个浮点数float是否相等。

更多信息参见 float

三元运算符

另一个条件运算符是“?:”(或三元)运算符 。

示例 #3 赋默认值

<?php
// 三元运算符的例子
$action = (empty($_POST['action'])) ? 'default' $_POST['action'];

// 以上等同于以下的  if/else 语句
if (empty($_POST['action'])) {
    
$action 'default';
} else {
    
$action $_POST['action'];
}

?>
表达式 (expr1) ? (expr2) : (expr3)expr1 求值为 true 时的值为 expr2,在 expr1 求值为 false 时的值为 expr3

可以省略三元运算符中间那部分。表达式 expr1 ?: expr3expr1 求值为 true 时返回 expr1,否则返回 expr3

注意: 注意三元运算符是个语句,因此其求值不是变量,而是语句的结果。如果想通过引用返回一个变量这点就很重要。在一个通过引用返回的函数中语句 return $var == 42 ? $a : $b; 将不起作用,以后的 PHP 版本会为此发出一条警告。

注意:

建议避免将三元运算符堆积在一起使用。和其他语言相比, 当在单个表达式中使用多个未加括号的三元运算符时会造成 PHP 运算结果不清晰。 甚至在 PHP 8.0.0 之前,三元运算符是从左到右执行的, 而大多数其他编程语言是从右到左的。 自 PHP 7.4.0 起,弃用依靠左联。 PHP 8.0.0 起,三元运算符是非关联的。

示例 #4 不清晰的三元运算符行为

<?php
// 乍看起来下面的输出是 'true'
echo (true 'true' false 't' 'f');

// 然而,上面语句的实际输出是't',因为在 PHP 8.0.0 之前三元运算符是左联的

// 下面是与上面等价的语句,但更清晰
echo ((true 'true' 'false') ? 't' 'f');

// 这里可以看到第一个表达式的计算结果是 “true”,第二个表达式的计算结果为 (bool)true,
// 因此返回第二个三元表达式的 true 分支。
?>

NULL 合并运算符

而且存在 "??" (NULL 合并)运算符。

示例 #5 设置默认值

<?php
// NULL 合并运算符的例子
$action $_POST['action'] ?? 'default';

// 以上例子等同于于以下 if/else 语句
if (isset($_POST['action'])) {
    
$action $_POST['action'];
} else {
    
$action 'default';
}

?>
expr1null,表达式 (expr1) ?? (expr2) 等同于 expr2,否则为 expr1

尤其要注意,当不存在左侧的值时,此运算符也和 isset() 一样不会产生警告。 对于 array 键尤其有用。

注意: 请注意:NULL 合并运算符是一个表达式,产生的也是表达式结果,而不是变量。 返回引用变量时需要强调这一点。 因此,在返回引用的函数里就无法使用这样的语句:return $foo ?? $bar;,还会提示警告。

注意:

请注意,NULL 合并运算符支持简单的嵌套:

示例 #6 嵌套 NULL 合并运算符

<?php

$foo 
null;
$bar null;
$baz 1;
$qux 2;

echo 
$foo ?? $bar ?? $baz ?? $qux// 输出 1

?>

add a note add a note

User Contributed Notes 10 notes

up
162
crazy888s at hotmail dot com
12 years ago
I couldn't find much info on stacking the new ternary operator, so I ran some tests:

<?php
echo 0 ?: 1 ?: 2 ?: 3; //1
echo 1 ?: 0 ?: 3 ?: 2; //1
echo 2 ?: 1 ?: 0 ?: 3; //2
echo 3 ?: 2 ?: 1 ?: 0; //3

echo 0 ?: 1 ?: 2 ?: 3; //1
echo 0 ?: 0 ?: 2 ?: 3; //2
echo 0 ?: 0 ?: 0 ?: 3; //3
?>

It works just as expected, returning the first non-false value within a group of expressions.
up
3
Sumon Mahmud
2 years ago
Extending from here: https://www.php.net/manual/en/language.operators.comparison.php#121907

$a = ['a' => 1, 'b' => 2, 'c' => 3, 'e' => 4];
$b = ['a' => 1, 'b' => 2, 'd' => 3, 'e' => 4];

echo $a > $b; // 0
echo $b > $a; // 0
echo $a <$b; // 0
echo $b < $a; // 0

If using spaceship operator then it is returning true like :

echo $a <=> $b; //1
echo $b <=> $a; //1
echo $a <=> $b; //1
echo $b <=> $a; //1
up
6
niall at maranelda dot org
4 years ago
Care must be taken when using the spaceship operator with arrays that do not have the same keys:

- Contrary to the notes above ("Example #2 Transcription of standard array comparison"), it does *not* return null if the left-hand array contains a key that the right-hand array does not.
- Because of this, the result depends on the order you do the comparison in.

For example:

<?php
$a
= ['a' => 1, 'b' => 2, 'c' => 3, 'e' => 4];
$b = ['a' => 1, 'b' => 2, 'd' => 3, 'e' => 4];

var_dump($a <=> $b);        // int(1) : $a > $b because $a has the 'c' key and $b doesn't.

var_dump($b <=> $a);        // int(1) : $b > $a because $b has the 'd' key and $a doesn't.
?>
up
19
rshawiii at yahoo dot com
16 years ago
You can't just compare two arrays with the === operator
like you would think to find out if they are equal or not.  This is more complicated when you have multi-dimensional arrays.  Here is a recursive comparison function.

<?php
/**
* Compares two arrays to see if they contain the same values.  Returns TRUE or FALSE.
* usefull for determining if a record or block of data was modified (perhaps by user input)
* prior to setting a "date_last_updated" or skipping updating the db in the case of no change.
*
* @param array $a1
* @param array $a2
* @return boolean
*/
function array_compare_recursive($a1, $a2)
{
   if (!(
is_array($a1) and (is_array($a2)))) { return FALSE;}   
   
   if (!
count($a1) == count($a2))
      {
       return
FALSE; // arrays don't have same number of entries
     
}
     
   foreach (
$a1 as $key => $val)
   {
       if (!
array_key_exists($key, $a2))
           {return
FALSE; // uncomparable array keys don't match
             
}
       elseif (
is_array($val) and is_array($a2[$key]))  // if both entries are arrays then compare recursive
          
{if (!array_compare_recursive($val,$a2[$key])) return FALSE;
           }
       elseif (!(
$val === $a2[$key])) // compare entries must be of same type.
          
{return FALSE;
           }
   }
   return
TRUE; // $a1 === $a2
}
?>
up
21
adam at caucho dot com
16 years ago
Note: according to the spec, PHP's comparison operators are not transitive.  For example, the following are all true in PHP5:

"11" < "a" < 2 < "11"

As a result, the outcome of sorting an array depends on the order the elements appear in the pre-sort array.  The following code will dump out two arrays with *different* orderings:

<?php
$a
= array(2,    "a""11", 2);
$b = array(2,    "11", "a"2);
sort($a);
var_dump($a);
sort($b);
var_dump($b);
?>

This is not a bug report -- given the spec on this documentation page, what PHP does is "correct".  But that may not be what was intended...
up
14
bishop
15 years ago
When you want to know if two arrays contain the same values, regardless of the values' order, you cannot use "==" or "===".  In other words:

<?php
(array(1,2) == array(2,1)) === false;
?>

To answer that question, use:

<?php
function array_equal($a, $b) {
    return (
is_array($a) && is_array($b) && array_diff($a, $b) === array_diff($b, $a));
}
?>

A related, but more strict problem, is if you need to ensure that two arrays contain the same key=>value pairs, regardless of the order of the pairs.  In that case, use:

<?php
function array_identical($a, $b) {
    return (
is_array($a) && is_array($b) && array_diff_assoc($a, $b) === array_diff_assoc($b, $a));
}
?>

Example:
<?php
$a
= array (2, 1);
$b = array (1, 2);
// true === array_equal($a, $b);
// false === array_identical($a, $b);

$a = array ('a' => 2, 'b' => 1);
$b = array ('b' => 1, 'a' => 2);
// true === array_identical($a, $b)
// true === array_equal($a, $b)
?>

(See also the solution "rshawiii at yahoo dot com" posted)
up
4
Ryan Mott
2 years ago
Searching for "double question mark" operator should find this page (and hopefully after this comment the crawlers will agree)
up
9
Cuong Huy To
10 years ago
In the table "Comparison with Various Types", please move the last line about "Object" to be above the line about "Array", since Object is considered to be greater than Array (tested on 5.3.3)

(Please remove my "Anonymous" post of the same content before. You could check IP to see that I forgot to type my name)
up
1
Tahazzot
1 year ago
Very careful when reading PHP documentation, Here's a lot of miss information.

According to documentation, They say's (int) 0 == (string) "a" is true. But it is not in PHP 8.

var_dump(0 == "a"); // 0 == 0 -> true

Now In PHP 8 it's False.
up
4
Marcin Kuzawiski
6 years ago
A < B and still B < A...

$A = [1 => 1, 2 => 0, 3 => 1];
$B = [1 => 1, 3 => 0, 2 => 1];

var_dump($A < $B);  // TRUE
var_dump($B < $A);  // TRUE

var_dump($A > $B);  // TRUE
var_dump($B > $A);  // TRUE

Next - C and D are comparable, but neither C < D nor D < C (and still C != D)...

$C = [1 => 1, 2 => 1, 3 => 0];
$D = [1 => 1, 3 => 1, 2 => 0];

var_dump($C < $D); // FALSE
var_dump($D < $C); // FALSE

var_dump($C > $D); // FALSE
var_dump($D > $C); // FALSE

var_dump($D == $C); // FALSE
To Top