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


Answers

==演算子の使用( 等価

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

これは、 等価演算子==が型変換を実行するためです。つまり、インタプリタは暗黙的に値を変換してから比較することを意味します。

一方、 アイデンティティ演算子===は型強制を行わないため、比較の際に値を変換しません。

Question

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

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

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

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




* Operators === vs == *

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



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

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


var1 === var2

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


var1 == var2

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


ストーリーの道徳的:2つのイコールで行われるコンバージョンを完全に理解していない限り、3つのイコールを使用します。




Equality comparison:

Operator ==

Returns true, when both operands are equal. The operands are converted to the same type before being compared.

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

Equality and type comparison:

Operator ===

Returns true if both operands are equal and of the same type. It's generally better and safer if you compare this way, because there's no behind-the-scenes type conversions.

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



===演算子は、値と変数の型が等しいかどうかをチェックします。

==演算子は、変数の値が等しいかどうかをチェックするだけです。




なぜ==は予測できないのですか?

空の文字列""と数字の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つの値が同じかどうかをチェックする「トリプル・イコール」( === )とは異なります。

== 他のものがたくさんあります。

それは関数の特別な処理、ヌルの特別な処理、未定義の文字列、あなたは名前を付けます。

それはかなり変なことになる。

実際に、あなたが何をするかを行う関数を書こうとすると、これは次のようになります:

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

それはどういう意味ですか?

それは==が複雑であることを意味します。

複雑なので、使用するときに何が起こるのかを知ることは難しいです。

つまり、あなたはバグに終わる可能性があります。

その話の道徳は、

あなたの人生をより複雑にする。

==代わりに===を使用します。

終わり。




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

==の両方のオペランドがオブジェクトである場合、それらが比較されて、それらが同じオブジェクトであるかどうかが確認されます。 If both operands point to the same object, then the equal operator returns true. Otherwise, the two are not equal.

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

In the code above, both == and === get false because a and b are not the same objects.

That's to say: if both operands of == are objects, == behaves same as ===, which also means identity. The essential difference of this two operators is about type conversion. == has conversion before it checks equality, but === does not.




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

例:

'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"



From the core javascript reference

=== Returns true if the operands are strictly equal (see above) with no type conversion.




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

例えば、

4 == "4" // will return true

しかし

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



単に

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



等しい比較演算子==は混乱するので、避けるべきです。

あなたがそれに住んでいなければならない場合は、次の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.



これは、型強制変換なしでの等価性を意味します。型変換は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 



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

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

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

<script>

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

</script>

</head>

<body onload='onPageLoad();'>

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




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




Links