Quelle est la différence entre (NaN != NaN) et (NaN !== NaN)?

Tout d'abord, je tiens à mentionner que je sais comment isNaN() et Number.isNaN() travail. Je suis de lecture Le Précise le Guide de par David Flanagan et il donne un exemple de la façon de vérifier si la valeur est NaN:

x !== x

Ce résultat true si et seulement si x est NaN.

Mais maintenant j'ai une question: pourquoi utilise-t-il une comparaison stricte? Parce qu'il semble que 

x != x

se comporte de la même manière. Est-il sécuritaire d'utiliser les deux versions, ou il me manque une certaine valeur(s) dans le JavaScript qui sera de retour true pour x !== x et false pour x != x?

  • À mon avis , une comparaison stricte (===) est plus précis que les autres. parce qu'il compare non seulement la valeur, mais aussi le type de données de cet objet.
  • ok, mais le type de NaN is number et il n'est pas nécessaire pour une comparaison stricte? C'est comme dans ce cas c'est juste une question de style, je pense.
  • selon votre entrée x==y est également faux
  • Il se pourrait que Flanagan qu'on préfère !== contrôles de plus de != contrôles. Autant que je sache, il n'y a pas d'autre valeur où x != x. Mais il y a deux groupes distincts les développeurs JavaScript: ceux qui préfèrent != et ceux qui préfèrent !==, que ce soit pour la vitesse, la précision, l'expressivité, etc.
  • Pour vérifier ce qui est de la comparaison de deux valus à partir du même type == ou != doit toujours retourner le même résultat que === et !==. Les problèmes apparaissent lorsque l'on compare les différents types.
  • Pourquoi utiliser lâche la comparaison lors de la comparaison stricte se comporte de la même manière?
  • NaN est l'unique type d'objet qui n'est pas égale à elle-même.
  • NaN n'est pas un type unique, c'est un nombre. C'est une valeur unique qui n'est pas égal à lui-même.
  • Le titre semble être tromper les gens. Je vous suggère de le changer pour quelque chose comme "Est x != x toujours différent de x !== x?"
  • == et === sont pas juste le style de préférence. Ils servent à des fins différentes pour ceux qui comprennent comment ils fonctionnent. Ilsne pas se comportent de la même, mais ont parfois les mêmes résultats. Ma réponse a donné plusieurs exemples de cas où elles sont différentes. David Flanagan est aussi mauvais pour l'aide soit == ou === pour NaN comparaison de toute façon. NaN est une valeur unique qui n'est pas égal à quoi que ce soit-y compris lui-même--de sorte que même lorsque x est NaN, x == NaN et x === NaN sera toujours faux. C'est pourquoi la négation semble se comporter de la même, il est toujours faux, sauf si vous utilisez isNaN().
  • Giorgi a dit "dans ce cas," c'est une affaire de style. Et il a raison. Il n'est pas le style quand les types des opérandes sont différents, mais il est de style quand ils sont les mêmes. Séparément: Flanagan est de faire ces comparaisons avec === avec NaN pour faire le point que NaN n'est pas égal à lui-même. Il n'est pas "mal", qu'il fait ça comme une tâche d'enseignement, ce qui démontre que ça ne fonctionne pas.
  • Je viens de tomber sur cet article après la lecture de votre question, le point n ° 4 adresses des opérateurs d'égalité et sont susceptibles de vous intéresser. À peu près la même que T. J. Crowder a été affirmant dans sa réponse: toptal.com/javascript/10-most-common-javascript-mistakes

InformationsquelleAutor Giorgi Nakeuri | 2015-12-14
  1. 128

    Tout d'abord, permettez-moi de souligner que NaN est un très spécial valeur: Par définition, il n'est pas égal à lui-même. Qui vient de la norme IEEE-754 que JavaScript numéros de dessiner. Le "pas un nombre" la valeur n'est jamais égal à lui-même, même lorsque les bits sont une correspondance exacte. (Ce qu'ils ne sont pas nécessairement dans la norme IEEE-754, il permet de multiples "pas un nombre" valeurs). C'est pourquoi cette même sort; toutes les autres valeurs de JavaScript sont égaux à eux-mêmes, NaN est juste spécial.

    ...je manque un peu de valeur en JavaScript qui retourne true, pour x !== x et fausse pour x != x?

    Non, vous n'êtes pas. La seule différence entre !== et != est que ce dernier va faire de ce type de coercition si nécessaire pour obtenir les types des opérandes de même. Dans x != x, les types des opérandes sont les mêmes, et donc c'est exactement la même que x !== x.

    C'est clair depuis le début de la définition de la Résumé De L'Égalité De L'Opération:

    1. ReturnIfAbrupt(x).
    2. ReturnIfAbrupt(y).

    3. Si Type(x) est le même que le Type(y), alors

      Retourner le résultat de l'exécution Stricte Comparaison d'Égalité x === y.

    4. ...

    Les deux premières étapes sont à la base de la plomberie. En effet, la première étape de == est de voir si les types sont les mêmes et, le cas échéant, à faire === à la place. != et !== sont tout simplement annulés versions de l'.

    Donc si Flanagan est exact que seulement NaN donne le vrai pour x !== x, on peut être sûr que c'est aussi vrai que seule NaN donne le vrai pour x != x.

    De nombreux programmeurs JavaScript par défaut à l'aide de === et !== pour éviter quelques pièges autour de la contrainte de type souple, opérateurs de le faire, mais il n'y a rien à lire dans Flanagan utilisation de la stricte vs loose opérateur dans ce cas.

    • J'ai relu 4.9.1 - Equality and Inequality Operators section et ce semble être la réponse. Le point clé pour === comparaison est: If the two values have the same type, test them for strict equality as described above. If they are strictly equal, they are equal. If they are not strictly equal, they are not equal.
    • Je ne suis pas sûr de ce que 4.9.1 vous faites allusion, peut-être Flanagan livre? Mais c'est essentiellement à dire que la citation de la spécification ci-dessus est dit, oui.
    • Oui, c'est à partir de Flanagan, 6e édition. Merci pour le lien sur les specs.
    • Je suis d'accepter cela car cela répond à ma question dans formalisé et précis de la mode. Merci pour les explications!
    • avec es modules et de vivre des liaisons, import a from 'a'; console.log(a !== a) peut retourner true pour les non valeurs NaN
    • Qu'entendez-vous par "vivre liaisons"? (Le terme n'apparaît pas dans la spec.) Voulez-vous dire quelque chose comme GOTO 0 exemple où a est en fait une fonction et ne retourne pas la même valeur à deux reprises? Ce n'est pas la même chose qu'un valeur pour ce qui !== serait vrai, c'est ce que l'OP a demandé à propos. C'est juste une fonction qui renvoie des valeurs différentes. foo() !== foo() n'est pas forcément vrai, puisque foo peut retourner des valeurs différentes à chaque appel.
    • quelque chose comme ceci: C'est un plaisir de WAT moment: babeljs.io/repl/...
    • Eh bien, c'est un super-méchant façon de jouer avec les propriétés et les méthodes de lecture. Mais il semble être à peu près le même que GOTO 0 exemple, juste avec une couche supplémentaire d'indirection.
    • Je pense que cette réponse doit préciser que (NaN !== NaN (même si c'est la même variable par rapport à lui-même) et que c'est un mauvais exemple de la façon dont les opérateurs de comparaison fonctionnent réellement. NaN devraient généralement être évités en raison de sa confusion de mise en œuvre. (typeof NaN === "nombre"), etc
    • "il permet pour de multiples "pas un nombre" valeurs". -- Pouvez-vous fournir un lien à l'appui de cette confusion déclaration?
    • À partir de ecma-international.org/ecma-262/5.1/#sec-8.5: pour ECMAScript code, toutes les valeurs NaN sont indiscernables les uns des autres. Donc, il n'y a pas plusieurs valeurs.
    • C'est dans la norme IEEE-754 cahier des charges, qui vous pouvez facilement trouver (mais exige le paiement). Il est également couvert dans le IEEE-754 et NaN les pages de Wikipedia. Quant à votre citation de la JS spec, notez la phrase où je mentionner: "(qu'ils ne sont pas nécessairement dans la norme IEEE-754, il permet de multiples "pas un nombre" valeurs)." Et juste parce qu'ils sont indiscernables en JS, il ne signifie pas qu'il n'y a pas plus d'un, surtout s'ils viennent de l'extérieur de la JS env.
    • Un exemple de la façon dont les deux valeurs différentes peuvent venir?
    • N'importe quel nombre reçu à partir de l'hôte de l'environnement pourrait avoir l'un des 2^53 bits différents modèles de permis pour NaN, peut-être 0111 1111 1111 0100 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 ou 0111 1111 1111 0111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111 1111. Pour cette question, un JS moteur est libre d'avoir des calculs qui en résultent dans les différents types de NaNs -- et pourrait bien, si elle utilise le PROCESSEUR à virgule flottante de la fpo. Nous n'avons aucun moyen de dire, bien sûr, parce que JS traite tous de la même malgré le fait qu'ils sont distincts dans la norme IEEE-754.

    InformationsquelleAutor T.J. Crowder
  2. 37

    Pour les fins de NaN, != et !== faire la même chose.

    Cependant, de nombreux programmeurs éviter == ou != en JavaScript. Par exemple, Douglas Crockford considère parmi les "de mauvaises pièces" du langage JavaScript, car ils se comportent dans l'inattendu et déroutant façons:

    JavaScript a deux ensembles d'opérateurs d'égalité: === et !==, et leurs jumeaux maléfiques == et !=. Les bons de travail de la façon que vous attendez.

    ...Mon conseil est de ne jamais utiliser les evil twins. Au lieu de cela, utilisez toujours === et !==.

    • La question n'est pas à propos de NaN (malgré le titre). La question est "je manque un peu de valeur en JavaScript qui retourne true, pour x !== x et fausse pour x != x?"
    • Deux questions. La première question est "Est-il sûr d'utiliser les deux versions" et la réponse est que les deux versions sont équivalentes. J'aime votre "sous le capot" réponse qui explique tout en détail.
    InformationsquelleAutor jkdev
  3. 22

    Juste pour le plaisir, laissez-moi vous montrer un exemple artificiel où x n'est pas NaN mais les opérateurs se comportent différemment de toute façon. D'abord définir:

    Object.defineProperty(
  self,
  'x',
  { get: function() { return self.y = self.y ? 0 : '0'; } }
);

    Puis nous avons

    x != x //false

    mais

    x !== x //true
    • Ha! 🙂 Mais c'est effectivement foo() != foo() où foo retourne 1 puis 2. E. g., le valeurs ne sont pas les mêmes, c'est juste la comparaison des valeurs différentes.
    InformationsquelleAutor GOTO 0
  4. 2

    Je veux juste souligner NaN n'est pas la seule chose qui produit x !== x sans l'aide de l'objet global. Il y a beaucoup de moyens astucieux pour déclencher ce problème. Ici est en utilisant les méthodes de lecture:

    var i = 0, obj = { get x() { return i++; }};
with(obj) //force dynamic context, this is evil. 
console.log(x === x); //false

    Comme d'autres réponses à souligner, == effectue ce type encore de la contrainte, mais aussi dans d'autres langues et par la norme - NaN indique un calcul d'échec, et pour de bonnes raisons, n'est pas égale à elle-même.

    Pour une raison quelconque au-delà de moi des gens qui ocnsider-ce un problème avec JS, mais la plupart des langues qui ont des doubles (à savoir, C, Java, C++, C#, Python et autres) présentent ce comportement exact et les gens sont juste très bien avec elle.

    • Oui, c'est exactement ce que @T. J. Crowder a mentionné dans le commentaire de GOTO_0 réponse, n'est-ce pas?
    • Pourriez-vous préciser comment faire pour obtenir l'ambiguïté de la contrainte de type dans ces autres langues?
    InformationsquelleAutor Benjamin Gruenbaum
  5. 0

    Que parfois, les images valent mieux que des mots, cochez cette table (qui est la raison pour moi de faire une réponse au lieu d'un commentaire, c'est parce qu'il obtient une meilleure visibilité).

    Là, vous pouvez voir une stricte égalité de comparaison (===) ne renvoie vrai si le type et le contenu du match, donc 

    var f = "-1" === -1; //false

    Tout abstrait comparaison d'égalité (==) vérifie seulement le contenu* par conversion de types, puis strictement comparer:

    var t = "-1" == -1; //true

    Si ce n'est pas clair, sans consulter ECMA, du JavaScript qui considère que lors de la comparaison, de manière à ce que le code soufflet évalue à true.

     var howAmISupposedToKnowThat = [] == false; //true
    InformationsquelleAutor MVCDS