变量有类型和值。

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

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

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

PHP必须将$var转换为整数。在本例中，"$var == 1"为真，因为任何非空字符串都被转换为1。

当使用===时，检查值和类型是否相等，因此"$var === 1"为假。

这很有用，例如，当你有一个函数可以返回false(错误)和0(结果):

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

这段代码是错误的，如果myFunction()返回0，它被强制转换为false，你似乎有一个错误。正确的代码是:

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

因为测试的是返回值“是一个布尔值并且为假”，而不是“可以被强制转换为假”。

关于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');
}

一图胜千言万语:

PHP双等号==等号图表:

PHP三重等号===等号图表:

创建这些图像的源代码:

https://github.com/sentientmachine/php_equality_charts

大师冥想

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

NAN != NAN but NAN == true. == will convert left and right operands to numbers if left is a number. So 123 == "123foo", but "123" != "123foo" A hex string in quotes is occasionally a float, and will be surprise cast to float against your will, causing a runtime error. == is not transitive because "0"== 0, and 0 == "" but "0" != "" PHP Variables that have not been declared yet are false, even though PHP has a way to represent undefined variables, that feature is disabled with ==. "6" == " 6", "4.2" == "4.20", and "133" == "0133" but 133 != 0133. But "0x10" == "16" and "1e3" == "1000" exposing that surprise string conversion to octal will occur both without your instruction or consent, causing a runtime error. False == 0, "", [] and "0". If you add 1 to number and they are already holding their maximum value, they do not wrap around, instead they are cast to infinity. A fresh class is == to 1. False is the most dangerous value because False is == to most of the other variables, mostly defeating it's purpose.

希望:

如果你正在使用PHP，你不应该使用双等号操作符，因为如果你使用三等号，唯一需要担心的边缘情况是NAN和太接近其数据类型最大值的数字，它们会被强制转换为无穷大。使用双等号，任何东西都可以是surprise ==对任何东西或，或可以是出乎你的意愿和!=对显然应该是相等的东西。

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

这都是关于数据类型的。以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中==和===的区别

到目前为止，所有的答案都忽略了一个危险的问题===。这里已经顺便提过，但没有强调，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在这方面是不等效的，因为它只有一种数字类型(在内部它可能有不同的位表示，但它不会导致===的问题)。

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