論理演算子 - javascript=== 否定




演算子(== vs===)と等しいJavaScriptは、JavaScriptの比較で使用する必要がありますか? (20)

2つの操作のパフォーマンスの違いはほとんどありません。 両方のパラメータがすでに同じ型であるため、実行する型変換はありません。 どちらの演算も、型比較の後に値の比較を行います。

私はJSLintを使ってJavaScriptを使っていますが、 idSele_UNVEHtype.value.length == 0idSele_UNVEHtype.value.length == 0内で比較するようなことをするとき== (2つの等号)を===ステートメント。

====に置き換えるとパフォーマンス上のメリットはありますか?

多くの比較演算子が存在するため、パフォーマンスの改善は歓迎されます。

タイプ変換が行われない場合は、 ==以上のパフォーマンスが得られますか?


JSLintは時々あなたに物を修正する非現実的な理由を与えます。 ===すでに型が同じであれば==と全く同じ性能を持ちます。

型が同じでない場合にのみ、より速くなります。この場合、型の変換は試みませんが、直接falseを返します。

だから、IMHO JSLintは新しいコードを書くのに使われるかもしれませんが、無駄なオーバーオプティマイゼーションは避けてください。

意味は、 == to ===if (a == 'test')ようなチェックで変更する理由はありません。

開発者や批評家の時間を無駄にし、何も達成しないように多くのコードを修正する


JavaScriptでは、同じ値と型を意味します。

例えば、

4 == "4" // will return true

しかし

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

PHPとJavaScriptでは、厳密な等価演算子です。 つまり、タイプと値の両方を比較します。


=====間の等価比較の興味深い図解表現。

出典: dorey.github.io/JavaScript-Equality-Table : dorey.github.io/JavaScript-Equality-Table

var1 === var2

JavaScriptの等価性テストに===を使用すると、すべてがそのままです。 評価される前に変換されるものはありません。

var1 == var2

JavaScriptの等価性テストに==を使用すると、いくつかの面白い変換が行われます。

この話の教訓:

あなたが==で起こる変換を完全に理解しない限り、 ===使用してください。


==演算子の使用( 等価

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つのことを覚えておいてください:

  1. 推移的ではない: (a == b)(b == c)(a == c)
  2. 否定とは相互に排他的です: (a == b)(a!= b)は常に反対のブール値を持ち、すべてaとbです。
  3. 疑いがある場合は、以下の真理値表を心に留めてください。

JAVASCRIPTの等号演算子の真理値表

  • テーブルの各行は、3つの相互に等しい値のセットです。つまり、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.

===演算子は厳密比較演算子と呼ばれ、 ==演算子と異なります。

aとbの2つのvarsを取​​ることができます。

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

要約すると==演算子を使用することは、 ===演算子を使用しない方が安全であると思われる状況で真と評価される可能性があります。

90%の使用シナリオでは、どちらを使用するかは関係ありませんが、ある日、予期しない動作が発生した場合の違いを知ることは便利です。


はい! それは問題である。

===演算子は、javascriptの値と型をチェックし as ==演算子は値をチェックします(必要に応じて型変換を行います)

簡単にテストすることができます。 次のコードをHTMLファイルに貼り付けてブラウザで開きます

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

あなたは警告で「 」を得るでしょう。 onPageLoad()メソッドを変更してalert(x == 5); あなたは本当になるでしょう。


nullとundefinedは無駄です。つまり、

var a;
var b = null;

ここには値がaありbません。一方、0、偽、および 'はすべて値です。これら全てに共通しているのは、すべてが虚偽の値であるということです。つまり、すべて虚偽の条件を満たすことを意味します。

したがって、0、false、および ''は一緒にサブグループを形成します。一方、第2のサブグループをヌル&未定義フォームにします。下の画像の比較を確認してください。nullとundefinedは等しくなります。他の3つはお互いに等しいでしょう。しかし、それらはすべてJavaScriptで偽の条件として扱われます。

これは、任意のオブジェクト({}や配列など)と同じですが、空でない文字列&Boolean trueは真実の条件です。しかし、彼らはすべて平等ではありません。


この弁護士を追加しましょう:

不確かな場合は、 specification読みください!

ECMA-262は、JavaScriptが方言であるスクリプト言語の仕様です。 もちろん、実際には、何かが処理されるはずの難解な定義よりも、最も重要なブラウザがどのように動作するかが重要です。 しかし、なぜ新しいString( "a")!== "a"なのかを理解することは役に立ちます。

この質問を明確にするために仕様を読む方法を説明してください。 私はこの非常に古い話題の中で、誰も非常に奇妙な効果の答えを持っていなかったことを知っています。 したがって、仕様を読むことができれば、これはあなたの職業であなたを大いに助けるでしょう。 獲得したスキルです。 それでは、続けましょう。

===についてPDFファイルを検索すると、仕様の56ページに移動します11.9.4。 Strict Equals Operator(===) 、そして私が見つけた仕様書を辿った後:

11.9.6厳密な等価比較アルゴリズム
比較x === y(xとyは値)は、 または偽を生成します 。 このような比較は以下のように行われる。
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の場合、xとyがまったく同じ文字列(対応する位置の同じ長さと同じ文字)の場合はtrueを返します 。 それ以外の場合はfalseを返します
12. Type(x)がBooleanである場合、xとyの両方がtrueまたは両方ともfalseの 場合trueを返します 。 それ以外の場合はfalseを返します
13. xとyが同じオブジェクトを参照している場合、または互いに結合しているオブジェクトを参照している場合はtrueを返します (13.1.2参照)。 それ以外の場合はfalseを返します

面白いのはステップ11です。はい、文字列は値型として扱われます。 しかし、これはなぜ新しいString( "a")!== "a"を説明するものではありません。 ECMA-262に準拠していないブラウザがありますか?

そんなに早くない!

オペランドの型を調べましょう。 typeof()でラップして自分で試してみてください。 私は、 新しい文字列( "a")がオブジェクトであり、ステップ1が使用されていることがわかります。タイプが異なる場合はfalseを返します

なぜ新しいString( "a")が文字列を返さないのか不思議なら、仕様書を読むエクササイズはどうですか? 楽しむ!

Aidiakapiは以下のコメントにこれを書いた:

仕様から

11.2.2新しいオペレータ

Type(コンストラクタ)がObjectでない場合は、TypeError例外をスローします。

言い換えれば、StringがObject型でない場合、それはnew演算子で使用できませんでした。

newは常にStringコンストラクタに対してもObjectを返します。 そして、悲しいことに! 文字列の値セマンティクス(手順11を参照)が失われます。

これはついに、 新しい文字列( "a")!== "a"を意味します。


これは、型強制変換なしでの等価性を意味します。型変換は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キロバイト== ":)あなたのケースでパフォーマンスの違いがあるかどうかをJavaScriptプロファイラが教えてくれるということです。

しかし、個人的に私はJSLintが示唆していることをします。 この推奨は、パフォーマンス上の理由からではなく、タイプ強制変換('\t\r\n' == 0)が真であるためです。


単に

== 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 

同じ辺のが同じであるかどうかをチェックします

例:

'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

同一性( === )演算子は、型変換が行われないことを除いて、等価( == )演算子と同じように動作し、型は同じであるとみなされる必要があります。

リファレンス: Javascriptチュートリアル:比較演算子

==演算子は、必要な型変換を行った後 、等価性を比較します。 ===演算子は変換を行わないので、2つの値が同じ型でない場合、 ===は単にfalse返しfalse 。 両方とも同等に速いです。

Douglas Crockfordの優れたJavaScript:The Good Parts

JavaScriptには、 ===!== 2つの等価演算子と、悪い双子==!= 2つのセットがあり!= 。 良いものは、あなたが期待する方法で動作します。 2つのオペランドが同じ型で同じ値を持つ場合、 ===trueを生成し、 !==false生成し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を生成しfalse

更新:

コメントの中の@Casebashと参照型に関する@Phillipe Laybaertの 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

特殊なケースは、そのリテラルを、そのtoStringまたはvalueOfメソッドのために同じリテラルに評価されるオブジェクトと比較する場合です。 たとえば、文字列リテラルとStringコンストラクタによって作成された文字列オブジェクトの比較を考えてみましょう。

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

ここで==演算子は2つのオブジェクトの値をチェックしてtrueを返しtrueが、 ===はそれらが同じ型ではなく、 falseを返すことを見ています。 どちらが正しいですか? それは本当にあなたが比較しようとしているものに依存します。 私のアドバイスは、質問を完全に回避し、文字列オブジェクトを作成するためにStringコンストラクタを使用しないことです。

参照
http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3


私は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回以上の覚えている)微妙な違いはごくわずかであると言いたい。 パフォーマンスはそれを行う理由ではありません 。 型の安全性(JavaScriptで手に入るほど安全です)、コードの品質は、


簡単な例は

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

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


上の2つの答えは両方とも==は平等を意味し、===は同一性を意味します。残念ながら、このステートメントは正しくありません。

==の両方のオペランドがオブジェクトである場合、それらが比較されて、それらが同じオブジェクトであるかどうかが確認されます。両方のオペランドが同じオブジェクトを指す場合、等価演算子はtrueを返します。そうでなければ、2つは等しくない。

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

上記のコードでは、aとbが同じオブジェクトではないため、==と===の両方がfalseになります。

つまり、==の両方のオペランドがオブジェクトの場合、==は===と同じように動作します。これは同一性も意味します。この2つの演算子の本質的な違いは型変換です。==は等価をチェックする前に変換を行いますが、===は変換しません。





identity-operator