私はJSLintを使用してJavaScriptを調べていますが、ステートメント内で比較するなどのことを行うときに、 ==（2つの等号）を（3つの等号）に置き換えるための多くの提案を返しています。===idSele_UNVEHtype.value.length == 0if
に置き換える==とパフォーマンス上の利点はあり===ますか?
多くの比較演算子が存在するため、パフォーマンスの向上は歓迎されます。
型変換が行われない場合、パフォーマンスは向上し==ますか?
1983441 次
48 に答える
6941
厳密な等値演算子 ( ) は、型変換が行われないことを除い===て、抽象等値演算子 ( ) と同じように動作し、同じと見なされるには型が同じでなければなりません。==
リファレンス: Javascript チュートリアル: 比較演算子
演算子は、必要な型変換を行った後==、等しいかどうかを比較します。演算子は変換を行わないため、2 つの値が同じ型でない場合、単純に が返されます。どちらも同じように速いです。======false
Douglas Crockford の優れたJavaScript: The Good Partsを引用すると、
JavaScript には 2 組の等値演算子があります。
===and!==と、それらの双子の==and!=です。良いものは、期待どおりに機能します。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
推移性の欠如は驚くべきことです。私のアドバイスは、悪の双子を決して使わないことです。代わりに、常に and を使用
===して!==ください。今示したすべての比較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
toString特殊なケースは、プリミティブを、そのorvalueOfメソッドのために同じプリミティブに評価されるオブジェクトと比較する場合です。たとえば、文字列プリミティブと、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
于 2008-12-11T14:25:06.430 に答える
1214
==演算子の使用( 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
これは、等値演算子==が型強制を行うためです。つまり、インタープリターは比較する前に値を暗黙的に変換しようとします。
一方、ID 演算子===は型強制を行わないため、比較時に値を変換しないため、1 ステップスキップするため ( This JS ベンチマークテストによると) 高速です。
于 2008-12-11T14:33:58.317 に答える
837
==との等値比較の興味深い視覚化を次に示し===ます。
ソース: https://github.com/dorey/JavaScript-Equality-Table (デモ、統合デモ)
var1 === var2
JavaScript の等価性テストに使用する場合===は、すべてそのままです。
評価される前に何も変換されません。
var1 == var2
==JavaScript の等価性テストに使用すると、奇妙な変換が行われます。
Javascript での等価性のまとめ
結論：
で行われる奇妙な変換を完全に理解していない限り==、常に を使用して===ください。
于 2014-05-05T05:21:25.513 に答える
646
ここでの回答では、 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場合に true を返しますab
参照型の場合:とがまったく同じオブジェクトを
a === b場合に true を返しab
文字列の場合:とが両方とも文字列で、まったく同じ文字が含まれている
a === b場合に true を返しますab
文字列: 特殊なケース...
文字列は値型ではありませんが、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
于 2009-06-05T19:11:36.920 に答える
281
この助言を追加させてください：
疑わしい場合は、仕様をお読みください。
ECMA-262は、JavaScriptが方言であるスクリプト言語の仕様です。もちろん、実際には、何かがどのように処理されるかについての難解な定義よりも、最も重要なブラウザーがどのように動作するかが重要です。しかし、なぜnew String（ "a"）！=="a"であるかを理解することは役に立ちます。
この質問を明確にするために、仕様の読み方を説明させてください。この非常に古いトピックでは、非常に奇妙な効果について誰も答えを持っていなかったことがわかります。したがって、仕様を読むことができれば、これはあなたの職業に非常に役立ちます。習得したスキルです。それでは、続けましょう。
PDFファイルで===を検索すると、仕様の56ページに移動します：11.9.4。Strict Equals Operator（===）、そして仕様書をくぐり抜けた後、私は見つけました：
11.9.6厳密な等式比較アルゴリズム
比較x===y（xとyは値）は、trueまたはfalseを生成します。このような比較は次のように実行されます
。1。Type（x）がType（y）と異なる場合は、falseを返します。
2. Type（x）がUndefinedの場合、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の場合、xとyがまったく同じ文字シーケンス（対応する位置で同じ長さと同じ文字）であればtrueを返します。それ以外の場合は、 falseを返します。
12. Type（x）がブール値の場合、xとyが両方ともtrueまたは両方がfalseの場合はtrueを返します。それ以外の場合は、 falseを返します。 13.trueを返す
xとyが同じオブジェクトを参照している場合、または互いに結合されているオブジェクトを参照している場合（13.1.2を参照）。それ以外の場合は、 falseを返します。
興味深いのはステップ11です。はい、文字列は値型として扱われます。しかし、これはnew String（ "a"）！=="a"の理由を説明していません。ECMA-262に準拠していないブラウザはありますか？
そんなに早くない！
オペランドの種類を確認してみましょう。typeof（）でラップして、自分で試してみてください。new String（ "a"）がオブジェクトであり、ステップ1が使用されていることがわかりました。タイプが異なる場合はfalseを返します。
new String（ "a"）が文字列を返さないのはなぜか疑問に思われる場合は、仕様を読む練習をしてみてはどうでしょうか。楽しむ！
Aidiakapiはこれを以下のコメントに書いています：
仕様より
11.2.2新しい演算子：
Type（コンストラクター）がObjectでない場合は、TypeError例外をスローします。
つまり、StringがObject型でない場合、new演算子で使用することはできません。
newは、 Stringコンストラクターの場合でも、常にObjectを返します。そして悲しいかな！文字列の値のセマンティクス（手順11を参照）は失われます。
そしてこれは最終的に次のことを意味します：new String（ "a"）！=="a"。
于 2009-11-28T18:18:00.283 に答える
109
次のようなコードを使用して、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");私の結果（それぞれ5回テストされ、平均化されました）：
==: 115.2
===: 114.4
したがって、ごくわずかな違い（これは100000回を超える反復です、覚えておいてください）はごくわずかだと思います。パフォーマンスはそうする理由ではありません===。安全性を入力すると（JavaScriptで取得するのと同じくらい安全です）、コードの品質はです。
于 2008-12-25T11:17:35.473 に答える
105
PHP と JavaScript では、これは厳密な等価演算子です。つまり、型と値の両方を比較します。
于 2010-05-12T12:58:39.810 に答える
101
JavaScript では、同じ値と型を意味します。
例えば、
4 == "4" // will return true
しかし
4 === "4" // will return false
于 2010-05-12T12:58:24.723 に答える
92
なぜ==そんなに予測不可能なのですか？
""空の文字列を数字の 0 と比較すると、何が得られます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**
そして、これはプリミティブで得られるクレイジーなものです。
オブジェクトで使用すると、まったく新しいレベルのクレイジーになり==ます。
この時点で、おそらく疑問に思うでしょう...
なぜこれが起こるのですか？
===2 つの値が同じかどうかをチェックするだけの "triple equals" ( ) とは異なります。
==他の多くのことを行います。
関数の特別な処理、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();
}
では、これはどういう意味ですか？
==複雑という意味です。
複雑なため、使用するとどうなるかわかりません。
つまり、バグが発生する可能性があります。
だから、物語の教訓は...
あなたの人生をより簡単にします。
===の代わりに使用し==ます。
終わり。
于 2016-08-09T16:50:12.523 に答える
91
===演算子は厳密な比較演算子と呼ばれ、 ==演算子とは異なります。
2 つの変数 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");
}
要約すると; ==演算子を使用すると、望ましくない状況で true と評価される可能性があるため、===演算子を使用する方が安全です。
90% の使用率のシナリオでは、どちらを使用しても問題ありませんが、ある日予期しない動作が発生した場合に違いを知っておくと便利です。
于 2008-12-11T14:58:51.417 に答える
86
===同じ辺の型と値が等しいことを確認します。
例：
'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
値が、、または _undefinednull0""
于 2010-05-12T12:58:12.090 に答える
75
厳密等価/比較「===」のJavascript実行フロー図
非厳密等価/比較「==」のJavascript実行フロー図
于 2015-09-05T13:53:16.283 に答える
56
型強制なしで等しいことを意味 します。型強制は、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
于 2010-05-12T12:59:09.960 に答える
50
一般的なスクリプトでは、パフォーマンスの違いはありません。もっと重要なのは、1000 の "===" は 1000 の "==" よりも 1 KB 重いという事実です:) JavaScript プロファイラーは、ケースにパフォーマンスの違いがあるかどうかを知ることができます。
しかし、個人的には、JSLint が提案することを行います。この推奨事項は、パフォーマンスの問題のためではなく、型強制の意味('\t\r\n' == 0)が true であるためです。
于 2008-12-16T14:29:16.423 に答える
48
等値比較演算子 == は紛らわしいので避けるべきです。
それと一緒に暮らす必要がある場合は、次の3つのことを覚えておいてください。
- 推移的ではありません: (a == b)および(b == c)は (a == c )にはなりません。
- その否定に対して相互に排他的です: (a == b)と(a != b)は常に反対のブール値を保持し、すべて a と b を持ちます。
- 疑問がある場合は、次の真理値表を暗記してください。
JAVASCRIPT の等価演算子の真理値表
- 表の各行は、3 つの相互に「等しい」値のセットです。つまり、等号 == 記号を使用すると、それらの値のうちの 2 つの値が等しいことを意味します*
** 奇妙: 最初の列の 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.
于 2011-09-16T14:25:11.027 に答える
41
あなたの使用法では、2 つの操作の間にパフォーマンスの違いはほとんどありません。両方のパラメーターが既に同じ型であるため、型変換を行う必要はありません。どちらの操作でも、型の比較に続いて値の比較が行われます。
于 2008-12-11T14:44:55.783 に答える
39
単に
==型強制によるオペランド間の比較を意味します
と
===型強制なしのオペランド間の比較を意味します。
JavaScript の型強制とは、データ型を他のデータ型に自動的に変換することを意味します。
例えば：
123 == "123" // Returns true, because JS coerces string "123" to number 123
// and then goes on to compare `123 == 123`.
123 === "123" // Returns false, because JS does not coerce values of different types here.
于 2015-03-20T05:05:48.057 に答える
34
===演算子は、値と変数の型が等しいかどうかをチェックします。
==演算子は、変数の値が等しいかどうかをチェックするだけです。
于 2010-05-12T13:03:37.447 に答える
34
厳しいチェックテストです。
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
于 2010-05-12T13:19:21.230 に答える
33
経験則として、私は一般的に===代わりに==(および!==代わりに!=) を使用します。
理由は上記の回答で説明されており、Douglas Crockford もそれについてかなり明確です ( JavaScript: The Good Parts )。
ただし、例外が 1 つあります。
== null「is null または undefined」をチェックする効率的な方法です。
if( value == null ){
// value is either null or undefined
}
たとえば、jQuery 1.9.1 はこのパターンを 43 回使用しており、JSHint 構文チェッカーeqnullはこの理由から緩和オプションも提供しています。
== を優先して、厳密な等価性チェック (===) を使用する必要があります。唯一の例外は、null を介して undefined と null をチェックする場合です。
// Check for both undefined and null values, for some important reason.
undefOrNull == null;
編集 2021-03:
現在、ほとんどのブラウザはNullish 合体演算子 ( ??)
と論理的な nullish 代入(??=)を
サポートしています。これにより、変数が null または未定義の場合に、より簡潔な方法でデフォルト値を割り当てることができます。次に例を示します。
if (a.speed == null) {
// Set default if null or undefined
a.speed = 42;
}
これらの形式のいずれかとして書くことができます
a.speed ??= 42;
a.speed ?? a.speed = 42;
a.speed = a.speed ?? 42;
于 2013-04-27T14:15:38.290 に答える
33
JSLint は時として、何かを変更する非現実的な理由を与えてくれます。タイプがすでに同じであるかのよう===に、まったく同じパフォーマンスを発揮します。==
型が同じでない場合にのみ高速です。その場合、型を変換しようとせず、直接 false を返します。
したがって、 IMHO 、 JSLint を使用して新しいコードを作成することもできますが、無駄な過度の最適化は絶対に避ける必要があります。
つまり、 a が文字列にしかならないという事実を知っている場合のように、チェックでに変更==する理由はありません。===if (a == 'test')
このように多くのコードを変更すると、開発者とレビュー担当者の時間が無駄になり、何も達成できません。
于 2012-06-05T07:53:04.983 に答える
28
簡単な例は
2 == '2' -> true, values are SAME because of type conversion.
2 === '2' -> false, values are NOT SAME because of no type conversion.
于 2015-05-14T14:45:00.333 に答える
26
== は平等を意味し、=== は同一性を意味します。残念ながら、この記述は正しくありません。
== の両方のオペランドがオブジェクトである場合、それらが同じオブジェクトであるかどうかを確認するために比較されます。両方のオペランドが同じオブジェクトを指している場合、等値演算子は 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 つの演算子の本質的な違いは、型変換に関するものです。== は等価性をチェックする前に変換を行いますが、=== は行いません。
于 2013-09-09T08:31:45.250 に答える
23
問題は、JavaScriptには暗黙の変換がたくさんあるため、簡単に問題が発生する可能性があることです...
var x = 0;
var isTrue = x == null;
var isFalse = x === null;
これはすぐに問題になります。暗黙の変換が「悪」である理由の最良のサンプルは、CStringからポインターtypedefタイプであるHANDLEへの暗黙の変換のために実際にコンパイルされるMFC /C++のこのコードから取得できます。
CString x;
delete x;
これは明らかに実行時に非常に未定義のことを行います...
それに対する議論のいくつかを得るためにC++とSTLで暗黙の変換のためのグーグル...
于 2008-12-29T11:54:44.320 に答える
23
===true型変換なしでオペランドが厳密に等しい場合 (上記を参照) を返します。
于 2010-05-12T12:59:13.563 に答える
22
等価比較:
オペレーター==
両方のオペランドが等しい場合、true を返します。オペランドは、比較される前に同じ型に変換されます。
>>> 1 == 1
true
>>> 1 == 2
false
>>> 1 == '1'
true
等価性と型の比較:
オペレーター===
両方のオペランドが等しく、同じ型である場合に true を返します。バックグラウンドでの型変換がないため、この方法で比較すると、一般的にはより適切で安全です。
>>> 1 === '1'
false
>>> 1 === 1
true
于 2013-10-02T21:54:43.567 に答える
21
発生する変換と と の違いを示す便利な比較表を次に示し==ます===。
結論として次のように述べています。
「2 つの等しい値に対して行われる変換を完全に理解していない限り、3 つの等しい値を使用してください。」
于 2014-03-27T00:18:06.257 に答える
18
*演算子 === vs == *
1 == true => true
true == true => true
1 === true => false
true === true => true
于 2014-03-19T12:08:11.163 に答える
13
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 + "]")
};
}
于 2015-08-06T05:44:24.543 に答える
12
===オブジェクトが同じかどうかを気にします。したがって、new String("Hello world") === "Hello world"false を返します。ただし、==オブジェクトが同じかどうかは気にしません。単に一方の引数を他方の型に変換するだけです。変換できない場合は false を返します。次にnew String("Hello world") == "Hello world"、false ではなく true を返します。
于 2015-03-29T21:48:22.663 に答える
7
常に' === ' を使用すると、何千もの間違いを避けることができます。今日では、オペランドの型を考慮して比較するため、さまざまなスタイル ガイドで三重等価を使用する方が望ましいとされています。
于 2016-07-01T13:29:08.937 に答える
5
==はい、等値演算子と恒等演算子には大きな違いがあり===ます。
型変換が行われないため、通常、ID 演算子のほうが高速に実行されます。ただし、値が同じ型の場合、違いは見られません。
私の投稿を確認してくださいJavaScript 等価演算子の伝説、型変換と比較アルゴリズムを含む詳細を多くの例で説明しています。
于 2016-01-04T13:26:38.350 に答える
1
Javascript は php と同じように型付けが緩く、
var x = "20";
var y =20;
if (x===y) // false
変数の値は同じですが、データ型が異なるため、これは常に false になります。
1つは文字列で、もう1つはintです
If(x==y)//true
ただし、これはデータ型に関係なく、コンテンツが同じかどうかを確認するだけです...
文字列値は論理的に int 値と等しくないため、値が等しいとは言いたくありません
于 2016-07-01T17:00:02.753 に答える
0
var a = new String("123");
var b = "123";
alert(a === b); // returns false !! (but they are equal and of the same type)
答えの1つでこれを見ました。
この場合、実際には同じタイプではありません。チェックaする
と、'object'とis 'string'が得られます。btypeof(a)typeof(b)
于 2016-07-05T12:53:56.197 に答える