PHP平等（==双重平等）和身份（===三重等于）的比较操作员有何不同？

Question

==和===之间有什么区别？

• 松散的==比较如何工作？
• 严格的===比较如何工作？

有什么有用的例子？

Answer 1

== 和 === 之间的区别

松散 == 等于运算符和严格 === 之间的区别> 相同的运算符在手册中得到了准确的解释：

比较运算符

示例	名称	结果
$a == $b	等于	TRUE如果类型杂耍后 $a 等于 $b。
$a === $b	相同	如果 $a 等于 $b 并且它们属于相同类型，则为 TRUE。

---

松散 == 相等比较

如果您使用 == 运算符，或使用松散比较的任何其他比较运算符，例如 !=，< code><> 或 ==，您始终必须查看上下文以查看转换的内容、位置和原因，以了解转换的内容正在进行中。

转换规则

• 转换为布尔值
• 转换为整数
• 转换为浮点数
• 转换为字符串
• 转换为数组
• 转换为对象
• 转换为资源
• 转换为 NULL

类型比较表

作为参考和示例，您可以看到手册：

	TRUE	FALSE	1	0	-1	"1"	"0"	"-1"	NULL	array()	"php"	""
TRUE	TRUE	FALSE	TRUE	FALSE	TRUE	TRUE	FALSE	TRUE	FALSE	FALSE	TRUE	FALSE
FALSE	FALSE	TRUE	FALSE	TRUE	FALSE	FALSE	TRUE	FALSE	TRUE	TRUE	FALSE	真
1	真	假	真	假	假	真	假	假假	假假	假假	假	真假
0	假	假	真假	假假	真假	假	​	真假	真真	假	​	-1
假假	真假	假假	真假	假假	真假	假	真假	真假	假假	假假	假	​
1	真假	​	假	”	“	假假	​	​	​	​	​	​
"0"	FALSE	TRUE	FALSE	TRUE	FALSE	FALSE	TRUE	FALSE	FALSE	FALSE FALSE	FALSE	"
-1"	TRUE	FALSE	FALSE	FALSE	TRUE	FALSE	FALSE	TRUE	FALSE	FALSE	FALSE	FALSE
NULL	FALSE	TRUE	FALSE	TRUE	FALSE	FALSE	FALSE	FALSE	TRUE	TRUE	FALSE	TRUE
array()	FALSE	TRUE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	TRUE	TRUE	FALSE	FALSE
"php"	TRUE	FALSE	FALSE	TRUE	FALSE	FALSE	FALSE FALSE	FALSE	FALSE	TRUE	FALSE	"
"	FALSE	TRUE	FALSE	TRUE	FALSE	FALSE	FALSE	FALSE	TRUE	FALSE	FALSE	TRUE

严格 === 相同比较

如果您使用的是=== 运算符，或任何其他使用严格比较的比较运算符，例如 !== 或 ===，那么您始终可以确保类型不会神奇地改变，因为不会进行任何转换。因此，通过严格比较，类型和值必须相同，而不仅仅是值。

类型比较表

作为参考和示例，您可以在 中查看比较表手册：

与===严格比较

	TRUE	FALSE	1	0	-1	"1"	"0"	"-1"	NULL	array()	"php"	""
TRUE	TRUE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE
FALSE	FALSE	TRUE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	FALSE	错误
1	​​错误	错误	正确	假假	假假	假假	假假	假假	假假	假假	假	真假
0	假假	假假	假假	​	假假	​	​	假假	假假	假	​	​
-1	假假	假假	假	真假	假	假假	假假	假假	假假	假假	假	​
1	​	​	“	”	假	真假	假假	假假	假假	假假	假假	假假
”	假假	假假	假假	假假	假假	真假	假假	假假	假假	假假	假假	假
”	假假	假假	假假	假假	假假	“	假假	0	“	真假	假假	-1
​	​	​	​	​	​	假假	假	真假	假假	假假	假假	假假
数组	假假	假假	假假	假假	假假	假假	假假	假假	真假	假假	假假	假假
”	假假	假假	“	假假	（	假假	）	php	假假	假	真假	“
”	​	​	​	​	​	​	假假	假假	假假	假	​	真

编者注 - 之前已正确引用过此内容，但作为降价表格更具可读性。这不是抄袭

Answer 2

如果两个不同类型不同，则运算符 == 在它们之间进行强制转换，而 === 运算符则执行“类型安全比较”。这意味着只有当两个操作数具有相同的类型和相同的值时才会返回 true。

示例：

1 === 1: true
1 == 1: true
1 === "1": false // 1 is an integer, "1" is a string
1 == "1": true // "1" gets casted to an integer, which is 1
"foo" === "foo": true // both operands are strings and have the same value

警告：具有等效成员的同一类的两个实例与 === 运算符不匹配。例子：

$a = new stdClass();
$a->foo = "bar";
$b = clone $a;
var_dump($a === $b); // bool(false)

Answer 3

一图胜千字：

PHP Double Equals == 等式图表：

PHP 三重等于 === 等式图表：

创建这些图像的源代码：PHP 平等图表

大师冥想

那些希望保持理智的人，请不要继续阅读，因为这些都没有任何意义，除非说这就是 PHP 的疯狂分形的设计方式。

1. NAN != NAN 但NAN == true。

2. 如果 left 是数字，

   == 将把左右操作数转换为数字。所以 123 == "123foo"，但是 "123" != "123foo"

3. 引号中的十六进制字符串有时是浮点数，并且会意外地转换为违背你的意愿浮动，导致运行时错误。

4. == 不具有传递性，因为 "0"== 0，并且 0 == "" 但 "0" != ""

5. 尚未声明的 PHP 变量 为 false。尽管 PHP 有一种方法来表示未定义的变量，但该功能通过 == 被禁用。

6. “6”==“6”、“4.2”==“4.20”和“133”==“0133” >，但是133！= 0133。但是 "0x10" == "16" 和 "1e3" == "1000" 会在未经您的指示或同意的情况下发生意外的字符串转换为八进制，从而导致运行时错误。

7. False == 0、""、[] 和 "0"。

8. 如果您将数字加 1 并且它们已经保持最大值，则它们不会回绕。相反，它们被转换为无穷大。

9. 新班级 == 到 1。

10. False 是最危险的值，因为 False 是 == 到大多数其他变量，这大多违背了它的目的。

希望：

如果您使用 PHP，则不应使用双等号运算符，因为如果您使用三等号，则唯一需要担心的边缘情况是 NAN 和数字非常接近其数据类型的最大值，以至于它们会被强制转换为无穷大。使用双等号，任何东西都可以是令人惊讶的 == 到任何东西，或者可以是违背你的意愿的惊喜，并且 != 到它显然应该相等的东西。

在 PHP 中使用 == 的任何地方都是一种糟糕的代码味道，因为隐式转换规则暴露了 85 个错误，这些规则似乎是由数百万程序员通过布朗运动编程设计的。

Answer 4

关于JavaScript：

===操作员的工作与==运算符相同，但它要求其操作数不仅具有相同的值，而且具有相同的数据类型。

例如，下面的示例将显示“ x和y相等”，而不是“ x和y是相同的”。

var x = 4;
var y = '4';
if (x == y) {
    alert('x and y are equal');
}
if (x === y) {
    alert('x and y are identical');
}

Answer 5

有关对象比较的其他答案的补充：

==使用对象的名称及其值比较对象。如果两个对象具有相同的类型并且具有相同的成员值，则$ a == $ b产生true。

===比较对象的内部对象ID。即使成员相等，$ a！== $ b如果它们不是完全相同的对象。

class TestClassA {
    public $a;
}

class TestClassB {
    public $a;
}

$a1 = new TestClassA();
$a2 = new TestClassA();
$b = new TestClassB();

$a1->a = 10;
$a2->a = 10;
$b->a = 10;

$a1 == $a1;
$a1 == $a2;  // Same members
$a1 != $b;   // Different classes

$a1 === $a1;
$a1 !== $a2; // Not the same object

Answer 6

这都是关于数据类型的。以 BOOL（true 或 false）为例：

true 也等于 1 并且
false 也等于 0

比较时 == 不关心数据类型：
因此，如果您有一个为 1 的变量（也可能是 true）：

$var=1;

然后与 == 进行比较：

if ($var == true)
{
    echo"var is true";
}

但是 $var 实际上并不等于 true，不是吗？它的 int 值为 1，而该值又等于 true。

使用===，检查数据类型以确保两个变量/对象/任何内容使用相同的类型。

因此，如果我这样做，

if ($var === true)
{
    echo "var is true";
}

这个条件就不会成立，因为 $var !== true 它只是 == true （如果你知道我的意思）。

你为什么需要这个？

简单 - 让我们看一下 PHP 的一个函数： array_search()：

array_search() 函数只是在数组中搜索某个值，然后返回该值的键找到该值的元素。如果在数组中找不到该值，则返回false。但是，如果您对存储在数组的第一个元素中的值执行array_search()（数组键为0< /code>)....array_search() 函数将返回 0...这等于 false..

因此，如果您这样做：

$arr = array("name");
if (array_search("name", $arr) == false)
{
    // This would return 0 (the key of the element the val was found
    // in), but because we're using ==, we'll think the function
    // actually returned false...when it didn't.
}

那么，您知道这现在怎么会成为一个问题吗？ ？

大多数人在检查函数是否返回 false 时不会使用 == false。相反，他们使用 !。但实际上，这与使用 ==false 完全相同，因此如果您这样做：

$arr = array("name");
if (!array_search("name", $arr)) // This is the same as doing (array_search("name", $arr) == false)

因此对于类似的事情，您将使用 === 代替，这样检查数据类型。

Answer 7

PHP Double Equals == ：

在大多数编程语言中，比较运算符 (==) 一方面检查数据类型，另一方面检查变量的内容是否相等。 PHP 中的标准比较运算符 (==) 的行为有所不同。这会在比较之前尝试将两个变量转换为相同的数据类型，然后才检查这些变量的内容是否相同。获得以下结果：

<?php
    var_dump( 1 == 1 );     // true
    var_dump( 1 == '1' );   // true
    var_dump( 1 == 2 );     // false
    var_dump( 1 == '2' );   // false
    var_dump( 1 == true );  // true
    var_dump( 1 == false ); // false
?>

PHP Triple Equals === ：

该运算符还会检查变量的数据类型，仅当两个变量具有相同的内容和相同的数据类型时才返回 (bool)true。因此，以下内容是正确的：

<?php
    var_dump( 1 === 1 );     // true
    var_dump( 1 === '1' );   // false
    var_dump( 1 === 2 );     // false
    var_dump( 1 === '2' );   // false
    var_dump( 1 === true );  // false
    var_dump( 1 === false ); // false
?>

阅读 PHP 中 == 和 === 有什么区别

Answer 8

您将使用===测试函数还是变量是错误的，而不仅仅是等于false（零或一个空字符串）。

$needle = 'a';
$haystack = 'abc';
$pos = strpos($haystack, $needle);
if ($pos === false) {
    echo $needle . ' was not found in ' . $haystack;
} else {
    echo $needle . ' was found in ' . $haystack . ' at location ' . $pos;
}

在这种情况下，STRPO将返回0等于在测试中的false

if ($pos == false)

或

if (!$pos)

您在这里想要的不是什么。

Answer 9

到目前为止，所有答案都忽略了 === 的危险问题。顺便指出，但没有强调，整数和双精度是不同的类型，因此以下代码：

$n = 1000;
$d = $n + 0.0e0;
echo '<br/>'. ( ($n ==  $d)?'equal' :'not equal' );
echo '<br/>'. ( ($n === $d)?'equal' :'not equal' );

给出：

 equal
 not equal

请注意，这不是“舍入错误”的情况。这两个数字直到最后一位都完全相等，但它们具有不同的类型。

这是一个令人讨厌的问题，因为如果所有数字都足够小（其中“足够小”取决于您运行的硬件和操作系统），使用 === 的程序可以愉快地运行多年。但是，如果碰巧某个整数恰好足够大，可以转换为双精度型，则其类型将“永远”更改，即使后续操作或许多操作可能会将其值恢复为小整数。而且，情况变得更糟。它可以传播——双重感染可以传播到它接触到的任何东西，一次一个计算。

例如，在现实世界中，这可能是处理 2038 年之后日期的程序中的一个问题。此时，UNIX 时间戳（自 1970-01-01 00:00:00 UTC 以来的秒数）将需要超过 32 位，因此它们的表示形式将在某些系统上“神奇地”切换为双倍。因此，如果您计算两次之间的差异，您可能会得到几秒钟的结果，但作为双精度数，而不是 2017 年发生的整数结果。

我认为这比字符串和数字之间的转换要糟糕得多，因为这是微妙的。我发现跟踪什么是字符串和什么是数字很容易，但是跟踪数字中的位数超出了我的范围。

因此，在上面的答案中，有一些不错的表格，但 1（作为整数）和 1（微妙双精度）和 1.0（明显双精度）之间没有区别。另外，建议您应该始终使用 === 而从不使用 == ，这种建议并不好，因为 === 有时会在 == 正常工作的情况下失败。另外，JavaScript 在这方面并不等效，因为它只有一种数字类型（内部可能有不同的按位表示，但不会导致 === 出现问题）。

我的建议是——两者都不用。您需要编写自己的比较函数才能真正解决这个问题。

Answer 10

变量有类型和值。

• $var = "test" 是一个包含 "test" 的字符串
• $var2 = 24 是一个整数 vhose 值为 24。

当您使用这些变量（在 PHP 中）时，有时您没有正确的类型。
例如，如果

if ($var == 1) {... do something ...}

PHP 必须将 $var 转换（“转换”）为整数。在这种情况下，“$var == 1”为 true，因为任何非空字符串都会转换为 1。

使用 === 时，您会检查值和类型是否相等，因此“$var === 1”是假的。

这很有用，例如，当您有一个可以返回 false（出错时）和 0（结果）的函数时：

if(myFunction() == false) { ... error on myFunction ... }

此代码是错误的，就像 myFunction() 返回 0 一样，它会被强制转换为 false你似乎有一个错误。正确的代码是：

if(myFunction() === false) { ... error on myFunction ... }

因为测试是返回值“是布尔值并且是假”而不是“可以转换为假”。

Answer 11

<?php

    /**
     * Comparison of two PHP objects                         ==     ===
     * Checks for
     * 1. References                                         yes    yes
     * 2. Instances with matching attributes and its values  yes    no
     * 3. Instances with different attributes                yes    no
     **/

    // There is no need to worry about comparing visibility of property or
    // method, because it will be the same whenever an object instance is
    // created, however visibility of an object can be modified during run
    // time using ReflectionClass()
    // http://php.net/manual/en/reflectionproperty.setaccessible.php
    //
    class Foo
    {
        public $foobar = 1;

        public function createNewProperty($name, $value)
        {
            $this->{$name} = $value;
        }
    }

    class Bar
    {
    }
    // 1. Object handles or references
    // Is an object a reference to itself or a clone or totally a different object?
    //
    //   ==  true   Name of two objects are same, for example, Foo() and Foo()
    //   ==  false  Name of two objects are different, for example, Foo() and Bar()
    //   === true   ID of two objects are same, for example, 1 and 1
    //   === false  ID of two objects are different, for example, 1 and 2

    echo "1. Object handles or references (both == and    ===) <br />";

    $bar = new Foo();    // New object Foo() created
    $bar2 = new Foo();   // New object Foo() created
    $baz = clone $bar;   // Object Foo() cloned
    $qux = $bar;         // Object Foo() referenced
    $norf = new Bar();   // New object Bar() created
    echo "bar";
    var_dump($bar);
    echo "baz";
    var_dump($baz);
    echo "qux";
    var_dump($qux);
    echo "bar2";
    var_dump($bar2);
    echo "norf";
    var_dump($norf);

    // Clone: == true and === false
    echo '$bar == $bar2';
    var_dump($bar == $bar2); // true

    echo '$bar === $bar2';
    var_dump($bar === $bar2); // false

    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    echo '$bar === $baz';
    var_dump($bar === $baz); // false

    // Object reference: == true and === true
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    echo '$bar === $qux';
    var_dump($bar === $qux); // true

    // Two different objects: == false and === false
    echo '$bar == $norf';
    var_dump($bar == $norf); // false

    echo '$bar === $norf';
    var_dump($bar === $norf); // false

    // 2. Instances with matching attributes and its values (only ==).
    //    What happens when objects (even in cloned object) have same
    //    attributes but varying values?

    // $foobar value is different
    echo "2. Instances with matching attributes  and its values (only ==) <br />";

    $baz->foobar = 2;
    echo '$foobar' . " value is different <br />";
    echo '$bar->foobar = ' . $bar->foobar . "<br />";
    echo '$baz->foobar = ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false

    // $foobar's value is the same again
    $baz->foobar = 1;
    echo '$foobar' . " value is the same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // true

    // Changing values of properties in $qux object will change the property
    // value of $bar and evaluates true always, because $qux = &$bar.
    $qux->foobar = 2;
    echo '$foobar value of both $qux and $bar is 2, because $qux = &$bar' . "<br />";
    echo '$qux->foobar is ' . $qux->foobar . "<br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$bar == $qux';
    var_dump($bar == $qux); // true

    // 3. Instances with different attributes (only ==)
    //    What happens when objects have different attributes even though
    //    one of the attributes has same value?
    echo "3. Instances with different attributes (only ==) <br />";

    // Dynamically create a property with the name in $name and value
    // in $value for baz object
    $name = 'newproperty';
    $value = null;
    $baz->createNewProperty($name, $value);
    echo '$baz->newproperty is ' . $baz->{$name};
    var_dump($baz);

    $baz->foobar = 2;
    echo '$foobar' . " value is same again <br />";
    echo '$bar->foobar is ' . $bar->foobar . "<br />";
    echo '$baz->foobar is ' . $baz->foobar . "<br />";
    echo '$bar == $baz';
    var_dump($bar == $baz); // false
    var_dump($bar);
    var_dump($baz);
?>

Answer 12

==（相等）和===（相同相等）之间的区别

PHP 提供了两个比较运算符来检查两个值是否相等。这两者之间的主要区别在于'=='检查两个操作数的值是否相等。另一方面，'===' 检查操作数的值和类型是否相等。

==（等于）

===（相同相等）

示例 =>

<?php 
    $val1 = 1234;
    $val2 = "1234";
    var_dump($val1 == $val2);// output => bool(true)
    //It checks only operands value
?> 


<?php 
    $val1 = 1234;
    $val2 = "1234";
    var_dump($val1 === $val2);// output => bool(false)
    //First it checks type then operands value
?> 

如果我们输入cast $val2 to (int)$val2 or (string)$val1 那么它返回 true

   <?php 
        $val1 = 1234;
        $val2 = "1234";
        var_dump($val1 === (int)$val2);// output => bool(true)
        //First it checks type then operands value
    ?> 

OR

  <?php 
        $val1 = 1234;
        $val2 = "1234";
        var_dump($val1 === (int)$val2);// output => bool(true)
        //First it checks type then operands value
    ?> 

Answer 13

PHP 数组和对象中的 == 和 === 有两个没有人提到的区别：两个具有不同键排序的数组和对象。

具有不同键排序的两个数组

如果您有两个数组，其键排序不同，但具有相同的键值映射，则它们是完全不同的（即使用 ===）。如果您对数组进行键排序，并尝试将排序后的数组与原始数组进行比较，这可能会导致问题。

例如：

$arrayUnsorted = [
    "you" => "you",
    "I" => "we",
];

$arraySorted = $arrayUnsorted;
ksort($arraySorted);

$arrayUnsorted == $arraySorted; // true
$arrayUnsorted === $arraySorted; // false

对象

请记住，主要规则是两个不同的对象永远不会严格相等。请看下面的示例：

$stdClass1 = new stdClass();
$stdClass2 = new stdClass();
$clonedStdClass1 = clone $stdClass1;

$stdClass1 == $stdClass2; // true
$stdClass1 === $stdClass2; // false
$stdClass1 == $clonedStdClass1; // true
$stdClass1 === $clonedStdClass1; // false

注意：将一个对象分配给另一个变量不会创建副本 - 相反，它会创建对同一对象的引用。 请参阅此处。

注意：从 PHP7 开始，匿名类< /a> 被引入。在上面的测试中，new class {} 和 new stdClass() 之间没有区别。