49 题: 应该在JavaScript比较中使用哪个等于运算符(== vs ===)?

在...创建的问题 Wed, Mar 22, 2017 12:00 AM

我正在使用 JSLint 来浏览JavaScript,它正在返回许多建议来取代== (两个等于标志)与===(三个等号)做比较idSele_UNVEHtype.value.length == 0声明中的if

==替换===是否有性能优势?

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

如果没有进行类型转换,那么性能是否会超过==

    
5669
  1. 对于同一主题=== vs ==可能感兴趣的人,但在PHP中,可以在这里阅读: stackoverflow.com/questions/2401478/why-is-faster-than-in-php /... 。一>
    2010-12-31 12:33:37Z
  2. 万一有人在2012年想知道:=== 方式==更快。 jsperf.com/comparison-of-comparisons
    2012-07-03 23:02:38Z
  3. @minitech它应该是因为它不进行类型转换
    2012-07-14 19:10:25Z
  4. @ minitech,我怀疑有人会通过使用===而不是==让他们的应用程序显着更快。实际上,基准测试在现代浏览器上并没有显示出很大的差异。就个人而言,我通常在任何地方都使用==,除非我真的需要严格的平等。
    2012-12-25 09:09:27Z
  5. 这是Crockford的 JS The Good Parts 的一部分,他讨论了=====运营商: youtube.com/... 如果没有播放,则为 15 :20
    2013-04-22 16:17:00Z
  6. 醇>
    30答案                              30 跨度>                         

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

    参考: Javascript教程:比较运算符

    ==运算符将在执行任何必要的类型转换后比较 ===运算符将进行转换,因此如果两个值不是同一类型,===将只返回false。两者都同样快。

    引用Douglas Crockford的优秀 JavaScript:The Good Parts

      

    JavaScript有两组相等运算符:===!==,以及它们的邪恶双胞胎==!=。优秀的工作方式与您期望的方式相同。如果两个操作数具有相同的类型且具有相同的值,则===生成true!==生成false。当操作数属于同一类型时,邪恶的双胞胎做正确的事,但如果它们属于不同的类型,它们会试图强迫价值观。他们这样做的规则是复杂和不可取的。这些是一些有趣的案例:

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

    缺乏传递性令人震惊。我的建议是永远不要使用邪恶的双胞胎。相反,始终使用===!==。刚刚显示的所有比较产生false===运算符。


    更新

    @Casebash 在评论和@Phillipe Laybaert的 答案。对于参考类型=====彼此一致(除特殊情况外)。

     
    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
    

    特殊情况是,当您将文字与评估为同一文​​字的对象进行比较时,由于其toStringvalueOf方法。例如,考虑将字符串文字与String构造函数创建的字符串对象进行比较。

     
    "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

        
    6193
    2017-05-23 12:10:45Z
    1. ===如果类型相同则不会更快。如果类型不相同,===会更快,因为它不会尝试进行转换。
      2008-12-31 03:02:11Z
    2. ===永远不会慢于==。它们都进行类型检查,所以===与==相比没有做任何额外的事情,但类型检查可能允许===在类型不同时更快退出。
      2009-02-02 04:17:55Z
    3. 用=== /!= =替换所有== /!=会增加js文件的大小,然后需要更多的时间来加载。 :)
      2010-03-31 09:22:07Z
    4. “......他们这样做的规则是复杂和不可取的......”现在这样的陈述让你在编程时感觉很安全...
      2011-12-09 16:24:46Z
    5. 有时JavaScript的类型系统让我想要逃避尖叫。
      2012-11-08 04:06:58Z
    6. 醇>

    使用==运算符( Equality

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

    使用===运算符( Identity

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

    这是因为等于运算符==确实键入了强制,这意味着解释器会在比较之前隐式尝试转换值。

    另一方面,身份运算符===不执行类型强制,因此在比较时不会转换值,因此更快(根据这个JS基准测试)跳过一步。

        
    1074
    2019-04-29 01:53:48Z
    1. @ Software Monkey:不适用于值类型(数字,布尔值,...)
      2009-06-05 20:00:24Z
    2. type coercion vs type casting vs type convertion stackoverflow.com/questions/8857763 /...
      2014-07-23 12:02:16Z
    3. 由于没有人提到过Javascript Equality Table,所以它是: dorey.github.io/JavaScript-Equality-Table
      2015-01-06 03:17:19Z
    4. 在第一个语句中,您确定'true'是否转换为1而不是1转换为true?
      2016-11-22 10:05:58Z
    5. 术语“平等”和“身份”来自何处?该标准不使用这些条款。它称==为“抽象平等”,它称===为“严格平等”。授予==任何类型的“平等”是恕我直言,因为它不是传递,但为什么要狡辩?我对“身份”有更多的疑问;我觉得这个词很有误导性,尽管它“有效”。但严肃的是,谁创造了“身份”一词?我搜索标准,但找不到它。
      2018-02-07 08:03:44Z
    6. 醇>

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

    来源: http://dorey.github.io/JavaScript-Equality-表/ 强>


    var1 === var2

      

    使用===进行JavaScript相等测试时,一切都按原样。在评估之前没有任何东西被转换。


    var1 == var2

      

    使用==进行JavaScript相等测试时,有些   发生了时髦的转换。

      

    故事的道德:

         

    除非您完全理解,否则请使用===   使用==进行的转化。

        
    639
    2018-07-13 17:14:41Z
    1. 我会更进一步道德:总是使用=== /!===但要理解能够应对其他人的代码的转换
      2015-05-08 11:11:03Z
    2. @ mfeineis你的意思是===或!==而不是==或!=。不想混淆新的程序员;)
      2016-06-23 14:04:34Z
    3. 从我使用三个等于的经验可能会导致问题,除非完全理解,否则应该避免。两个等于产生更好的结果,因为99%的时间我确实不希望类型相等。
      2017-02-12 08:47:06Z
    4. @ vsync:如果你真的不希望类型相等,你应该使用三等于
      2017-04-24 05:19:24Z
    5. 一个例外:您可以安全地使用x == null来检查xnull还是undefined
      2018-09-12 15:40:08Z
    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
    

    同样在这里:

     
    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
    

    甚至:

     
    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如果ab具有相同的值并且属于同一类型,则返回true

    对于参考类型:
    a === b如果ab引用完全相同的对象,则返回true

    对于字符串:
    a === b如果ab都是字符串且包含完全相同的字符,则返回true


    字符串:特殊情况......

    字符串不是值类型,但在Javascript中它们的行为类似于值类型,因此它们将在“等于”时字符串中的字符是相同的,当它们具有相同的长度时(如第三条规则中所述)

    现在变得有趣了:

     
    var a = "12" + "3";
    var b = "123";
    
    alert(a === b); // returns true, because strings behave like value types
    

    但是这个怎么样?:

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

    我认为字符串的行为类似于值类型?嗯,这取决于你问谁...在这种情况下,a和b不是同一类型。 aObject型,而bstring型。请记住,使用String构造函数创建一个字符串对象会创建Object类型的东西,其大部分时间都是字符串

        
    596
    2012-01-10 09:08:34Z
    1. activa:我会澄清,字符串只有在它们是文字时才相等。 new String(“abc”)===“abc”是假的(根据我的研究)。
      2009-06-05 19:54:58Z
    2. new Number() == "0"。同样在Firefox中:(function(){}) == "function () {\n}"
      2011-03-30 05:21:36Z
    3. 感谢您解释为什么new String("123") !== "123"。它们是不同的类型。
      。简单但令人困惑
      2012-08-26 05:51:54Z
    4. String个对象的行为与任何其他对象一样。永远不应该使用new String,因为它不会创建真正的字符串。一个真正的字符串,可以用字符串文字制作或者将String作为函数不用 new调用,例如:String(0); //"0", Real string, not an object
      2012-12-04 23:51:33Z
    5. 但在您详细说明的情况下,运算符“==”的行为完全相同。
      2015-02-06 10:48:04Z
    6. 醇>

    让我加上这个忠告:

    如有疑问,请阅读规范!

    ECMA-262是一种脚本语言的规范,其中JavaScript是一种方言。当然,在实践中,最重要的浏览器的行为方式比关于应该如何处理某些东西的深奥定义更重要。但是理解为什么新字符串(“a”)!==“a”会很有帮助。

    请让我解释如何阅读说明书以澄清这个问题。我看到在这个非常古老的主题中,没有人能够得到非常奇怪的效果的答案。因此,如果您可以阅读规范,这将极大地帮助您的职业。这是一项后天的技能。所以,让我们继续。

    在PDF文件中搜索===,使我进入规范的第56页: 11.9.4。严格等于运算符(===),在浏览规范后我发现:

      

    11.9.6严格的等式比较算法
      比较x === y,其中x和y是值,产生 true false 。这样的比较如下进行:
      1.如果Type(x)与Type(y)不同,则返回 false
      2.如果Type(x)未定义,则返回 true
      3.如果Type(x)为Null,则返回 true
      4.如果Type(x)不是Number,请转到步骤11.
      5.如果x NaN ,则返回 false
      6.如果y NaN ,则返回 false
      7.如果x与y的数字值相同,则返回 true
      8.如果x为+0且y为-0,则返回 true
      9.如果x是-0且y是+0,则返回 true
      10.返回 false
      11.如果Type(x)是String,则返回 true 如果x和y完全相同的字符序列(相应位置的长度和字符相同);否则,返回 false
      12.如果Type(x)是布尔值,如果x和y都是 true 或两者都 false ,则返回 true ;否则,返回 false
      13.如果x和y引用同一个对象或它们引用相互连接的对象,则返回 true (见13.1.2)。 Otherwise,返回 false

    有趣的是第11步。是的,字符串被视为值类型。但这并不能解释为什么新字符串(“a”)!==“a”。我们的浏览器是否符合ECMA-262标准?

    没那么快!

    让我们检查一下操作数的类型。通过将它们包装在 typeof()中来自行尝试。我发现 new String(“a”)是一个对象,并使用了第1步:如果类型不同,则返回 false

    如果您想知道为什么新字符串(“a”)不返回字符串,那么阅读规范的练习怎么样?玩得开心!


    Aidiakapi在下面的评论中写道:

      

    来自规范

         

    11.2.2新运营商

         

    如果Type(构造函数)不是Object,则抛出TypeError异常。

         

    换句话说,如果String不是Object类型,则它不能与new运算符一起使用。

    new 始终返回一个Object,即使对于 String 构造函数也是如此。唉!字符串的值语义(参见步骤11)将丢失。

    这最终意味着:新字符串(“a”)!==“a”

        
    261
    2015-10-26 10:45:32Z
    1. 类型(x)的结果暗示与typeof相同?
      2012-11-15 18:35:49Z
    2. @nalply我并不完全理解new String('x')对行为的焦虑,因为我从未见过使用原始包装器对象的野外代码,而我不要认为有很多理由,特别是不是这些日子。你有没有遇到过代码?
      2018-09-10 18:28:06Z
    3. @Andy问题是恶意或只是草率的第三方代码,那么你不能假设没有人使用new String()
      2018-09-11 09:46:36Z
    4. 如果它很草率,===就是你会发现的。如果它是恶意的,我认为new String()可能是你最不担心的。我理解理论上的关注,但是,你有没有任何现实世界的例子?对我来说,这就像是有人可以将undefined设置为另一个值的旧焦虑。
      2018-09-12 15:34:23Z
    5. 我不知道你在哪里得到这个,但你的比较算法在第2步出错了。“7.2.15严格的等式比较”首先检查类型是否是同样,如果是,他们是否是数字。如果不是,则使用“7.2.12 SameValueNonNumber(x,y)”部分。
      2019-06-17 19:40:22Z
    6. 醇>

    在PHP和JavaScript中,它是一个严格的相等运算符。这意味着,它将比较类型和值。

        
    98
    2010-05-12 12:58:39Z
    1. @ David:正确。这就是为什么这个答案不准确(甚至是错误的)
      2010-05-31 12:25:27Z
    2. @ David var a = {}, b = {}; a == b返回false。
      2011-02-26 18:37:49Z
    3. 是:具有相同类型和值的两个不同的对象比较错误,即这个答案是错误的。为什么它有50个upvotes?
      2013-10-18 10:45:37Z
    4. 我意识到这是旧的,但要澄清为什么这个答案仍然“正确”是因为在var a = {}, b = {};的例子中虽然ab确实都是一个对象,但是从技术上讲,它们不是相同的值。它们是不同的实例。请注意比较实例行为与比较基元的行为不同。这可能会增加这种混乱。如果使用基本数据类型的实例版本,您将看到类似的比较行为。例如,new String('asdf')new Number(5)。例如:new Number(5) == new Number(5)是假的,即使它们保持相同的值。
      2017-05-18 18:02:00Z
    5. 我们都忘了对对象的引用实际上是一个Value Type,因为它是一个指向内存槽的指针。对象比较不是比较“对象的值”,而是两个指针是否相同,这意味着它们引用相同的内存槽。这在比较类型时是一个非常微妙的区别,因为“===”运算符确实需要说“如果内存中对象的类型,值和引用是相同的”。
      2018-09-03 20:05:25Z
    6. 醇>

    我在Firefox中使用 Firebug 使用以下代码对此进行了测试:

     
    console.time("testEquality");
    var n = 0;
    while(true) {
        n++;
        if(n==100000) 
            break;
    }
    console.timeEnd("testEquality");
    

     
    console.time("testTypeEquality");
    var n = 0;
    while(true) {
        n++;
        if(n===100000) 
            break;
    }
    console.timeEnd("testTypeEquality");
    

    我的结果(每次测试五次并取平均值):

     
    ==: 115.2
    ===: 114.4
    

    所以我要说微不足道的差异(这是超过100000次迭代,请记住)可以忽略不计。性能 不是 ===的理由。键入安全性(嗯,安全性与JavaScript相同),代码质量也是如此。

        
    94
    2014-10-26 11:07:41Z
    1. 超过类型安全,你想要逻辑正确 - 有时候你想要的东西在==不同意的时候是真实的。
      2011-09-13 21:14:15Z
    2. 现在,当==运算符存在实际类型的coersion时,如何进行比较?请记住,那是在性能提升的时候。
      2013-07-13 21:13:44Z
    3. 为了更快地检查类型不等式的上述原因而正确测试时的主要差异。 jsfiddle.net/4jhuxkb2
      2015-07-06 17:04:57Z
    4. 醇>

    在JavaScript中,它意味着相同的值和类型。

    例如,

     
    4 == "4" // will return true
    

     
    4 === "4" // will return false 
    
        
    91
    2014-10-26 11:11:58Z

    === 运算符称为严格比较运算符, == 运算符不同。

    让我们拿2个变量a和b。

    “a == b”评估为真,a和b必须是相同的值

    如果“a === b” a和b必须是相同值,并且相同类型评估为真。

    采取以下示例

     
    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%的使用情况下,使用哪一种都无关紧要,但是当你有一天意外行为时,知道差异就很方便了。

        
    80
    2013-08-21 08:39:53Z

    检查类型中的相同边是否相等以及

    实施例

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

    常见例子:

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

    另一个常见的例子:

     
    null == undefined // returns "true", but in most cases a distinction is necessary
    
        
    74
    2018-07-19 07:04:17Z
    1. 'string' !== 'number'
      2012-01-06 19:34:54Z
    2. 醇>

    为什么==如此难以预测?

    将空字符串""与数字零0进行比较时,您会得到什么?

    true

    是的,根据==,这是一个空字符串,数字零是同一时间。

    它并没有结束,这是另一个:

     
    '0' == false // true
    

    数组的事情变得非常奇怪。

     
    [1] == true // true
    [] == false // true
    [[]] == false // true
    [0] == false // true
    

    然后用字符串怪异

     
    [1,2,3] == '1,2,3' // true - REALLY?!
    '\r\n\t' == 0 // true - Come on!
    

    情况变得更糟:

    什么时候不相等?

     
    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!
    

    我再说一遍:

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

    这只是你用原语获得的疯狂东西。

    当你使用==对象时,这是一个全新的疯狂程度。

    此时你可能想知道......

    为什么会这样?

    嗯,这是因为与“三等于”(===)不同,它只检查两个值是否相同。

    == 其他一些东西

    它有函数的特殊处理,空值的特殊处理,未定义的,字符串,你可以命名。

    这很古怪。

    事实上,如果您尝试编写一个执行==功能的函数,它将看起来像这样:

     
    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();
    }
    

    那是什么意思?

    这意味着==很复杂。

    因为它很复杂,所以很难知道使用它会发生什么。

    这意味着你最终可能会遇到错误。

    故事的寓意是......

    让你的生活变得简单。

    使用===而不是==

    结束。

        
    72
    2018-04-21 15:39:44Z
    1. 你的looseEqual错了。 Function == Function.toString()是真的,但looseEqual(Function, Function.toString())是假的。不确定为什么要在开头过滤掉函数。
      2016-09-07 22:16:44Z
    2. @Oriol你是对的,我更新了代码以解释这个问题,根据我的测试,我不能删除“函数”的过滤器,而是“功能”必须完全不同地处理。
      2016-09-08 22:43:51Z
    3. 注意规范不会区别对待函数,它们只是对象。问题似乎是你依靠typeof x === "object"检查它是否是一个对象,但`typeof仅适用于非null原语。您可能对我的检查值是否为对象的正确方法列表感兴趣
      2016-09-08 23:25:01Z
    4. 我尝试对函数和对象进行相同处理,但发现结果不正确。例如,如果将函数视为对象,则将函数与实现与函数匹配的valueOf()或toString()函数的对象进行比较将会通过,但实际上它不会。示例:(function blah() { console.log("test"); }) != {valueOf:function(){return "function blah() { console.log(\"test\"); }";}} - 查看这个运行所有测试的JS Fiddle: jsfiddle.net/luisperezphd/7k6gcn6g(有1,225个测试排列)
      2016-09-10 16:22:22Z
    5. 你是对的,很棒的观察,这强调了==做了很多事情的主要观点,这使得很难预测结果,而===更加直截了当可预测哪个是===是推荐选择的主要原因之一。 (我会在回答中添加注释,提及你的观点)
      2016-09-11 13:20:38Z
    6. 醇>

    Javascript执行流程图,用于严格相等/比较'==='

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

        
    67
    2015-09-05 13:53:16Z
    1. 我不明白为什么string箭头指向大灰盒子,是不是意味着中断器将字符串转换为数字?
      2017-02-11 13:26:09Z
    2. @ vsync它指向灰色框内的字符串选项,即字符串 - > #|| NaN的。 Javascript不是类型脚本语言,但基本上它可以有任何类型的变量。因此,它指向灰色框。
      2017-02-12 06:56:21Z
    3. 我只是询问它是否用于铸造目的,因为string应该与number类型进行比较,因此中断器会查看字符串应该与哪些进行比较相应地施放字符串?
      2017-02-12 08:44:48Z
    4. 大灰色框是ToNumber在给定不同类型时会返回的内容,因此如果给它一个字符串,它将只选择最后一个选项(并将其转换为数字) )。 ==仅在ToNumberstring == number以上的情况下使用boolean == anything(仅在string/boolean上)。这意味着==永远不会转换undefinednull,即使它们在灰色框中。 (对于undefinednull或两者的任意组合,==将始终返回true.此外,无论值是左侧还是右侧都无关紧要,==(和===)将返回相同的结果。)
      2018-03-07 05:54:22Z
    5. 醇>

    JavaScript === vs ==

     
    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
    
        
    53
    2015-11-12 03:18:12Z

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

     
    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 
    
        
    52
    2017-07-30 21:40:44Z

    在典型的脚本中,没有性能差异。更重要的可能是千元“===”比千元“==”重1 KB。 JavaScript分析器可以告诉您案例中是否存在绩效差异。

    但我个人会做JSLint建议的事情。这个建议不是因为性能问题,而是因为类型强制意味着('\t\r\n' == 0)是真的。

        
    47
    2017-05-23 12:02:56Z
    1. 并非总是如此。使用gzip压缩,差异几乎可以忽略不计。
      2009-06-22 23:43:15Z
    2. 同意,但千元“===”也意味着10万条代码行,所以1kb或多或少......;)
      2016-09-28 18:32:51Z
    3. f你关心大小然后just将所有你的==与===交换,然后使用包含在av eval中的regexp将其切换回来
      2017-04-23 03:30:55Z
    4. 醇>

    平等比较运算符==令人困惑,应该避免。

    如果你必须,请记住以下3件事:

    1. 它不具有传递性:(a == b)(b == c)不会导致(a == c ) 强>
    2. 它的否定是相互排斥的:(a == b)(a!= b)总是保持相反的布尔值,所有a和湾强>
    3. 如有疑问,请记下以下真值表:
    4. 醇>

      JAVASCRIPT中的平等操作员真值表

    • 表中的每一行都是一组3个相互“相等”的值,这意味着它们中的任何2个值都相等,使用等于==符号*

    ** STRANGE:请注意,第一列中的任何两个值在这个意义上都不相等。**

     
    ''       == 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   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
    '\r'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
    '\n'     == 0 == false   // -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- --
    '\t\r\n' == 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.
    
        
    43
    2014-02-19 15:01:17Z

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

        
    36
    2008-12-11 14:44:55Z

    是的!这很重要。

    ===运算符在javascript中检查值以及输入,其中==运算符只检查值(如果需要则进行类型转换)

    您可以轻松测试它。将以下代码粘贴到HTML文件中并在浏览器中打开

     
    <script>
    
    function onPageLoad()
    {
        var x = "5";
        var y = 5;
        alert(x === 5);
    };
    
    </script>
    
    </head>
    
    <body onload='onPageLoad();'>
    

    您将在警报中获得“错误”。现在将onPageLoad()方法修改为alert(x == 5);,您将获得 true

        
    36
    2015-01-10 14:34:14Z

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

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

        
    33
    2017-11-20 12:05:13Z

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

    这是一件好事,特别是如果你在0和false之间进行检查并且为null。

    例如,如果你有:

     
    $a = 0;
    

    然后:

     
    $a==0; 
    $a==NULL;
    $a==false;
    

    全部返回true,你可能不想要这个。假设您有一个函数可以返回数组的第0个索引,或者在失败时返回false。如果您使用“==”false检查,则可能会产生令人困惑的结果。

    所以与上述相同,但严格的测试:

     
    $a = 0;
    
    $a===0; // returns true
    $a===NULL; // returns false
    $a===false; // returns false
    
        
    31
    2015-04-27 08:26:10Z
    1. 在JavaScript中,这是完全错误的,并且错误地不完整。 0 != null -1
      2013-05-06 03:07:17Z
    2. 醇>

    JSLint有时会给你不切实际的修改内容的理由。如果类型已经相同,=====具有完全相同的性能。

    只有当类型不相同时才会更快,在这种情况下它不会尝试to转换类型但直接返回false。

    所以,恕我直言, JSLint可能用于编写新代码,但应该不惜一切代价避免无用的过度优化。

    意思是,当你知道一个只能是一个字符串的事实时,没有理由在像==这样的支票中将===更改为if (a == 'test')

    修改大量代码会浪费开发人员和审阅者的时间并且什么都不会实现。

        
    30
    2017-11-20 12:11:45Z

    简单

    ==表示操作数之间比较 type conversion

    &安培;

    ===表示操作数之间比较 不含 type conversion

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

    例如:

     
    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 
    
        
    29
    2017-11-20 12:49:58Z

    一个简单的例子是

     
    2 == '2'  -> true, values are SAME because of type conversion.
    
    2 === '2'  -> false, values are NOT SAME because of no type conversion.
    
        
    25
    2015-07-04 03:56:47Z

    根据经验,我通常会使用===而不是==(而!==而不是!=)。

    上面的答案中解释了原因,道格拉斯·克罗克福德也很清楚( JavaScript:好的部分)。

    但是一个例外:  == null是检查'is null或undefined'的有效方法:

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

    例如,jQuery 1.9.1使用此模式43次,并使用 JSHint语法检查程序因此,甚至还提供了eqnull休闲选择。

    来自 jQuery样式指南

      

    应使用严格的等式检查(===)以支持==。唯一的   异常是通过null检查undefined和null。

     
    // Check for both undefined and null values, for some important reason. 
    undefOrNull == null;
    
        
    24
    2013-04-27 14:15:38Z

    前两个答案都提到==表示平等,===表示身份。不幸的是,这种说法不正确。

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

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

    在上面的代码中,==和===都变为false,因为a和b不是同一个对象。

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

        
    24
    2013-09-09 08:31:45Z

    问题是你可能很容易遇到麻烦,因为JavaScript有很多隐含的转换意味着......

     
    var x = 0;
    var isTrue = x == null;
    var isFalse = x === null;
    

    很快就会出现问题。隐式转换为“邪恶”的最佳示例可以从 MFC /C ++中的此代码中获取。由于从CString到HANDLE的隐式转换实际上会编译,这是一个指针typedef类型...

     
    CString x;
    delete x;
    

    显然在运行时非常未定义的东西......

    Google使用C ++进行隐式转换, STL 获取一些反对它的论据。

        
    22
    2014-10-26 11:08:37Z
    1. 0 == null为false。
      2014-01-13 00:25:19Z
    2. 醇>

    来自核心javascript参考

      

    ===如果操作数严格相等则返回true(见上文)   没有类型转换。

        
    22
    2015-11-12 03:17:34Z

    平等比较:

    运营商==

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

     
    >>> 1 == 1
    true
    >>> 1 == 2
    false
    >>> 1 == '1'
    true
    

    平等和类型比较:

    运营商===

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

     
    >>> 1 === '1'
    false
    >>> 1 === 1
    true
    
        
    21
    2013-10-02 21:54:43Z

    * 运营商=== vs == *

     
    1 == true    =>    true
    true == true    =>    true
    1 === true    =>    false
    true === true    =>    true
    
        
    19
    2014-03-19 12:08:11Z

    这是一个方便的比较表,显示了发生的转换以及=====之间的差异。

    结论如下:

      

    “除非您完全理解所采用的转换,否则请使用三个等号   两等于的地方。“

    http://dorey.github.io/JavaScript-Equality-Table/

        
    19
    2014-03-27 11:41:35Z
来源放置 这里