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

时间:2008-12-11 14:19:49

标签: javascript operators equality equality-operator identity-operator

我正在使用JSLint来浏览JavaScript,并且正在返回许多建议,以便在执行比较等操作时将==(两个等号)替换为===(三个等号) idSele_UNVEHtype.value.length == 0声明中的if

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

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

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

49 个答案:

答案 0 :(得分:6164)

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

参考:Javascript Tutorial: Comparison Operators

==运算符将在执行任何必要的类型转换后比较 ===运算符将进行转换,因此如果两个值不是同一类型===,则只返回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's answer中提到的参考类型提出了一个很好的观点。对于参考类型=====一致行动(特殊情况除外)。

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

答案 1 :(得分:1069)

使用==运算符( 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

使用===运算符(标识

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

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

另一方面,身份运算符===不执行类型强制,因此在比较时不会转换值,因此更快(根据{{3跳过一步。

答案 2 :(得分:631)

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

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


var1 === var2

  

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

Equality evaluation of === in JS


var1 == var2

  

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

Equality evaluation of == in JS

  

故事的道德:

     

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

答案 3 :(得分:594)

在这里的答案中,我没有读到任何关于相等的含义的内容。有些人会说===表示相同且属性相同,但事实并非如此。它实际上意味着两个操作数引用相同的对象,或者在值类型的情况下,具有相同的值

所以,我们采取以下代码:

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 === ba具有相同的值且类型相同,则b会返回

对于参考类型:
   如果a === ba引用完全相同的对象

,则b会返回true

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


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

字符串不是值类型,但在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不是同一类型。 a的类型为Object,而b的类型为string。请记住,使用String构造函数创建一个字符串对象会创建类型为Object的类型,其大部分时间都是字符串

答案 4 :(得分:261)

让我加上这个忠告:

如有疑问,请阅读specification

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.如果类型(x)不是数字,请转到步骤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)。否则,请返回 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”

答案 5 :(得分:98)

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

答案 6 :(得分:94)

我在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相同),代码质量也是如此。

答案 7 :(得分:91)

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

例如,

4 == "4" // will return true

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

答案 8 :(得分:80)

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

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

答案 9 :(得分:74)

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

实施例

'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

答案 10 :(得分:72)

为什么==如此不可预测?

将空字符串""与数字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();
}

那是什么意思?

这意味着==很复杂。

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

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

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

让你的生活变得简单。

使用===代替==

结束。

答案 11 :(得分:67)

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

Javascript strict equality

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

Javascript non equality

答案 12 :(得分:53)

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

答案 13 :(得分:52)

这意味着没有类型强制的平等 类型强制意味着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 

答案 14 :(得分:47)

在典型的脚本中,没有性能差异。更重要的是,千元“===”比千元“==”重1千克。JavaScript profilers可以告诉你在你的情况下是否存在性能差异。

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

答案 15 :(得分:43)

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

如果你必须,请记住以下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.
    

答案 16 :(得分:36)

是的!这很重要。

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

enter image description here

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

<script>

function onPageLoad()
{
    var x = "5";
    var y = 5;
    alert(x === 5);
};

</script>

</head>

<body onload='onPageLoad();'>

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

答案 17 :(得分:36)

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

答案 18 :(得分:33)

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

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

答案 19 :(得分:31)

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

这是一件好事,特别是如果你在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

答案 20 :(得分:30)

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

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

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

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

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

答案 21 :(得分:29)

简单

==表示操作数 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 

答案 22 :(得分:25)

一个简单的例子是

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

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

答案 23 :(得分:24)

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

如果==的两个操作数都是对象,则比较它们以查看它们是否是同一个对象。如果两个操作数都指向同一个对象,则等于运算符返回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 :(得分:24)

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

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

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

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

例如,jQuery 1.9.1使用此模式43次,JSHint syntax checker甚至提供了eqnull轻松选项。

来自jQuery style guide

  

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

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

答案 25 :(得分:22)

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

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

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

CString x;
delete x;

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

谷歌在C ++和STL中进行隐式转换以获得反对它的一些论据......

答案 26 :(得分:22)

来自core javascript reference

  

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

答案 27 :(得分:21)

平等比较:

运营商==

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

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

平等和类型比较:

运营商===

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

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

答案 28 :(得分:19)

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

结论如下:

  

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

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

答案 29 :(得分:19)

* 运营商=== vs == *

1 == true    =>    true
true == true    =>    true
1 === true    =>    false
true === true    =>    true

答案 30 :(得分:19)

null和undefined是虚无,即

var a;
var b = null;

此处ab没有值。然而,0,false和''都是值。所有这些之间的共同点是它们都是虚假值,这意味着它们都满足虚假条件。

因此,0,false和''一起形成一个子组。而另一方面,null&amp; undefined形成第二个子组。检查下图中的比较。 null和undefined相等。其他三个将彼此相等。但是,它们都被视为JavaScript中的虚假条件。

Enter image description here

这与任何对象(如{},数组等)相同,非空字符串&amp;布尔值为true都是条件。但是,他们都不相同。

答案 31 :(得分:17)

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

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

    语法:

    x == y

    示例:

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

    语法:

    x === y

    示例:

    3 === 3 // true

供参考: Comparison operators (Mozilla开发者网络)

答案 32 :(得分:16)

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

===

因为它将检查它是否是相同的内容以及它是否是相同的类型!

所以当有人进入时:

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!
}

但是

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

黑客永远不会在系统中更深入地发现错误并破解您的应用或用户

我的观点是

===

将为您的脚本添加更多安全性

当然你也可以检查输入的数字是否有效,是一个字符串等。在第一个例子中使用其他if语句,但这至少让我更容易理解和使用

我发布这个的原因是在这个对话中从未说过“更安全”或“安全”这个词(如果你看iCloud.com它使用2019次===和1308次==,这也是意味着你有时会使用==而不是===,因为它会阻止你的功能,但正如在开头所说,你应该尽可能使用===)

答案 33 :(得分:13)

===关心对象是否相同。因此,new String("Hello world") === "Hello world"返回false。但是,==并不关心对象是否相同;它只是简单地将一个参数转换为另一个参数:如果转换不可能,则返回false。然后new String("Hello world") == "Hello world"返回true而不是false。

答案 34 :(得分:12)

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

| use =      | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | 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\r\n ' |    |     |       |         |           |      | x          | 



| use ===    | '' | '0' | false | 'false' | undefined | null | ' \t\r\n ' |
| ''         | 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\r\n ' |    |     |       |         |           |      | x          |

我的测试脚本如下:运行&gt;节点xxx.js

var rowItems = ['', '0', false, 'false', undefined, null, ' \t\r\n ']
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 + "]")
    };
}

答案 35 :(得分:11)

javascript是弱类型语言,即没有C,c ++中的任何数据类型。 int,boolean,float等因此变量可以包含任何类型的值,这就是为什么这些特殊的比较运算符存在

例如

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

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

i==j //result is true

j != i//result is false

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

如果我们这样做

i===j //result is false

答案 36 :(得分:9)

  

== == = =

之间的差异
  • =运算符用于分配value
  • = =运算符用于仅比较values而不是datatype
  • = = =运算符用于比较values以及datatype

答案 37 :(得分:7)

==运算符只是比较值not datatype

===运算符将值与其数据类型

的比较进行比较

例如。

1 == "1" //true

1 === "1" //false

&#34; ===&#34;用于执行自动类型转换的语言的运算符,例如。 PHP,Javascript。 &#34; ===&#34;运算符有助于防止由自动类型转换引起的意外比较。

答案 38 :(得分:6)

始终使用' === ',您将避免数以千计的错误。现在使用三重相等更适合不同的样式指南,因为它会考虑操作数的类型。

答案 39 :(得分:5)

使用===的一个未提及的原因 - 就是您与/ coffee-script共存/交叉编译。来自Little Book on CoffeeScript ...

  

JavaScript中的弱相等比较具有一些令人困惑的行为,并且通常是混淆错误的根源。

     

解决方案是使用严格相等运算符,它由三个等号组成:===。它的工作方式与普通的相等运算符完全相同,但没有任何类型强制。建议始终使用严格相等运算符,并在需要时显式转换类型。

如果您定期与coffee-script进行转换,则应使用===。事实上,coffee-script编译器将强迫您 ...

  

CoffeeScript通过简单地用严格的替换所有弱比较来解决这个问题,换句话说,将所有==比较器转换为===。你不能在CoffeeScript中进行弱相等比较,如果需要,你应该在比较之前显式转换类型。

答案 40 :(得分:5)

是的,平等==和身份===运营商之间存在很大差异 通常,身份运算符执行速度更快,因为没有进行类型转换。但如果值的类型相同,那么您将看不到任何差异 查看我的帖子The legend of JavaScript equality operator,其中说明了详细信息,包括类型转换和&amp;比较算法,有很多例子。

答案 41 :(得分:3)

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

当你使用Javascript时,Javascript是一种松散类型的语言需要经常出现在你的脑海中。只要数据结构相同,就没有理由不使用严格的相等性,在常规相等的情况下,您经常会自动进行值的隐式转换,这会对代码产生深远的影响。这种转换很容易出现问题,因为它们会自动发生。

对于严格相等,没有自动隐式转换,因为值必须已经是正确的数据结构。

答案 42 :(得分:1)

使用===如果你想比较JavaScript中的几个东西,它被称为严格平等,这意味着如果只有两种类型和值是相同的,所以不会有任何不需要的类型更正,如果你使用==,你基本上不关心类型,在很多情况下你可以面对松散的平等比较问题。

严格平等使用===

  

严格相等性比较两个相等的值。这两个价值都不是   在比较之前隐式转换为其他值。如果   值具有不同的类型,值被认为是不相等的。   否则,如果值具有相同的类型而不是数字,   如果它们具有相同的值,则认为它们是相等的。最后,如果两者都有   值是数字,如果它们都不是NaN,则它们被认为是相等的   并且是相同的值,或者如果一个是+ 0而一个是-0。

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


使用==

进行宽松的平等
  

松散相等性在转换两者之后比较两个相等的值   值为常见类型。转换后(一方或双方可以   进行转换),进行最终的相等比较   正如===执行它。松散的等式是对称的:A == B.   对于A和B的任何值,始终具有与B == A相同的语义   (申请转换的顺序除外)。

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

答案 43 :(得分:1)

建议将var gulp = require('gulp') inject = require('gulp-inject'); gulp.task('index', function() { gulp.src('./app/index.html') .pipe(inject(gulp.src('./app/**/*.js', {read: false}), {ignorePath: 'app', addRootSlash: false})) .pipe(gulp.dest('./build')); }); 替换为==的原因是===运算符比===更可靠。在我们的上下文中,可靠的方法==也用于类型检查。考虑到最佳编程实践,我们应始终选择更可靠的功能而不是可靠性较低的功能。再次,只要我们在大多数时间考虑与运算符完全相等,我们默认情况下认为类型应该相同。由于===提供的相同,我们应该去做。

答案 44 :(得分:1)

Javascript是松散的类型,就像php一样,

window.alert = (function(){
  var selected = document.querySelectorAll("a[href^='javascript:alert('");

  Array.from(selected).forEach(function(item){
    var old = item.href
    item.addEventListener("click", function(){ alert(old.substring(11)); });
    item.href="javascript:void(0);";
  });

  var _alert = function(msg) {
    console.log(msg);
    console.log(arguments.callee.caller.arguments[0].target);
  };
  
  return _alert;
})();

这总是会给你一个错误,因为即使变量的值相同,数据类型也不是

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

<a href="javascript:alert(1);">test</a>

然而,这只是检查内容是否相同,而不管数据类型......

我不想说值是相等的,因为字符串值逻辑上不能等于int值

答案 45 :(得分:1)

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

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

使用两个等号返回true,因为在进行比较之前将字符串“3”转换为数字3。三个等号表示类型不同并返回false。这是另一个:

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

同样,抽象相等比较执行类型转换。在这种情况下,布尔值true和字符串“1”都转换为数字1,结果为true。严格的相等性返回false。

如果您了解自己正在努力区分==和===。但是,在某些情况下,这些运算符的行为不直观。我们来看看更多的例子:

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

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

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

答案 46 :(得分:1)

&#34的困境;我应该在JavaScript比较中使用=====&#34;与以下问题相同或类似:&#34;我应该使用&#39;勺子&#39;或者“叉子”吃。

这个问题的唯一合理答案是

  1. 您应该使用动态类型比较例如:==来进行 松散类型 比较。
  2. 您应该使用静态类型比较例如:===来进行 强类型 比较。
  3. 那是因为它们不一样。它们不具有相同的目的,并不意味着用于同一目的。

    当然,两种叉子都是&#39;和&#39;勺子&#39;是为了“吃”,但你会选择相应地使用它们来吃。

    意思是:你决定使用&#39;勺子&#39;即:==有一个汤&#39;和/或&#39; fork&#39;即:===用于采摘。

    询问是否更好地使用&#34; fork&#34;或者是&#34;勺子&#34;因为&#34;吃&#34; - 等于询问是否更好地使用静态[===]与动态[==] eq。,op。在JS中。这两个问题同样错误,反映了对相关主题的非常狭隘或浅薄的理解。

答案 47 :(得分:0)

var a = new String("123");
var b = "123";

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

在其中一个答案中看到了这一点。 如果您要检查abtypeof(a)在这种情况下的类型并不相同  您将获得'object'typeof(b) 'string'

答案 48 :(得分:-4)

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 ==
寻找你感兴趣的贴纸↓↓↓
豫ICP备18024241号-1