web-dev-qa-db-fra.com

Javascript logique "! ==" opérateur?

Je suis de retour dans le développement web, et j'ai essayé de passer en revue les nuances de jscript récemment. Je parcourais la source de la bibliothèque d’extensions THREEx construite au-dessus de Three.JS et j’ai remarqué cette fonction.

THREEx.KeyboardState.prototype.pressed  = function(keyDesc)
{
    var keys    = keyDesc.split("+");
    for(var i = 0; i < keys.length; i++){
        var key     = keys[i];
        var pressed;
        if( THREEx.KeyboardState.MODIFIERS.indexOf( key ) !== -1 ){
            pressed = this.modifiers[key];
        }else if( Object.keys(THREEx.KeyboardState.ALIAS).indexOf( key ) != -1 ){
            pressed = this.keyCodes[ THREEx.KeyboardState.ALIAS[key] ];
        }else {
            pressed = this.keyCodes[key.toUpperCase().charCodeAt(0)];
        }
        if( !pressed)   return false;
    };
    return true;
}

Je regarde en particulier la ligne ici:

if( THREEx.KeyboardState.MODIFIERS.indexOf( key ) !== -1 ){

Je ne suis pas au courant de cela! Opérateur ==. J'ai vérifié w3schools et leur liste d'opérateurs logiques ne comprend pas celle-ci. Je ne sais pas si c'est mal orthographié et les navigateurs le considèrent simplement comme! = Ou s'il a une autre signification. De plus, je me demandais s’il s’agissait d’un opérateur logique unique ou d’une combinaison, par exemple! + ==?

javascriptsyntaxlogical-operators
49
Cory Gross

Tu peux trouver === et !== opérateurs dans plusieurs autres langages à typage dynamique. Cela signifie toujours que les deux valeurs ne sont pas uniquement comparées par leur valeur "implicite" (c'est-à-dire que l'une ou les deux valeurs peuvent être converties pour les rendre comparables), mais également par leur type d'origine.

Cela signifie fondamentalement que si 0 == "0" retourne vrai, 0 === "0" retournera false car vous comparez un nombre et une chaîne. De même, alors que 0 != "0" retourne false, 0 !== "0" retourne vrai.

88
Wormbo

C'est != sans contrainte de type. Voir le documentation MDN pour les opérateurs de comparaison .

Voir aussi cette réponse StackOverflow , qui inclut une citation de "JavaScript: les bonnes parties" sur les problèmes rencontrés avec == et !=. (null == undefined, false == "0", etc.)

Réponse courte: toujours utilisez === et !== sauf si vous avez une raison impérieuse de faire autrement. (Des outils tels que JSLint , JSHint , ESLint , etc. vous donneront le même conseil.)

18
Joe White

Copié de la spécification formelle: ECMAScript 5.1 Section 11.9.5

11.9.4 L'opérateur Strict Equals (===)

La production EqualityExpression: EqualityExpression === RelationalExpression est évaluée comme suit:

  1. Soit lref le résultat de l'évaluation EqualityExpression.
  2. Soit lval GetValue ( lref).
  3. Soit rref le résultat de l’évaluation RelationalExpression.
  4. Soit rval soit GetValue ( rref).
  5. Renvoie le résultat de la comparaison d'égalité stricte rval === lval. (Voir 11.9.6)

11.9.5 L’opérateur strict n’est pas égal (! ==)

La production EqualityExpression: EqualityExpression! == [RelationalExpression est évaluée comme suit:

  1. Soit lref le résultat de l'évaluation EqualityExpression.
  2. Soit lval GetValue ( lref).
  3. Soit rref le résultat de l’évaluation RelationalExpression.
  4. Soit rval soit GetValue ( rref). Soit r le résultat d’une comparaison stricte des égalités rval === lval. (Voir 11.9.6)
  5. Si r est vrai , renvoie faux . Sinon, retourne vrai .

11.9.6 Algorithme de comparaison d'égalité stricte

La comparaison x === y, où x et y sont des valeurs , produit vrai ou faux . Une telle comparaison est effectuée comme suit:

  1. Si Type ( x) est différent de Type ( y), retournez false .
  2. Type ( x) est indéfini, retournez vrai .
  3. Type ( x) est nul, retourne vrai .
  4. Le type ( x) est un nombre, puis
    1. Si x est NaN, retournez false .
    2. Si y est NaN, retournez false .
    3. Si x est la même valeur numérique que y, retourne vrai .
    4. Si x est +0 et y est -0, retourne vrai .
    5. Si x est -0 et y est +0, retourne vrai .
    6. Renvoie false .
  5. Si Type ( x) est une chaîne, retournez true si x et y sont exactement la même séquence de caractères (même longueur et mêmes caractères aux positions correspondantes); sinon, retourne false .
  6. Si Type ( x) est booléen, retournez vrai si x et y are both true ou les deux false ; sinon, retourne false .
  7. Retour vrai si x et y font référence au même objet. Sinon, retourne false .
8
kay

Le !== opererator vérifie si les valeurs ne sont pas égales ou du même type. c'est à dire.

var x = 5;
var y = '5';
var 1 = y !== x; // true
var 2 = y != x; // false
2
secretformula

référence ici

! == est l'opérateur strict non égal et renvoie uniquement la valeur true si les deux opérandes ne sont pas égaux et/ou ne sont pas du même type. Les exemples suivants renvoient un booléen vrai:

a !== b 
a !== "2" 
4 !== '4'
2
Brendan Cutajar

!==

Ceci est l'opérateur strict non égal et renvoie uniquement la valeur true si les deux opérandes ne sont pas égaux et/ou ne sont pas du même type. Les exemples suivants renvoient un booléen vrai:

a !== b
a !== "2"
4 !== '4'
0
Rahul