==和===的区别是什么?
松==比较究竟是如何工作的? 严格的===比较到底是如何工作的?
有什么有用的例子吗?
==和===的区别是什么?
松==比较究竟是如何工作的? 严格的===比较到底是如何工作的?
有什么有用的例子吗?
当前回答
在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开始,引入了匿名类。在上面的测试中,新类{}和新stdClass()之间没有区别。
其他回答
一图胜千言万语:
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个错误,这些规则似乎是由数百万程序员通过布朗运动编程设计的。
<?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);
?>
在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开始,引入了匿名类。在上面的测试中,新类{}和新stdClass()之间没有区别。
关于对象比较的其他答案的补充:
==使用对象的名称和它们的值来比较对象。如果两个对象具有相同的类型并且具有相同的成员值,$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
到目前为止,所有的答案都忽略了一个危险的问题===。这里已经顺便提过,但没有强调,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在这方面是不等效的,因为它只有一种数字类型(在内部它可能有不同的位表示,但它不会导致===的问题)。
我的建议是——两者都不要用。你需要编写自己的比较函数来解决这个问题。