关于变量：在Javascript中， ==“”的计算结果为true。为什么会这样？

In Javascript, == “” evaluates to true. Why is it so?

如果我做0 =="0"则评估为真。尝试，

1	if( -777 =="-777" ) alert("same");

警报发生。

并且，值得注意的是，true =="true"不会评估为true。尝试，

1	if( false =="false" ) alert("same");

警报不会发生。

为什么会这样？

相关讨论

==的行为有点冗长，但在ecma-262规范中明确定义：

11.9.3 The Abstract Equality Comparison Algorithm

The comparison x == y, where x and y
are values, produces true or false.
Such a comparison is performed as
follows:

If Type(x) is different from Type(y), go to step 14.

If Type(x) is Undefined, return true.

If Type(x) is Null, return true.

If Type(x) is not Number, go to step 11.

If x is NaN, return false.

If y is NaN, return false.

If x is the same number value as y, return true.

If x is +0 and y is ?0, return true.

If x is ?0 and y is +0, return true.

Return false.

If Type(x) is String, then return true if x and y are exactly the same
sequence of characters (same length
and same characters in corresponding
positions). Otherwise, return false.

If Type(x) is Boolean, return true if x and y are both true or both
false. Otherwise, return false.

Return true if x and y refer to the same object or if they refer to
objects joined to each other (see 13.1.2). Otherwise, return false.

If x is null and y is undefined, return true.

If x is undefined and y is null, return true.

If Type(x) is Number and Type(y) is String, return the result of the
comparison x == ToNumber(y).

If Type(x) is String and Type(y) is Number, return the result of the
comparison ToNumber(x) == y.

If Type(x) is Boolean, return the result of the comparison ToNumber(x) == y.

If Type(y) is Boolean, return the result of the comparison x ==
ToNumber(y).

If Type(x) is either String or Number and Type(y) is Object, return
the result of the comparison x ==
ToPrimitive(y).

If Type(x) is Object and Type(y) is either String or Number, return the
result of the comparison
ToPrimitive(x) == y.

Return false.

第16步适用于您以前的示例：

1
2
3
4

0 =="0" // apply 16
≡ 0 == toNumber("0")
≡ 0 == 0 // apply 7
≡ true

步骤18，然后步骤16，适用于后者：

1
2
3
4
5
6

true =="true" // apply 18
≡ toNumber(true) =="true"
≡ 1 =="true" // apply 16
≡ 1 == toNumber("true")
≡ 1 == NaN // apply 6
≡ false

相关讨论

这样做：

1	if(5 =="5")

使javascript将前5个转换为字符串。试试这个：

1	if(5 ==="5")

===也使Javascript评估类型。

这实际上是这个question的副本，其解释非常好。

因为Javascript是松散类型的，它将根据操作中的操作和其他变量的类型静默地转换变量。

1
2
3

alert ("5" - 1); // 4 (int)
alert ("5" + 1); //"51" (string)"+" is a string operator, too
alert ("5" == 5); // true

你可能想看的是身份检查(===)。这确保了变量是相同的，而不仅仅是相等的。

1 2	alert("5" == 5); // true, these are equal alert("5" === 5); // false, these are not identical.

另请参阅此问题：等式和身份比较运算符如何不同？ PHP的实现与javascript非常相似。

JavaScript有两组相等运算符：

=== and !==(严格的相等运算符)
== and !=(标准相等运算符)

如果两个操作数是相同的类型，则标准相等运算符将进行正确的比较，但如果它们的类型不同，则可以得到一些意外的结果，例如：

1
2
3
4
5
6
7
8
9
10
11

'' == '0' // false
0 == '' // true
0 == '0' // true
false == 'false' // false
false == '0' // true
false == undefined // false
false == null // false
null == undefined // true
' \t

' == 0 // true

为此，我总是建议使用严格相等运算符(===，！==)。

Why is it so?

因为JavaScript是松散类型的，并且非常不一致。并非所有的设计功能都经过深思熟虑;与其他编程语言相比，它的创建，实现和部署速度极快，急于将Netscape 2.0推出。直到它安定下来之后不久，失去了一些更令人震惊的错误并变得半标准化。

寻找隐式铸造规则之类的某种哲学原理可能是徒劳无功的。 JavaScript坚持的唯一真正一致的原则是DWIM，非常消极。

Javascript是一种松散类型的语言，因此只要解释器??认为需要，就可以在运行时完成类型转换。如果将整数与字符串进行比较，则表明它们应该是相同的类型，因此，例如，"34"== 34为真，因为整数可能在比较之前被强制转换为字符串。

字符串"false"未被类型化为bool，而bool false被强制转换为字符串，该字符串实际上具有值"0"，即包含数字0的字符串，给出"0"=="虚假的"，这显然是假的。

如果要比较没有自动类型转换的值，有效地比较类型和值，请使用三等于：

5 ==="5"假
"string"==="string"true

Javascript不会将"false"转换为布尔值false，仅转换为字符串"false"。

您可以将字符串值松散地转换为等效的整数，因此您的第一个示例可以正常工作。