PHP: 比较运算符 - Manual

<?php
// 整数
echo 1 <=> 1 ; // 0
echo 1 <=> 2 ; // -1
echo 2 <=> 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 [ 1 , 2 , 3 ] <=> [ 1 , 2 , 3 ]; // 0
echo [ 1 , 2 , 3 ] <=> []; // 1
echo [ 1 , 2 , 3 ] <=> [ 1 , 2 , 1 ]; // 1
echo [ 1 , 2 , 3 ] <=> [ 1 , 2 , 4 ]; // -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

?> <?php
// Bool 和 null 总是作为 bool 比较
var_dump ( 1 == TRUE ); // TRUE - same as (bool)1 == TRUE
var_dump ( 0 == 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 , - 10 , NULL , 10 , 100 )); // NULL - (bool)NULL < (bool)-100 is FALSE < TRUE
?> <?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 1 ;
} elseif ( $val < $op2 [ $key ]) {
return - 1 ;
} elseif ( $val > $op2 [ $key ]) {
return 1 ;
}
}
return 0 ; // $op1 == $op2
}
?> 注意三元运算符是个语句，因此其求值不是变量，而是语句的结果。如果想通过引用返回一个变量这点就很重要。在一个通过引用返回的函数中语句


   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 合并运算符是一个表达式，产生的也是表达式结果，而不是变量。返回引用变量时需要强调这一点。因此，在返回引用的函数里就无法使用这样的语句：


   return $foo ?? $bar;

，还会提示警告。 null 合并运算符的优先级较低。这意味着如果将它与其它运算符（比如字符串链接或者算术运算符）混合使用，可能需要括号。 <?php
// $name 未定义，引发警告。
print 'Mr. ' . $name ?? 'Anonymous' ;

// 打印 "Mr. Anonymous"
print 'Mr. ' . ( $name ?? 'Anonymous' );
?> 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. Please be careful when you try to compare strings that have a plus sign `+` at the beginning (such as phone number, etc). When you use the Equal operator `==` PHP will ignore the plus sign. Use Identical operator `===` instead

Example:

$str1 = "62";
$str2 = "+62";

var_dump($str1 == $str2); // bool(true)
var_dump($str1 === $str2); // bool(false) 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 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... 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
}
?> 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) 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.
?> 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 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) Please note that using the null coalescing operator to check properties on a class that has the __get magic method (without an __isset magic method) invokes the magic method.

For example:

<?php

class A
{
public function __get ( $property )
{
echo 'Called __get for ' . $property . PHP_EOL ;
}
}

$a = new A ();

echo 'Trying null coalescing operator' . PHP_EOL ;
$b = $a -> test ?? 5 ;

echo 'Trying isset()' . PHP_EOL ;
if (isset( $a -> test )) {
$b = $a -> test ;
} else {
$b = 5 ;
}

?>