在JavaScript比较中，应使用哪个等号运算符== 还是 ===


Which equals operator (== vs ===) should be used in JavaScript comparisons?

我正在使用jslin进行javascript，当在if语句内部比较idSele_UNVEHtype.value.length == 0时，它返回了许多用if替换EDOCX1(2等号)的建议。

用===替换==是否有性能优势？

任何性能改进都将受到欢迎，因为存在许多比较运算符。

如果不进行类型转换，性能会比==有所提高吗？

相关讨论

除不进行类型转换外，identity(===运算符的行为与equality(==运算符)相同，并且类型必须相同才能被视为相等。

参考：javascript教程：比较运算符

在进行任何必要的类型转换之后，==运算符将比较是否相等。===运算符不进行转换，因此如果两个值的类型不同，===只返回false。两者都同样迅速。

引用Douglas Crockford优秀的javascript：好的部分，

JavaScript has two sets of equality operators: === and !==, and their evil twins == and !=. The good ones work the way you would expect. If the two operands are of the same type and have the same value, then === produces true and !== produces false. The evil twins do the right thing when the operands are of the same type, but if they are of different types, they attempt to coerce the values. the rules by which they do that are complicated and unmemorable. These are some of the interesting cases:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
'' == '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

The lack of transitivity is alarming. My advice is to never use the evil twins. Instead, always use === and !==. All of the comparisons just shown produce false with the === operator.

更新：

@casebash在评论和@phillipe laybaert关于引用类型的回答中提出了一个很好的观点。对于参考类型，==和===之间的行为一致(特殊情况除外)。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
var a = [1,2,3];
var b = [1,2,3];

var c = { x: 1, y: 2 };
var d = { x: 1, y: 2 };

var e ="text";
var f ="te" +"xt";

a == b            // false
a === b           // false

c == d            // false
c === d           // false

e == f            // true
e === f           // true

特殊情况是，当您将一个文本与一个计算结果相同的对象进行比较时，由于它的toString或valueOf方法。例如，考虑将字符串文字与由String构造函数创建的字符串对象进行比较。

1
2
"abc" == new String("abc")    // true
"abc" === new String("abc")   // false

这里，==操作符检查两个对象的值并返回true，但===发现它们不是同一类型，返回false。哪一个是正确的？这取决于你想比较什么。我的建议是完全绕过这个问题，不要使用String构造函数来创建字符串对象。

参考文献http://www.ecma-international.org/ecma-262/5.1/sec-11.9.3

相关讨论

使用==运算符(相等)

1
2
true == 1; //true, because 'true' is converted to 1 and then compared
"2" == 2;  //true, because"2" is converted to 2 and then compared

使用===运算符(标识)

1
2
true === 1; //false
"2" === 2;  //false

这是因为相等运算符==执行类型强制，这意味着解释程序在比较之前会隐式地尝试转换值。

另一方面，标识操作符===不执行类型强制，因此在比较时不转换值。

相关讨论

==和===之间相等比较的有趣图示。

来源：http://dorey.github.io/javascript-equality-table/

var1 === var2

When using === for JavaScript equality testing, everything is as is. Nothing gets converted before being evaluated.

Equality evaluation of === in JS

var1 == var2

When using == for JavaScript equality testing, some
funky conversions take place.

Equality evaluation of == in JS

Moral of the story:

Use === unless you fully understand the
conversions that take place with ==.

相关讨论

在这里的答案中，我没有读到任何关于平等的含义。有人会说，===意味着相同类型的相等，但这不是真的。它实际上意味着两个操作数引用相同的对象，或者在值类型的情况下，具有相同的值。

那么，让我们采用以下代码：

1
2
3
4
5
6
var a = [1,2,3];
var b = [1,2,3];
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

这里也是一样：

1
2
3
4
5
6
var a = { x: 1, y: 2 };
var b = { x: 1, y: 2 };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

甚至：

1
2
3
4
5
6
var a = { };
var b = { };
var c = a;

var ab_eq = (a === b); // false (even though a and b are the same type)
var ac_eq = (a === c); // true

这种行为并不总是显而易见的。这个故事比平等和同种类型有更多的意义。

规则是：

对于值类型(数字)：如果a和b具有相同的值且类型相同，则a === b返回true。

对于引用类型：如果a和b引用完全相同的对象，a === b返回true。

弦乐：如果a和b都是字符串并且包含完全相同的字符，则a === b返回true。

字符串：特殊情况…

字符串不是值类型，但在JavaScript中，它们的行为类似于值类型，因此当字符串中的字符相同且长度相同时，它们将"相等"(如第三条规则所述)。

现在它变得有趣了：

1
2
3
4
var a ="12" +"3";
var b ="123";

alert(a === b); // returns true, because strings behave like value types

但是这个怎么样？：

1
2
3
4
var a = new String("123");
var b ="123";

alert(a === b); // returns false !! (but they are equal and of the same type)

我认为字符串的行为类似于值类型？嗯，这取决于你问谁……在这种情况下，A和B不是同一类型。a为Object型，b为string型。只需记住，使用string构造函数创建一个字符串对象会创建一个类型为Object的对象，该对象在大多数情况下都表现为字符串。

相关讨论

我再加一句忠告：

如果有疑问，请阅读规范！

ECMA-262是一种脚本语言的规范，其中javascript是一种方言。当然，在实践中，最重要的浏览器的行为方式比对应该如何处理某些事情的深奥定义更为重要。但理解新字符串("A")的原因很有帮助！="A"。

请让我解释一下如何阅读规范来澄清这个问题。我看到在这个非常古老的话题中，没有人能回答这个非常奇怪的影响。所以，如果你能阅读一个规范，这将极大地帮助你的职业。这是一种后天习得的技能。那么，让我们继续。

在PDF文件中搜索===将进入规范第56页：11.9.4。strict equals运算符(==)，在详细阅读规范后，我发现：

11.9.6 The Strict Equality Comparison Algorithm
The comparison x === y, where x and y are values, produces true or false. Such a comparison is performed as follows:
  1. If Type(x) is different from Type(y), return false.
  2. If Type(x) is Undefined, return true.
  3. If Type(x) is Null, return true.
  4. If Type(x) is not Number, go to step 11.
  5. If x is NaN, return false.
  6. If y is NaN, return false.
  7. If x is the same number value as y, return true.
  8. If x is +0 and y is ?0, return true.
  9. If x is ?0 and y is +0, return true.
  10. Return false.
  11. 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.
  12. If Type(x) is Boolean, return true if x and y are both true or both false; otherwise, return false.
  13. 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.

有趣的是第11步。是的，字符串被视为值类型。但这并不能解释为什么新字符串("a")！="A"。我们有不符合ECMA-262的浏览器吗？

不要这么快！

让我们检查操作数的类型。通过用typeof()包装它们，自己尝试一下。我发现新的字符串("a")是一个对象，使用步骤1：如果类型不同，则返回false。

如果您想知道为什么新字符串("A")不返回字符串，那么阅读规范的一些练习如何？玩得高兴！

艾迪亚卡皮在下面的评论中写道：

From the specification

11.2.2 The new Operator:

If Type(constructor) is not Object, throw a TypeError exception.

With other words, if String wouldn't be of type Object it couldn't be used with the new operator.

new总是返回一个对象，即使对于字符串构造函数也是如此。唉！字符串的值语义(参见步骤11)丢失。

这最后意味着：新字符串("A")！="A"。

相关讨论

在PHP和JavaScript中，它是一个严格的相等运算符。也就是说，它将比较类型和值。

相关讨论

我在firefox中用firebug测试了这个，使用的代码如下：

1
2
3
4
5
6
7
8
console.time("testEquality");
var n = 0;
while(true) {
    n++;
    if(n==100000)
        break;
}
console.timeEnd("testEquality");

和

1
2
3
4
5
6
7
8
console.time("testTypeEquality");
var n = 0;
while(true) {
    n++;
    if(n===100000)
        break;
}
console.timeEnd("testTypeEquality");

我的测试结果(每个测试5次，平均值)：

1
2
==: 115.2
===: 114.4

所以我想说，微小的差异(这是超过100000次迭代，记住)是可以忽略的。性能不是执行===的原因。类型安全性(好吧，就像在javascript中一样安全)，代码质量是。

相关讨论

在javascript中，它意味着相同的值和类型。

例如，

1
4 =="4" // will return true

但是

1
4 ==="4" // will return false

==运算符被称为严格比较运算符，它与==运算符不同。

我们取两个变量A和B。

对于"a==b"，要计算为真a，b必须是相同的值。

在"a==b"的情况下，a和b必须是相同的值，也必须是相同的类型，才能计算为真。

以下面的例子为例

1
2
3
4
5
6
7
8
9
10
11
12
var a = 1;
var b ="1";

if (a == b) //evaluates to true as a and b are both 1
{
    alert("a == b");
}

if (a === b) //evaluates to false as a is not the same type as b
{
    alert("a === b");
}

总之，在不希望使用==运算符的情况下，使用==运算符可能会计算为true，因此使用==运算符会更安全。

在90%的使用场景中，使用哪一个并不重要，但是当有一天你遇到一些意想不到的行为时，知道它们之间的区别是很方便的。

它检查相同边的类型和值是否相同。

例子：

1
'1' === 1 // will return"false" because `string` is not a `number`

常见例子：

1
0 == ''  // will be"true", but it's very common to want this check to be"false"

另一个常见的例子：

1
null == undefined // returns"true", but in most cases a distinction is necessary
相关讨论

为什么==是如此不可预测？

当你将一个空字符串""与数字0 0进行比较时，你会得到什么？

true

是的，根据==的说法，空字符串和数字0是同时的。

它并没有结束，还有一个：

1
'0' == false // true

数组会让事情变得很奇怪。

1
2
3
4
[1] == true // true
[] == false // true
[[]] == false // true
[0] == false // true

然后用弦更奇怪

1
2
3
4
[1,2,3] == '1,2,3' // true - REALLY?!
'

\t' == 0 // true - Come on!

情况变得更糟：

什么时候等于不等于？

1
2
3
4
5
6
7
let A = ''  // empty string
let B = 0   // zero
let C = '0' // zero string

A == B // true - ok...
B == C // true - so far so good...
A == C // **FALSE** - Plot twist!

我再说一遍：

1
2
(A == B) && (B == C) // true
(A == C) // **FALSE**

这就是你从原始人身上得到的疯狂的东西。

当你在物品上使用==时，这是一个全新的疯狂水平。

现在你可能想知道…

为什么会这样？

这是因为不同于"三重相等"(===)，它只检查两个值是否相同。

==做了很多其他的事情。

它对函数有特殊的处理，对空值、未定义、字符串有特殊的处理，您可以命名它。

很奇怪。

事实上，如果您试图编写一个执行==所做操作的函数，它看起来会像这样：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
function isEqual(x, y) { // if `==` were a function
    if(typeof y === typeof x) return y === x;
    // treat null and undefined the same
    var xIsNothing = (y === undefined) || (y === null);
    var yIsNothing = (x === undefined) || (x === null);

    if(xIsNothing || yIsNothing) return (xIsNothing && yIsNothing);

    if(typeof y ==="function" || typeof x ==="function") {
        // if either value is a string
        // convert the function into a string and compare
        if(typeof x ==="string") {
            return x === y.toString();
        } else if(typeof y ==="string") {
            return x.toString() === y;
        }
        return false;
    }

    if(typeof x ==="object") x = toPrimitive(x);
    if(typeof y ==="object") y = toPrimitive(y);
    if(typeof y === typeof x) return y === x;

    // convert x and y into numbers if they are not already use the"+" trick
    if(typeof x !=="number") x = +x;
    if(typeof y !=="number") y = +y;
    // actually the real `==` is even more complicated than this, especially in ES6
    return x === y;
}

function toPrimitive(obj) {
    var value = obj.valueOf();
    if(obj !== value) return value;
    return obj.toString();
}

这是什么意思？

这意味着==是复杂的。

因为它很复杂，所以很难知道当你使用它时会发生什么。

这意味着你最终可能会有缺陷。

所以这个故事的寓意是…

让你的生活不那么复杂。

用===代替==。

结束。

相关讨论

严格相等/比较的javascript执行流程图'=='

Javascript strict equality

非严格相等/比较的javascript执行流程图'='

Javascript non equality

相关讨论

javascript ===与==的比较。

1
2
3
4
0==false   // true
0===false  // false, because they are of a different type
1=="1"     // true, auto type coercion
1==="1"    // false, because they are of a different type

它意味着没有类型强制的平等类型强制意味着javascript不会自动将任何其他数据类型转换为字符串数据类型

1
2
3
4
5
6
7
8
9
10
11
0==false   // true,although they are different types

0===false  // false,as they are different types

2=='2'    //true,different types,one is string and another is integer but
            javaScript convert 2 to string by using == operator

2==='2'  //false because by using === operator ,javaScript do not convert
           integer to string

2===2   //true because both have same value and same types

在典型的脚本中，没有性能差异。更重要的可能是，千"=="比千"=="：)javascript配置文件可以告诉您在您的情况下是否存在性能差异。

但就我个人而言，我会按照JSlint的建议去做。这一建议不是因为性能问题，而是因为类型强制意味着('\t

' == 0)是正确的。

相关讨论

相等比较运算符==容易混淆，应避免使用。

如果你必须和它一起生活，那么记住以下三件事：

  • 它是不可传递的：(a==b)和(b==c)不会导致(a==c)
  • 它的否定是相互排斥的：(a==b)和(a！=b)始终保持与所有a和b相反的布尔值。
  • 如有疑问，请认真学习以下真理表：

    • javascript中的相等运算符真值表

    • 表中的每一行都是一组3个相互"相等"的值，这意味着其中任何2个值都是相等的，使用equal==符号*

    **奇怪：请注意，第一列中的任何两个值在这个意义上都不相等。**

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    ''       == 0 == false   // Any two values among these 3 ones are equal with the == operator
    '0'      == 0 == false   // Also a set of 3 equal values, note that only 0 and false are repeated
    '\t'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
    '
    '         == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
    '
    '         == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
    '\t

    '     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --

    null == undefined  // These two"default" values are not-equal to any of the listed values above
    NaN                // NaN is not equal to any thing, even to itself.

    对！这很重要。

    javascript中的===操作符检查值以及类型，其中==操作符只检查值(如果需要，执行类型转换)。

    enter image description here

    你可以很容易地测试它。在HTML文件中粘贴以下代码并在浏览器中打开它

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    function onPageLoad()
    {
        var x ="5";
        var y = 5;
        alert(x === 5);
    };



    </head>

    <body onload='onPageLoad();'>

    你会得到"错误"的警告。现在将onPageLoad()方法修改为alert(x == 5);，您将得到正确的结果。

    在您的使用中，这两个操作之间不太可能有任何性能差异。由于两个参数已经是同一类型，因此没有要进行的类型转换。两个操作都将进行类型比较，然后进行值比较。

    ===运算符检查变量的值和类型是否相等。

    ==运算符只检查变量的值是否相等。

    这是一个严格的检查测试。

    这是一件好事，尤其是当您检查0和false和null之间时。

    例如，如果您有：

    1
    $a = 0;

    然后：

    1
    2
    3
    $a==0;
    $a==NULL;
    $a==false;

    所有的返回都是真的，你可能不想这样。假设您有一个函数可以返回数组的第0个索引，或者失败时返回false。如果您选择"=="false，可能会得到一个令人困惑的结果。

    所以和上面一样，只是一个严格的测试：

    1
    2
    3
    4
    5
    $a = 0;

    $a===0; // returns true
    $a===NULL; // returns false
    $a===false; // returns false
    相关讨论

    JSlint有时会给你一些不切实际的理由来修改东西。如果类型已经相同，那么===与==的性能完全相同。

    只有当类型不相同时，它才会更快，在这种情况下，它不会尝试转换类型，而是直接返回一个false。

    所以，imho、jslint可能用来编写新的代码，但是无论如何都应该避免无用的过度优化。

    也就是说，当你知道支票A只能是一个字符串时，没有理由在支票中把==改为===。

    以这种方式修改大量代码会浪费开发人员和评审人员的时间，而且一无所获。

    简单地

    ==表示操作数与type conversion的比较。

    和；

    ===表示没有type conversion的操作数之间的比较。

    javascript中的类型转换意味着javascript会自动将任何其他数据类型转换为字符串数据类型。

    例如：

    1
    2
    3
    4
    5
    123=='123'   //will return true, because JS convert integer 123 to string '123'
                 //as we used '==' operator

    123==='123' //will return false, because JS do not convert integer 123 to string
                //'123' as we used '===' operator

    一个简单的例子是

    1
    2
    3
    2 == '2'  -> true, values are SAME because of type conversion.

    2 === '2'  -> false, values are NOT SAME because of no type conversion.

    根据经验，我一般用===代替==，用!==代替!=。

    上面的答案解释了原因，道格拉斯·克罗克福德也非常清楚(javascript：好的部分)。

    但是有一个例外：== null是检查"是否为空或未定义"的有效方法：

    1
    2
    3
    if( value == null ){
        // value is either null or undefined
    }

    例如，jquery 1.9.1使用这种模式43次，jshint语法检查器甚至为此提供了eqnull放松选项。

    从jquery样式指南：

    Strict equality checks (===) should be used in favor of ==. The only
    exception is when checking for undefined and null by way of null.

    1
    2
    // Check for both undefined and null values, for some important reason.
    undefOrNull == null;

    前两个答案都是==表示相等，==表示同一性。不幸的是，这句话是错误的。

    如果==的两个操作数都是对象，则将它们进行比较，以查看它们是否是同一对象。如果两个操作数都指向同一对象，则相等运算符返回true。否则，两者不相等。

    1
    2
    3
    4
    var a = [1, 2, 3];  
    var b = [1, 2, 3];  
    console.log(a == b)  // false  
    console.log(a === b) // false

    在上面的代码中，==和==get false，因为a和b不是相同的对象。

    也就是说：如果==的两个操作数都是对象，==的行为与==相同，这也意味着标识。这两个操作符的本质区别在于类型转换。==在检查相等性之前有转换，但==没有。

    问题是，你可能很容易陷入麻烦，因为javascript有很多隐式转换意味着…

    1
    2
    3
    var x = 0;
    var isTrue = x == null;
    var isFalse = x === null;

    很快就成了问题。隐式转换之所以是"邪恶"的最好例子，可以从MFC／C++中的代码中获取，因为CString从隐式转换为指针TyPulf类型，它实际上会被编译。

    1
    2
    CString x;
    delete x;

    很明显在运行时会做一些不明确的事情…

    谷歌用于C++和STL中的隐式转换，以获得一些反对它的参数…

    相关讨论

    从核心的javascript参考

    === Returns true if the operands are strictly equal (see above)
    with no type conversion.

    相等比较：

    操作工==

    当两个操作数相等时返回true。在进行比较之前，操作数被转换为同一类型。

    1
    2
    3
    4
    5
    6
    >>> 1 == 1
    true
    >>> 1 == 2
    false
    >>> 1 == '1'
    true

    等式和类型比较：

    操作工===。

    如果两个操作数相等且类型相同，则返回true。一般来说如果您以这种方式进行比较，会更好更安全，因为没有幕后类型转换。

    1
    2
    3
    4
    >>> 1 === '1'
    false
    >>> 1 === 1
    true

    空的和未定义的都是虚无，也就是说，

    1
    2
    var a;
    var b = null;

    这里，a和b没有值。而0、false和""都是值。所有这些都有一个共同点，那就是它们都是虚伪的价值观，这意味着它们都满足虚伪的条件。

    因此，0、false和""一起构成子组。另一方面，空值和未定义值构成了第二个子组。检查下图中的比较。空值和未定义值将相等。另外三个相等。但是，在JavaScript中，它们都被视为不稳定的条件。

    Enter image description here

    这与任何对象(如、数组等)相同，非空字符串和布尔值都是真实条件。但是，它们都不平等。

    *运算符==vs==*

    1
    2
    3
    4
    1 == true    =>    true
    true == true    =>    true
    1 === true    =>    false
    true === true    =>    true

    这里有一个方便的比较表，显示发生的转换以及==和===之间的差异。

    如结论所述：

    "Use three equals unless you fully understand the conversions that take
    place for two-equals."

    http://dorey.github.io/javascript-equality-table/

    Javascript有严格的和类型转换的比较。严格比较(如===)仅在操作数类型相同时才为真。更常用的抽象比较(例如==)在进行比较之前将操作数转换为相同的类型。

    • equality(==运算符)转换操作数(如果它们不是同一类型)，然后应用严格比较。如果操作数是数字或布尔值，则在可能的情况下将操作数转换为数字；否则，如果任一操作数是字符串，则在可能的情况下将字符串操作数转换为数字。如果两个操作数都是对象，那么当操作数引用内存中的同一对象时，javascript会比较相等的内部引用。

      Syntax：

      x == y

      实例：

      1
      2
      3
      3 == 3     // true
      "3" == 3   // true
      3 == '3'   // true

    • 如果操作数严格相等(见上文)，且没有类型转换，则identity/strict equality(===运算符)返回true。

      Syntax：

      x === y

      实例：

      3 === 3 // true

    供参考：比较运营商(Mozilla Developer Network)

    如果要制作Web应用程序或安全页面，则应始终使用(仅在可能的情况下)

    1
    ===

    因为它会检查内容是否相同，类型是否相同！

    所以当有人进入时：

    1
    2
    3
    4
    var check = 1;
    if(check == '1') {
        //someone continued with a string instead of number, most of the time useless for your webapp, most of the time entered by a user who does not now what he is doing (this will sometimes let your app crash), or even worse it is a hacker searching for weaknesses in your webapp!
    }

    但与

    1
    2
    3
    4
    5
    6
    var check = 1;
    if(check === 1) {
        //some continued with a number (no string) for your script
    } else {
        alert('please enter a real number');
    }

    黑客永远不会在系统中更深入地发现漏洞并对你的应用程序或用户进行黑客攻击。

    我的观点是

    1
    ===

    将为脚本添加更多安全性

    当然，您也可以检查输入的数字是否有效、是否为字符串等。在第一个示例中使用其他if语句，但这至少对我来说更容易理解和使用。

    我之所以发表这篇文章，是因为"更安全"或"安全"这个词在本次对话中从未被提及(如果你在icloud.com上看到它使用2019次==和1308次==，这也意味着你有时会使用==而不是==因为它会阻塞你的函数，但正如在开始时所说，你应该使用==和p一样多的值。可渗透的)

    ===关心对象是否相同。因此，new String("Hello world") ==="Hello world"返回false。但是，==并不关心对象是否相同；它只是简单地将一个参数转换为另一个参数的类型：如果无法转换，则返回false。然后，new String("Hello world") =="Hello world"返回"真"而不是"假"。

    我的推理过程使用emacs-org模式和node.js来运行测试。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    | use =      | '' | '0' | false | 'false' | undefined | null | ' \t

     '     |
    | ''         | x  | f   | t     | f       | f         | f    | f          |
    | '0'        |    | x   | t     | f       | f         | f    | f          |
    | false      |    |     | x     | f       | f         | f    | t          |
    | 'false'    |    |     |       | x       | f         | f    | f          |
    | undefined  |    |     |       |         | x         | t    | f          |
    | null       |    |     |       |         |           | x    | f          |
    | ' \t

     '     |    |     |       |         |           |      | x          |



    | use ===    | '' | '0' | false | 'false' | undefined | null | ' \t

     '     |
    | ''         | x  | f   | f     | f       | f         | f    | f          |
    | '0'        |    | x   | f     | f       | f         | f    | f          |
    | false      |    |     | x     | f       | f         | f    | f          |
    | 'false'    |    |     |       | x       | f         | f    | f          |
    | undefined  |    |     |       |         | x         | f    | f          |
    | null       |    |     |       |         |           | x    | f          |
    | ' \t

     '     |    |     |       |         |           |      | x          |

    我的测试脚本如下：run>node xxx.js

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    var rowItems = ['', '0', false, 'false', undefined, null, ' \t

     '    ]
    var colItems = rowItems

    for(var i = 0; i < rowItems.length; i++) {
        for (var j = 0; j < colItems.length; j++) {
            var r = (rowItems[i] === colItems[j]) ? true : false;
            console.log(rowItems[i] +" =" + colItems[j] +"" + r +" [" + i +"] ==> [" + j +"]")
        };
    }
    相关讨论

    JavaScript是一种弱类型的语言，即没有任何数据类型，如C、C++ +int、布尔、浮点等。因此，变量可以保存任何类型的值，这就是为什么这些特殊的比较操作符存在的原因。

    如

    1
    var i = 20;var j ="20";

    如果我们应用比较运算符，这些变量的结果将是

    1
    i==j //result is true

    或

    1
    j != i//result is false

    为此，我们需要一个特殊的比较运算符来检查变量的值和数据类型。

    如果我们这样做

    1
    i===j //result is false

    Different's Between = , = = , = = =

    • =运算符，用于分配value号。
    • = =运算符，用于比较values而不是datatype的值。
    • 用于比较values和datatype的= = =运算符。

    ==运算符只比较值而不是数据类型

    ===运算符比较值与其数据类型的比较

    如。

    1
    2
    3
    1 =="1" //true

    1 ==="1" //false

    "=="运算符，用于执行自动类型转换的语言，如php、javascript。"=="运算符有助于防止自动类型转换导致的意外比较。

    相关讨论

    总是使用"==="，这样可以避免上千个错误。现在，不同的样式指南更倾向于使用三重相等，因为它比较考虑操作数的类型。

    使用===的一个未提及的原因是，您与coffee-script共存/相互编译。从咖啡书上…

    The weak equality comparison in JavaScript has some confusing behavior and is often the source of confusing bugs.

    The solution is to instead use the strict equality operator, which consists of three equal signs: ===. It works exactly like the normal equality operator, but without any type coercion. It's recommended to always use the strict equality operator, and explicitly convert types if needs be.

    如果您经常转换到coffee-script或从coffee-script转换到===，则只需使用===。事实上，coffee-script编译器会强迫您……

    CoffeeScript solves this by simply replacing all weak comparisons with strict ones, in other words converting all == comparators into ===. You can't do a a weak equality comparison in CoffeeScript, and you should explicitly convert types before comparing them if necessary.

    是的，相等的==和同一的===操作符之间有很大的区别。通常，Identity运算符执行得更快，因为没有进行类型转换。但是如果这些值是相同的类型，您将看不到任何区别。查看我的文章javascript相等运算符的图例，其中解释了详细信息，包括类型转换和比较算法，以及许多示例。

    严格的平等在很大程度上是更好的

    事实上，JavaScript是一种松散类型的语言，在使用它时，需要不断地在您的头脑中出现。只要数据结构是相同的，就没有理由不使用严格的相等，对于常规的相等，您通常会有自动发生的值的隐式转换，这会对代码产生深远的影响。这种转换很容易出现问题，因为它们会自动发生。

    如果严格相等，则不存在自动隐式转换，因为值必须已经具有正确的数据结构。

    首先，有关javascript字符串equals:double equals的一些术语被正式称为抽象相等比较运算符，而triple equals则被称为严格相等比较运算符。它们之间的区别可以总结为：抽象相等将在进行比较之前尝试通过类型强制解析数据类型。如果类型不同，则严格相等将返回false。请考虑以下示例：

    1
    2
    3
    4
    console.log(3 =="3"); // true
    console.log(3 ==="3"); // false.
    console.log(3 =="3"); // true
    console.log(3 ==="3"); // false.

    使用两个等号返回true，因为字符串"3"在进行比较之前转换为数字3。三个等号发现类型不同并返回false。这是另一个：

    1
    2
    3
    4
    console.log(true == '1'); // true
    console.log(true === '1'); // false
    console.log(true == '1'); // true
    console.log(true === '1'); // false

    同样，抽象相等比较执行类型转换。在这种情况下，布尔值"真"和字符串"1"都转换为数字1，结果为"真"。严格相等返回错误。

    如果你知道你很快就能区分==和==。但是，在某些情况下，这些操作员的行为是不直观的。让我们再看一些例子：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    console.log(undefined == null); // true
    console.log(undefined === null); // false. Undefined and null are distinct types and are not interchangeable.
    console.log(undefined == null); // true    
    console.log(undefined === null); // false. Undefined and null are distinct types and are not interchangeable.

    console.log(true == 'true'); // false. A string will not be converted to a boolean and vice versa.
    console.log(true === 'true'); // false
    console.log(true == 'true'); // false. A string will not be converted to a boolean and vice versa.
    console.log(true === 'true'); // false

    下面的示例很有趣，因为它说明字符串文本与字符串对象不同。

    1
    2
    3
    4
    console.log("This is a string." == new String("This is a string.")); // true
    console.log("This is a string." === new String("This is a string.")); // false
    console.log("This is a string." == new String("This is a string.")); // true
    console.log("This is a string." === new String("This is a string.")); // false

    使用===如果你想在javascript中比较两个东西，这叫做严格的相等，这意味着如果类型和值都相同，这将返回真的，所以不会有任何不需要的类型修正，如果你使用==你基本上不关心类型，在很多情况下你可能会遇到与l有关的问题。OOSE平等比较。

    严格相等使用===

    Strict equality compares two values for equality. Neither value is
    implicitly converted to some other value before being compared. If the
    values have different types, the values are considered unequal.
    Otherwise, if the values have the same type and are not numbers,
    they're considered equal if they have the same value. Finally, if both
    values are numbers, they're considered equal if they're both not NaN
    and are the same value, or if one is +0 and one is -0.

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    var num = 0;
    var obj = new String('0');
    var str = '0';

    console.log(num === num); // true
    console.log(obj === obj); // true
    console.log(str === str); // true

    console.log(num === obj); // false
    console.log(num === str); // false
    console.log(obj === str); // false
    console.log(null === undefined); // false
    console.log(obj === null); // false
    console.log(obj === undefined); // false

    松散相等使用==

    Loose equality compares two values for equality, after converting both
    values to a common type. After conversions (one or both sides may
    undergo conversions), the final equality comparison is performed
    exactly as === performs it. Loose equality is symmetric: A == B
    always has identical semantics to B == A for any values of A and B
    (except for the order of applied conversions).

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    var num = 0;
    var obj = new String('0');
    var str = '0';

    console.log(num == num); // true
    console.log(obj == obj); // true
    console.log(str == str); // true

    console.log(num == obj); // true
    console.log(num == str); // true
    console.log(obj == str); // true
    console.log(null == undefined); // true

    // both false, except in rare cases
    console.log(obj == null);
    console.log(obj == undefined);
    相关讨论

    "在javascript比较中，我应该使用==还是==="的两难境地与以下问题相同或类似："我应该使用‘勺子’还是‘叉子’来吃饭。"

    对这个问题唯一合理的回答是

  • 您应该使用动态类型比较，例如：==进行松散类型比较。
  • 您应该使用静态类型比较，例如：===进行强类型比较。

    • 那是因为它们不一样。它们没有相同的用途，也不打算用于相同的用途。

    当然，"叉子"和"勺子"都是用来"吃"的，但是你会根据你吃的东西来选择使用它们。

    意思是：你会下决心用"勺子"，即：==来喝汤，和/或用"叉子"，即：===来采摘。

    询问用"叉子"或"勺子"来"吃"是否更好，等同于询问用静态的[==]与动态的[==]公式是否更好，见JS。这两个问题同样是错误的，反映出对问题主题的理解非常狭隘或肤浅。

    相关讨论

    建议用===代替==的原因是===操作比==更可靠。在我们的上下文中，可靠意味着===也用于类型检查。考虑到最佳编程实践，我们应该总是选择更可靠的特性而不是不可靠的特性。同样，每当我们在大多数情况下考虑完全等于运算符时，我们默认认为类型应该是相同的。由于===提供了同样的条件，我们应该去做。

    javascript的类型松散，就像php一样，

    1
    2
    3
    4
    var x ="20";
    var y =20;

    if (x===y) // false

    这将始终给您一个错误，因为即使变量的值相同，数据类型也不相同

    一个是字符串，另一个是int

    1
    If(x==y)//true

    然而，这只是检查内容是否相同，不管数据类型如何…

    我不想说这些值相等，因为字符串值在逻辑上不能等于int值

    1
    2
    3
    4
    var a = new String("123");
    var b ="123";

    alert(a === b); // returns false !! (but they are equal and of the same type)

    在其中一个答案中看到了这个。如果您检查typeof(a)的话，a和b实际上不是同一类型。你会得到"object"，typeof(b)是"string"。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    1 =="1"    =>    true(define)
    true ==="true"    => false(undefined compare the type of variable)
    Case 1
    if(true ==="true"){
      echo 'true'
    }else{
     echo 'false undefined'
    }
    Ans :- false undefined because case 1 is check data type also with ===  
    Case 2
    if(1 =="1"){
      echo 'true define'
    }else{
     echo 'false undefined'
    }
    Ans :- true define undefined because case 2 is not check data type with ==
    相关讨论