这都是关于数据类型的。以BOOL (true或false)为例:

True也等于1和 False也等于0

==在比较时不关心数据类型: 所以如果你有一个变量是1(这也可能是真的):

$ var = 1;

然后与==进行比较:

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

但$var并不等于true，对吧?它的int值为1，而int值为true。

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

如果我这样做了

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

这个条件不会为真，因为$var !== true它只== true(如果你知道我的意思)。

你为什么需要这个?

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

array_search()函数的作用是:简单地在数组中搜索一个值，并返回该值所在元素的键。如果在数组中找不到该值，则返回false。但是，如果对存储在数组的第一个元素(数组键值为0)....中的值执行array_search()会怎样呢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)

因此，对于这种情况，您可以使用===来代替，以便检查数据类型。

<?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);
?>

这都是关于数据类型的。以BOOL (true或false)为例:

True也等于1和 False也等于0

==在比较时不关心数据类型: 所以如果你有一个变量是1(这也可能是真的):

$ var = 1;

然后与==进行比较:

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

但$var并不等于true，对吧?它的int值为1，而int值为true。

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

如果我这样做了

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

这个条件不会为真，因为$var !== true它只== true(如果你知道我的意思)。

你为什么需要这个?

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

array_search()函数的作用是:简单地在数组中搜索一个值，并返回该值所在元素的键。如果在数组中找不到该值，则返回false。但是，如果对存储在数组的第一个元素(数组键值为0)....中的值执行array_search()会怎样呢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)

因此，对于这种情况，您可以使用===来代替，以便检查数据类型。

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

更多内容请参见PHP中==和===的区别

==和===的差值

松散==相等操作符和严格===相同操作符之间的区别在手册中有详细解释:

比较运算符

松散==相等比较

如果您正在使用==操作符，或任何其他使用松散比较的比较操作符，如!=，<>或==，您总是必须查看上下文，以了解转换的内容，位置和原因，以了解发生了什么。

转换规则

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

类型对照表

作为参考和例子，您可以在手册中看到比较表:

严格===相同的比较

如果您正在使用===操作符，或任何其他使用严格比较的比较操作符，如!==或===，那么您总是可以确保类型不会神奇地改变，因为不会发生转换。因此，在严格比较中，类型和值必须相同，而不仅仅是值。

类型对照表

作为参考和例子，您可以在手册中看到比较表:

严格比较===

编者注-这是正确的引用之前，但更可读作为降价表。这不是抄袭

到目前为止，所有的答案都忽略了一个危险的问题===。这里已经顺便提过，但没有强调，integer和double是不同的类型，所以代码如下:

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

给:

 equal
 not equal

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

This is a nasty problem because a program using === can run happily for years if all of the numbers are small enough (where "small enough" depends on the hardware and OS you are running on). However, if by chance, an integer happens to be large enough to be converted to a double, its type is changed "forever" even though a subsequent operation, or many operations, might bring it back to a small integer in value. And, it gets worse. It can spread - double-ness infection can be passed along to anything it touches, one calculation at a time.

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

我认为这比字符串和数字之间的转换更糟糕，因为它很微妙。我发现记录什么是字符串，什么是数字很容易，但是记录数字中的比特数却超出了我的能力。

因此，在上面的答案中有一些不错的表，但在1(作为整数)和1(微妙的双精度)和1.0(明显的双精度)之间没有区别。另外，总是使用===而从不使用==的建议也不是很好，因为===有时会在==正常工作的地方失败。此外，JavaScript在这方面是不等效的，因为它只有一种数字类型(在内部它可能有不同的位表示，但它不会导致===的问题)。

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