JavaScriptの比較にはどの等号演算子（== vs ===）を使うべきですか？
私は JSLint を使用してJavaScriptを実行しています。ifステートメント内で==を比較する場合などに、===（2つの等号）をidSele_UNVEHtype.value.length == 0（3つの等号）に置き換える提案が多数返されています。
==を===に置き換えることによるパフォーマンス上の利点はありますか？
多くの比較演算子が存在するため、パフォーマンスの向上は歓迎されます。
型変換が行われない場合、==よりもパフォーマンスが向上するでしょうか。
Identity（===）演算子は、型変換が行われないことを除いて、等価（==）演算子と同じように動作します。型が等しいと見なされるには、型が同じである必要があります。
==演算子は等しいかどうかを比較します必要な型変換を行った後。 ===演算子はnot変換を行います。そのため、2つの値が同じ型ではない場合、===は単にfalseを返します。どちらも同じくらい速いです。
ダグラス・クロックフォードの優秀な JavaScript：The Good Parts 、
JavaScriptには、
===と!==、およびそれらの邪悪な双子==と!=の2組の等価演算子があります。良いものはあなたが期待するように働く。 2つのオペランドが同じ型で同じ値を持つ場合、===は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を生成します。
更新：
コメントと @Phillipe Laybaertのanswer で参照タイプに関して @Casebash が良い点を挙げています。参照型の場合、==と===は一貫して動作します（特別な場合を除く）。
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コンストラクタによって作成された文字列オブジェクトとの比較を考えてみましょう。
"abc" == new String("abc") // true
"abc" === new String("abc") // false
ここで==演算子は2つのオブジェクトの値をチェックしてtrueを返していますが、===はそれらが同じ型ではないと見なしてfalseを返しています。どちらが正しいですか？それは本当に比較しようとしているものによって異なります。私のアドバイスは、この質問を完全に回避し、文字列オブジェクトを作成するのにStringコンストラクタを使わないことです。
参照
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3
==演算子（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ベンチマーク testに従って）高速になります。一歩スキップします。
==と===の間の同等性比較の興味深い絵的表現。
出典： http://dorey.github.io/JavaScript-Equality-Table/
var1 === var2
JavaScript同等性テストに
===を使用する場合、すべてそのままの状態です。評価される前に変換されるものはありません。
var1 == var2
JavaScriptの同等性テストに
==を使用するとき、いくつかのファンキーな変換が行われます。
この話の教訓：
===で行われる変換を完全に理解していない限り、==を使用してください。
ここの答えでは、私は equal が何を意味するのかについては何も読みませんでした。 ===は 等しいそして同じ型 を意味すると言う人もいるでしょうが、それは本当ではありません。それは実際には 両方のオペランドが同じオブジェクトを参照することを意味します または 値型の場合は同じ値を持つこと 。
それでは、次のコードを見てみましょう。
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は、aとbが同じ値で同じ型である場合にtrueを返します
参照型の場合： aとbがまったく同じオブジェクトを参照している場合、a === bはtrueを返します
文字列の場合： a === bは、aとbが両方とも文字列で、まったく同じ文字を含む場合はtrueを返します。
文字列：特別な場合...
文字列は値型ではありませんが、Javascriptでは値型のように動作するため、文字列内の文字が同じで同じ長さの場合は「等しい」となります（3番目の規則で説明）
今では面白くなります：
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型のものが作成されることを忘れないでください。
この助言を加えましょう：
よくわからない場合は、 specification ！を読んでください
ECMA-262は、JavaScriptが方言であるスクリプト言語の仕様です。もちろん実際には、何かがどう扱われることになっているかという難解な定義よりも、最も重要なブラウザがどのように振る舞うかがより重要です。しかし、なぜ new String（ "a"）！== "a" なのかを理解することは有益です。
この質問を明確にするために仕様書の読み方を説明させてください。この非常に古いトピックでは、非常に奇妙な効果について誰も答えを持っていなかったことがわかります。あなたが仕様を読むことができればそれで、これはあなたの職業で途方もなくあなたを助けるでしょう。習得したスキルです。それでは続けましょう。
PDFファイルで===を検索すると、仕様の56ページに移動します。 11.9.4。 Strict Equals演算子（===） 、そして仕様を見てみると、
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に進みます。
xが NaN の場合、 false を返す。
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）がBooleanの場合、 true を返します。xとyが両方とも true またはboth false ;を返します。そうでなければ、 false を返します。
13. xとyが同じオブジェクトを参照している場合、または互いに結合されているオブジェクトを参照している場合は、 true を返します（13.1.2を参照）。そうでなければ、 false を返します。
興味深いのは手順11です。はい、文字列は値型として扱われます。しかし、これは new String（ "a"）！== "a" を説明するものではありません。 ECMA-262に準拠していないブラウザがありますか？
そんなに早くない！
オペランドの種類を調べてみましょう。 typeof（） で囲んで試してみてください。 new String（ "a"） がオブジェクトであり、ステップ1が使用されていることがわかります。return false 型が異なる場合。
new String（ "a"） が文字列を返さない理由を疑問に思う場合は、仕様を読んで演習をしてください。楽しむ！
Aidiakapiはこれを下のコメントで書いています。
仕様から
11.2.2新しい演算子 ：
Type（コンストラクタ）がObjectではない場合、TypeError例外をスローします。
つまり、StringがObject型ではない場合、new演算子と一緒に使用することはできません。
new は、 String コンストラクタでも常にObjectを返します。そして悲しいかな！文字列の値の意味（手順11を参照）は失われます。
そしてこれは最終的に意味する： 新しい文字列（ "a"）！== "a" 。
PHPおよびJavaScriptでは、これは厳密な等価演算子です。つまり、型と値の両方を比較します。
私は Firebug を使ってFirefoxでこれをテストしました。
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");
私の結果（各5回テストして平均）：
==: 115.2
===: 114.4
それで、私は非常に小さな違い（これは100000回以上の繰り返しです、覚えている）はごくわずかであると言うでしょう。パフォーマンスnot===を実行する理由。安全性を入力してください（まあ、あなたがJavaScriptで取得するのと同じくらい安全です）、そしてコード品質はそうです。
JavaScriptではそれは同じ値と型を意味します。
例えば、
4 == "4" // will return true
しかし
4 === "4" // will return false
=== 演算子は厳密比較演算子と呼ばれ、 は と == 演算子とは異なります。
2 var aとbを取りましょう。
"a == b" がtrueと評価されるには、aとbが 同じ値 である必要があります。
"a === b" aの場合、bが 同じ値 で、かつ 同じ型 でなければ、trueと評価されません。
次の例を見てください
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");
}
要約すると ; == 演算子を使用しない場合は、 == 演算子を使用する方が安全です。
使用率が90％のシナリオでは、どちらを使用してもかまいませんが、ある日予期しない動作が発生したときにその違いを知っておくと便利です。
同じ側が type と value で等しいかどうかをチェックします。
例：
'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
なぜ==がそれほど予測できないのですか？
空の文字列""と数字のゼロ0を比較するとどうなりますか？
true
うん、それは正しいです==によると、空の文字列と数値ゼロは同じ時間です。
それだけではありません。もう1つあります。
'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**
そして、これはあなたがプリミティブで手に入れる狂気のものです。
==をオブジェクトと一緒に使用すると、まったく新しいレベルのクレイジーになります。
この時点であなたはおそらく疑問に思う...
なぜこれが起こるのですか？
それは、2つの値が同じかどうかをチェックする「トリプルイコール」（===）とは違っているからです。
==は他のものの束をします。
それは関数のための特別な取り扱い、nullのための特別な取り扱い、未定義の、文字列、あなたがそれを名前を付けます。
それはかなり風変わりです。
実際、==の機能を実行する関数を作成しようとすると、次のようになります。
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実行フロー図 '=='
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
これは 型強制なしの等価 型強制を意味する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
一般的なスクリプトでは、パフォーマンスに違いはありません。もっと重要なのは、千の "==="が千の "=="よりも1 KB重いということです:) JavaScriptプロファイラー あなたの場合パフォーマンスの違いがあるかどうか教えてくれます。
個人的には、私はJSLintが提案することをするでしょう。この推奨は、パフォーマンスの問題によるものではありませんが、型強制が('\t\r\n' == 0)がtrueであることを意味するためです。
等号比較演算子==は紛らわしく、避けるべきです。
もしあなたが HAVE TO それを持って生きるのなら、次の3つのことを覚えておいてください。
- 推移的ではありません： （a == b） および （b == c） は （a == c） にはなりません。
- 否定は相互排他的です。 （a == b） と （a！= b） は、常に反対のブール値を持ち、すべてのaとbを持ちます。
- 疑問がある場合は、次の真理値表を心で学んでください。
JavaScriptでの同等の演算子真理値表
- テーブルの各行は、3つの相互に「等しい」値のセットです。つまり、equal ==記号*を使用して、2つの値が等しいということです。
** STRANGE：最初の列の2つの値はその意味で等しくないことに注意してください。**
'' == 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.
はい！ それは問題である。
javascriptの===演算子 typeと同様にvalue - をチェックします == operatorはちょうど その値をチェックします（必要ならば型変換を行います） 。
簡単にテストできます。次のコードをHTMLファイルに貼り付けてブラウザで開きます。
<script>
function onPageLoad()
{
var x = "5";
var y = 5;
alert(x === 5);
};
</script>
</head>
<body onload='onPageLoad();'>
あなたは ' false 'という警告を受けるでしょう。 onPageLoad()メソッドをalert(x == 5);に変更すると true になります。
使用法の2つの操作の間にパフォーマンスの違いがあるとは考えにくいです。両方のパラメータがすでに同じ型であるため、実行する型変換はありません。両方の操作とも、型比較の後に値比較が続きます。
===演算子は、値と変数の型が等しいかどうかを確認します。
==演算子は、変数の値が等しいかどうかをチェックするだけです。
厳密なチェックテストです。
特に、0からfalse、そしてnullをチェックしているなら、それは良いことです。
たとえば、次のようになります。
$a = 0;
その後：
$a==0;
$a==NULL;
$a==false;
Allはtrueを返し、これは望まないかもしれません。配列の0番目のインデックス、あるいは失敗した場合にfalseを返すことができる関数があるとしましょう。 "=="をfalseにしてチェックすると、混乱を招くことがあります。
だから上記と同じことを、しかし厳密なテストで：
$a = 0;
$a===0; // returns true
$a===NULL; // returns false
$a===false; // returns false
JSLintは時々あなたにものを修正する非現実的な理由を与えます。型が既に同じである場合、===は==とまったく同じパフォーマンスを持ちます。
型が同じでない場合に限り速くなります。その場合、型を変換しようとはせずに直接falseを返します。
そのため、 IMHO、 JSLintを使用して新しいコードを作成することもできますが、無駄な過剰最適化は絶対に避けてください。
つまり、if (a == 'test')のようなチェックで==を===に変更する理由はないのです。
このように多くのコードを修正すると、開発者やレビュー担当者の時間が無駄になり、何も達成されません。
単に
==は 比較 オペランド間/ は type conversionを意味します
＆
===は 比較 オペランド間/ なし type conversionを意味します
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
簡単な例は
2 == '2' -> true, values are SAME because of type conversion.
2 === '2' -> false, values are NOT SAME because of no type conversion.
上位2つの答えは、==は平等を意味し、===は同一性を意味します。残念ながら、この文は誤りです。
==の両方のオペランドがオブジェクトの場合は、それらが同じオブジェクトであるかどうかが比較されます。両方のオペランドが同じオブジェクトを指している場合、equal演算子はtrueを返します。そうでなければ、両者は等しくありません。
var a = [1, 2, 3];
var b = [1, 2, 3];
console.log(a == b) // false
console.log(a === b) // false
上記のコードでは、aとbが同じオブジェクトではないため、==と===の両方がfalseになります。
つまり、==の両方のオペランドがオブジェクトの場合、==は===と同じように動作します。これは同一性も意味します。この2つの演算子の本質的な違いは型変換についてです。 ==は等価性をチェックする前に変換しますが、===は変換しません。
経験則として、私は一般的に===の代わりに==（および!==の代わりに!=）を使用します。
理由は上の答えで説明されていますし、Douglas Crockfordもそれについてはっきりしています（ JavaScript：The Good Parts ）。
ただし、 単一の例外があります ：== nullは、 'is nullまたはundefined'をチェックするための効率的な方法です。
if( value == null ){
// value is either null or undefined
}
例えば、jQuery 1.9.1はこのパターンを43回使用し、 JSHint構文チェッカー はこの理由からeqnull relaxオプションを提供します。
厳密な等価検査（===）は==を優先して使用されるべきです。唯一の例外は、nullを使用してundefinedとnullをチェックする場合です。
// Check for both undefined and null values, for some important reason. undefOrNull == null;
問題は、JavaScriptには暗黙のうちに暗黙の変換が含まれているため、簡単に問題が発生する可能性があることです。
var x = 0;
var isTrue = x == null;
var isFalse = x === null;
それはすぐに問題になります。暗黙的な変換が「悪」である理由の最良の例は、 _ mfc _ / C++のこのコードから取得できます。これは、CStringからポインターtypedef型であるHANDLEへの暗黙の変換により実際にコンパイルされます。
CString x;
delete x;
これは明らかに実行時に 非常に 未定義のことをします...
それに対していくつかの引数を取得するためにC++および _ stl _ の暗黙の変換のためのGoogle ...
===型変換を行わずにオペランドが厳密に等しい場合（上記を参照）、trueを返します。
平等比較：
演算子==
両方のオペランドが等しい場合、trueを返します。オペランドは、比較前に同じ型に変換されます。
>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true
等式と型の比較
演算子===
両方のオペランドが等しく、同じ型の場合はtrueを返します。この方法を比較すれば、一般的にはより良く、より安全です。
>>> 1 === '1'
false
>>> 1 === 1
true
これは、発生した変換と、==と===の違いを示す便利な比較表です。
結論が述べるように：
「2-equalsに対して行われる変換を完全に理解していない限り、3-equalsを使用してください。」
* 演算子=== vs == *
1 == true => true
true == true => true
1 === true => false
true === true => true
nullと未定義は何もない、つまり
var a;
var b = null;
ここでaとbは値を持ちません。一方、0、false、および ''はすべて値です。これらすべてに共通することの1つは、それらがすべて偽の値であるということです。つまり、すべてのが偽の条件を満たしています。
そのため、0、false、および「」が一緒になってサブグループを形成します。そしてその一方で、null＆undefinedは2番目のサブグループを形成します。下の画像で比較を確認してください。 nullと未定義は等しくなります。他の3つは互いに等しいでしょう。しかし、それらはすべてJavaScriptでは偽の条件として扱われます。
これは他のオブジェクト（{}、配列など）と同じです。空でない文字列とBoolean trueはすべて真の条件です。しかし、それらはすべて同じではありません。
JavaScriptには、厳密比較と型変換の両方の比較があります。厳密な比較（例：===）は、オペランドが同じ型である場合にのみ当てはまります。より一般的に使用される抽象比較（例：==）は、比較を行う前にオペランドを同じTypeに変換します。
等号（
==）演算子は、それらが同じタイプではない場合、それらのオペランドを変換し、次に厳密な比較を適用します。いずれかのオペランドが数値またはブール値の場合、可能であればオペランドは数値に変換されます。それ以外の場合、どちらかのオペランドが文字列の場合、その文字列オペランドは可能であれば数値に変換されます。両方のオペランドがオブジェクトの場合、JavaScriptは、オペランドがメモリ内の同じオブジェクトを参照するときに等しい内部参照を比較します。構文：
x == y例：
3 == 3 // true "3" == 3 // true 3 == '3' // true同一性／厳密等価（
===）演算子は、型変換を行わずにオペランドが完全に等しい場合（上記参照）にtrueを返します。構文：
x === y例：
3 === 3 // true
参考のために：比較演算子（Mozilla Developer Network）
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倍==を使用し===の代わりにuse ==を使うと、関数がブロックされることがありますが、冒頭で述べたように、可能な限り===を使用してください。
===はオブジェクトが同じかどうかを気にします。したがって、new String("Hello world") === "Hello world"はfalseを返します。しかし、==はオブジェクトが同じであるかどうかを気にしません。単に一方の引数を他方の型に変換するだけです。変換が不可能な場合はfalseを返します。 new String("Hello world") == "Hello world"はfalseではなくtrueを返します。
テストを実行するために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 |
以下の私のテストスクリプト：run> node 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 + "]")
};
}
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
=、= =、= = =の違い
=演算子valueを代入するためだけに使用されます。= =演算子valuesではなくdatatypeを比較するためだけに使用されます。= = =演算子valuesとdatatypeを比較するために使用されます。
==演算子は、データ型ではなく値のみを比較します。
===演算子は値をそのデータ型の比較と比較します
例えば。
1 == "1" //true
1 === "1" //false
自動型キャストを実行する言語で使用される "==="演算子。 PHP、Javascript。 "==="演算子は、自動タイプキャストによる予期しない比較を防ぐのに役立ちます。
常に ' === 'を使うと、何千もの間違いを避けることができます。 トリプル 等号を使用することは、オペランドのタイプを考慮に入れて比較するため、異なるスタイルガイドではより望ましい方法です。
One===を使用しない理由は、coffee-scriptから/への/クロスコンパイルと共存している場合です。 CoffeeScriptの Little Book から.
JavaScriptでの同等性の比較が弱いため、混乱を招くような動作があり、多くの場合、混乱を招くバグの原因となっています。
解決策は、代わりに3つの等号からなる厳密な等価演算子===を使用することです。これは通常の等価演算子とまったく同じように機能しますが、型強制はありません。常に厳密な等価演算子を使用し、必要に応じて明示的に型を変換することをお勧めします。
coffee-scriptとの間で定期的に変換を行っているのであれば、===を使うべきです。実際、coffee-scriptコンパイラは を強制的に ...にします。
CoffeeScriptはこれを解決するために、すべての弱い比較を厳密なものと単純に置き換える、言い換えればすべての==コンパレータを===に変換します。 CoffeeScriptでは弱い等号比較はできません。また、必要に応じて型を比較する前に明示的に型を変換する必要があります。
はい、等価==演算子と恒等===演算子の間には大きな違いがあります。
型変換が行われないため、通常、単位演算子はより高速に実行されます。しかし、値が同じタイプであれば、違いはありません。
私の投稿をチェックしてください JavaScriptの等価演算子の凡例 。型の変換や比較のアルゴリズムなど、詳細を多くの例で説明しています。
厳密な平等は、大部分が優れています
Javascriptが緩やかに型付けされた言語であるという事実は、それを使って作業するときには常に頭の中にある必要があります。データ構造が同じである限り、厳密な等価性を使用しない理由は実際にはありません。通常の等価性では、自動的に暗黙的に値が変換されることがよくあります。自動的に行われるため、この変換に問題があるのは非常に簡単です。
厳密に等しい場合、値はすでに正しいデータ構造でなければならないため、自動的に暗黙的に変換されることはありません。
JavaScriptで2つのことを比較する場合は===を使用します。これは厳密に等しい、型と値の両方が同じであるため、これはtrueを返すことを意味します）。あなたが==を使っているのであれば、型の訂正はあなたのために基本的には気にせず、多くの場合あなたはゆるい等式比較で問題に直面する可能性があります。
===を使用した厳密な等価
厳密等価性は、等価性について2つの値を比較します。どちらの値も、比較前に暗黙的に他の値に変換されることはありません。値のタイプが異なる場合、値は等しくないと見なされます。それ以外の場合、値が同じ型を持ち、数値ではない場合、それらが同じ値を持つ場合、それらは等しいと見なされます。最後に、両方の値が数値である場合、それらが両方とも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
==を使って平等を緩める
緩い等号は、両方の値を共通の型に変換した後、2つの値が等しいかどうかを比較します。変換後（片側または両側で変換が行われる可能性があります）、最終的な等価比較は、===の変換とまったく同じように実行されます。緩い等式は対称的です：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);
==を===に置き換えることを提案しているのは、===演算子が==より信頼性が高いからです。私たちの文脈では、===は型チェックにも使えるという信頼できる手段です。最良のプログラミング方法を考慮すると、信頼性の低い機能よりも信頼性の高い機能を常に選択する必要があります。繰り返しますが、ほとんどの場合、演算子と正確に等しいと考えるときはいつでも、デフォルトでは型は同じであるべきだと考えます。 ===が同じことを提供するので、私達はそれのために行くべきです。
Javascriptはphpと同じように大まかに型付けされています、
var x = "20";
var y =20;
if (x===y) // false
変数の値が同じであってもデータ型が正しくないため、これは常に偽を与えます。
一方は文字列、他方はintです。
If(x==y)//true
ただし、データ型に関係なく、内容が同じかどうかを確認するだけです。
文字列値はint値と論理的に等しくなることはできないので、値が等しいとは言いたくありません。
まず、Javascript文字列の等号についてのいくつかの用語があります。二重等号は正式には抽象等価比較演算子として知られていますが、三重等号は厳密等価比較演算子と呼ばれます。両者の違いは次のようにまとめることができます。抽象等価性は、比較を行う前に型強制によってデータ型を解決しようとします。型が異なる場合、厳密な等号はfalseを返します。次の例を見てください。
console.log(3 == "3"); // true
console.log(3 === "3"); // false.
console.log(3 == "3"); // true
console.log(3 === "3"); // false.
2つの等号を使用すると、比較が行われる前にストリング「3」が数値3に変換されるため、trueが返されます。 3つの等号は、型が異なり偽を返すことを示しています。これはもう一つです：
console.log(true == '1'); // true
console.log(true === '1'); // false
console.log(true == '1'); // true
console.log(true === '1'); // false
やはり、抽象等価比較は型変換を実行します。この場合、ブール値のtrueと文字列 '1'の両方が数値1に変換され、結果はtrueになります。厳密な等式は偽を返します。
==と===を見分ける方法がうまくいっていることを理解していれば。ただし、これらの演算子の動作が直感的ではないシナリオがいくつかあります。もう少し例を見てみましょう。
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
「JavaScriptの比較に==または===を使用する必要があります」というジレンマは、「食事に「スプーン」または「フォーク」を使用する必要がある」という質問と同じまたは類似しています。
この質問に対する唯一の合理的な答えは、
- 動的型 比較（例：緩い型/の比較には
==を使うべきです。 - 静的型 比較（例：strong Type/の比較には
===を使うべきです。
それは彼らが同じではないからです。それらは同じ目的を持っておらず、同じ目的のために使われることを意図していません。
もちろん、「フォーク」と「スプーン」はどちらも「食べる」ことを目的としていますが、あなたは食べたことに応じてそれらを使用することを選択するでしょう。
意味：あなたは 'スプーン'を使うことに決心するでしょう： 'スープ'を持つための==そして/または 'フォーク'：を選ぶための===。
「食べる」には「フォーク」と「スプーン」のどちらを使用するのが良いかを尋ねることは、静的[===]対動的[==]方程式を使うのが良いかどうかを尋ねることと同じです。 JSで。どちらの質問も等しく間違っており、問題の主題に関する非常に狭いまたは浅い理解を反映しています。
var a = new String("123");
var b = "123";
alert(a === b); // returns false !! (but they are equal and of the same type)
答えの一つでこれを見た。この場合、aとbは実際には同じ型ではありません。もしtypeof(a)をチェックすれば 'object' そしてtypeof(b)は 'string' となります。