`==`和`===`

Question

==和===之间的区别是什么？

松散的==比较究竟是如何运作的？
严格的===比较究竟是如何运作的？

什么是有用的例子？

Answer 1

`==`和`===`

之间的差异

松散的==相等运算符与严格===相同运算符之间的差异在manual中有详细解释：

比较运算符

┌──────────┬───────────┬───────────────────────────────────────────────────────────┐
│ Example  │ Name      │ Result                                                    │
├──────────┼───────────┼───────────────────────────────────────────────────────────┤
│$a ==  $b │ Equal     │ TRUE if $a is equal to $b after type juggling.            │
│$a === $b │ Identical │ TRUE if $a is equal to $b, and they are of the same type. │
└──────────┴───────────┴───────────────────────────────────────────────────────────┘

松散`==`相等比较

如果您使用的是==运算符，或使用松散比较的任何其他比较运算符，例如!=，<>或==，您始终需要查看上下文，了解某些内容转换为什么，在哪里以及为何能够了解正在发生的事情。

转换规则

类型比较表

作为参考和示例，您可以在manual：

中看到比较表

与==

的松散比较

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ 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 │ TRUE  │
│ 1       │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ 0       │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ TRUE  │ FALSE   │ TRUE  │ TRUE  │
│ -1      │ TRUE  │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "1"     │ TRUE  │ FALSE │ TRUE  │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "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  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

严格`===`相同比较

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

类型比较表

作为参考和示例，您可以在manual：

中看到比较表

与===

进行严格比较

┌─────────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬───────┬─────────┬───────┬───────┐
│         │ 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 │ FALSE │
│ 1       │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ 0       │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ -1      │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "1"     │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "0"     │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE │ FALSE   │ FALSE │ FALSE │
│ "-1"    │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE │ FALSE   │ FALSE │ FALSE │
│ NULL    │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE  │ FALSE   │ FALSE │ FALSE │
│ array() │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ TRUE    │ FALSE │ FALSE │
│ "php"   │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ TRUE  │ FALSE │
│ ""      │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE │ FALSE   │ FALSE │ TRUE  │
└─────────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴───────┴─────────┴───────┴───────┘

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 Triple Equals `===` Equality chart：

创建这些图片的源代码：

https://github.com/sentientmachine/php_equality_charts

大师冥想

那些希望保持理智的人，不要再读了，因为这些都没有任何意义，只是说这就是PHP的疯狂分形的设计。

NAN != NAN但NAN == true。
==会将左右操作数转换为数字。所以123 == "123foo"，但"123" != "123foo"
引号中的十六进制字符串偶尔会浮动，并且会意外转换为违背您的意愿浮动，从而导致运行时错误。
==不具有传递性，因为"0"== 0和0 == ""只有"0" != ""
尚未声明的PHP变量为false，即使PHP有表示未定义变量的方法，但==禁用了该功能。
"6" == " 6"，"4.2" == "4.20"和"133" == "0133"，但133 != 0133。但"0x10" == "16"和"1e3" == "1000"暴露出意外的字符串转换为八进制将在没有您的指示或同意的情况下发生，从而导致运行时错误。
False == 0，""，[]和"0"。
当数字足够大时，它们是==无限。
新课程是== 1。
错误是最危险的价值，因为对大多数其他变量来说，假是= =，大多数都是为了挫败它的目的。

希望：

如果你使用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

简单来说：

==检查等效（仅限值）

===检查是否相同（值＆amp;＆amp;类型）

等价与相同：类比

1 + 1 = 2 + 0 （等效）

1 + 1 = 1 + 1 （相同）

在PHP中：

true == 1 （true - 等值）

true === 1 （错误 - 价值和＆amp;＆amp;类型不一样）

true是布尔
1是 int

Answer 7

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

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 < / strong>即可。但是，如果你对存储在数组的第一个元素（它的数组键为array_search()）中的值执行了0，该怎么办？ 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 8

一个例子是数据库属性可以为null或＆＃34;＆＃34;：

$attributeFromArray = "";
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //true
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //false

$attributeFromArray = null;
if ($attributeFromArray ==  ""){}  //true
if ($attributeFromArray === ""){}  //false
if ($attributeFromArray ==  null){}  //true
if ($attributeFromArray === null){}  //true

Answer 9

给定x = 5

1）运算符：==“等于”。 x == 8是假的 2）运算符：===“完全等于”（值和类型）x === 5为真，x === "5"为假

Answer 10

很少有例子

var_dump(5 == 5);    // True
var_dump(5 == "5");  // True because == checks only same value not type
var_dump(5 === 5);   // True
var_dump(5 === "5"); // False because value are same but data type are different.

P.S。

==仅比较值，不会打扰数据类型

VS

===比较值和数据类型

Answer 11

PHP 双等号 `==` :

在大多数编程语言中，比较运算符 (==) 一方面检查数据类型，另一方面检查变量的内容是否相等。 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 三重等于 `===` :

此运算符还检查变量的数据类型，并且仅当两个变量具有相同的内容和相同的数据类型时才返回 (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
?>

在What is the difference between == and === in PHP中阅读更多

Answer 12

简而言之，===的工作方式与大多数其他编程语言中的==相同。

PHP允许您进行真正有意义的比较。例如：

$y = "wauv";
$x = false;
if ($x == $y)
    ...

虽然这允许一些有趣的“快捷方式”，但你应该注意，因为一个不应该返回的东西（比如“错误”而不是数字）不会被抓住，你会想知道发生了什么。< / p>

在PHP中，==比较值并在必要时执行类型转换（例如，字符串“12343sdfjskfjds”将在整数比较中变为“12343”）。 ===将比较值AND类型，如果类型不相同则返回false。

如果您查看PHP手册，您将看到许多函数在函数失败时返回“false”，但是它们可能在成功的场景中返回0，这就是为什么他们建议执行“if（function（）！== false）“以避免错误。

Answer 13

$a = 5;   // 5 as an integer

var_dump($a == 5);       // compare value; return true
var_dump($a == '5');     // compare value (ignore type); return true
var_dump($a === 5);      // compare type/value (integer vs. integer); return true
var_dump($a === '5');    // compare type/value (integer vs. string); return false

但要小心。这是一个臭名昭着的问题。

// 'test' is found at position 0, which is interpreted as the boolean 'false'
if (strpos('testing', 'test')) {
    // code...
}

VS

// true, as strict comparison was made (0 !== false)
if (strpos('testing', 'test') !== false) {
    // code...
}

Answer 14

您可以使用===来测试函数或变量是否为false而不仅仅等于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;
}

在这种情况下，strpos将返回0，这将在测试

中等于false

if ($pos == false)

或

if (!$pos)

这不是你想要的。

Answer 15

php ==是一个比较运算符，用于比较变量的值。但是===会比较值和数据类型。

例如，

<?php 
  $var1 = 10;
  $var2 = '10';

  if($var1 == $var2) {
    echo 'Variables are equal';
  } else {
    echo 'Variables are not equal';
  }
?>

在这种情况下，即使数据类型不同，输出也将是“变量相等”。

但是，如果我们使用===而不是==，则输出将为“变量不相等”。 php首先比较变量的值，然后比较数据类型。这里的值是相同的，但是数据类型是不同的。

Answer 16

PHP是一种松散类型的语言。使用双等运算符可以对变量进行宽松的检查。

松散地检查一个值会允许一些相似但不相等的值等同于：

＆＃39;＆＃39;
空
假
0

使用双等运算符，所有这些值都等于等于。

Answer 17

至于何时使用另一个，请以PHP中的fwrite()函数为例。

此函数将内容写入文件流。根据PHP，“fwrite()返回写入的字节数，或者错误时返回FALSE。”如果要测试函数调用是否成功，则此方法存在缺陷：

if (!fwrite(stuff))
{
    log('error!');
}

它可以返回零（并且被认为是成功的），并且您的状况仍然会被触发。正确的方法是：

if (fwrite(stuff) === FALSE)
{
    log('error!');
}

Answer 18

<?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 19

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

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

给出：

 equal
 not equal

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

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

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

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

所以，在上面的答案中有一些很好的表，但没有区分1（作为整数）和1（微妙的双）和1.0（明显的双）。此外，建议您应该始终使用===和never ==并不是很好，因为===有时会失败，其中==正常工作。此外，JavaScript在这方面并不等同，因为它只有一种数字类型（在内部它可能有不同的逐位表示，但它不会导致===的问题）。

我的建议 - 两者都不使用。你需要编写自己的比较函数来真正解决这个问题。

Answer 20

===运算符应该比较精确内容相等，而==运算符则比较语义相等。特别是它会将字符串强制转换为数字。

平等是一个广阔的主题。请参阅the Wikipedia article on equality。

Answer 21

变量有一个类型和一个值。

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

当你使用这些变量时（在PHP中），有时你没有好的类型。例如，如果你这样做

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

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

使用===时，检查值AND THE TYPE是否相等，因此“$ var === 1”为false。

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

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

此代码错误，好像myFunction()返回0，它被转换为false并且您似乎有错误。正确的代码是：

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

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

Answer 22

==（相等）和 ===（完全相等）的区别

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

<块引用>

==（相等）

===（完全相同）

示例 =>

<?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 到 (int)$val2 或 (string)$val1 那么它返回 true

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

或

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

Answer 23

PHP数组和对象中的==和===之间有两个区别，我认为这里没有提到；具有不同键类型和对象的两个数组。

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

如果您有一个具有键排序的数组和另一个具有不同键排序的数组，则它们是严格不同的（即使用===）。如果对数组进行键排序，然后尝试将排序后的数组与原始数组进行比较，则可能会导致这种情况。

例如，考虑一个空数组。首先，我们尝试将一些新索引推入数组，而不进行任何特殊排序。一个很好的例子是一个以字符串为键的数组。现在深入一个例子：

// Define an array
$arr = [];

// Adding unsorted keys
$arr["I"] = "we";
$arr["you"] = "you";
$arr["he"] = "they";

现在，我们有了一个未排序键数组（例如，“他”排在“您”之后）。考虑相同的数组，但是我们按字母顺序对键进行排序：

// Declare array
$alphabetArr = [];

// Adding alphabetical-sorted keys
$alphabetArr["I"] = "we";
$alphabetArr["he"] = "they";
$alphabetArr["you"] = "you";

提示：您可以使用ksort()函数按键对数组进行排序。

现在您有了另一个数组，该数组的键排序与第一个数组不同。因此，我们将对其进行比较：

$arr == $alphabetArr; // true
$arr === $alphabetArr; // false

注意：这也许很明显，但是使用严格比较比较两个不同数组总是会得到false。但是，使用===可以使两个任意数组相等。

您会说：“这种差异可以忽略不计”。然后我说这是有区别的，应该考虑并可能随时发生。如上所述，对数组中的键进行排序就是一个很好的例子。

对象

请记住，两个不同的对象绝不是严格相等的。这些示例将有助于：

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

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

注意：将对象分配给另一个变量不会创建副本-而是会创建对与该对象相同的内存位置的引用。 See here。

注意：从PHP7开始，添加了anonymous classes。从结果来看，以上测试中new class {}和new stdClass()之间没有区别。

PHP等式（== double equals）和identity（=== triple equals）比较运算符有何不同？

23 个答案:

`==`和`===`

松散`==`相等比较

转换规则

类型比较表

严格`===`相同比较

类型比较表

PHP Double Equals `==`平等图：

PHP Triple Equals `===` Equality chart：

大师冥想

希望：

PHP 双等号 `==` :

PHP 三重等于 `===` :

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

对象

PHP等式（== double equals）和identity（=== triple equals）比较运算符有何不同？

23 个答案:

==和===

松散==相等比较

转换规则

类型比较表

严格===相同比较

类型比较表

PHP Double Equals ==平等图：

PHP Triple Equals === Equality chart：

大师冥想

希望：

PHP 双等号 == :

PHP 三重等于 === :

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

对象

`==`和`===`

松散`==`相等比较

严格`===`相同比较

PHP Double Equals `==`平等图：

PHP Triple Equals `===` Equality chart：

PHP 双等号 `==` :

PHP 三重等于 `===` :