Quel est le ! !! (not not) en JavaScript ?

Question

J'ai vu un code qui semble utiliser un opérateur que je ne reconnais pas, sous la forme de deux points d'exclamation, comme ceci : !! . Quelqu'un peut-il me dire ce que fait cet opérateur ?

Le contexte dans lequel j'ai vu cela était le suivant,

this.vertical = vertical !== undefined ? !!vertical : this.vertical;

Answer 1

Contraint oObject booléens. Si c'était falsey (par exemple, 0, null, undefined, etc.), il sera false, sinon, true.

!oObject  //Inverted boolean
!!oObject //Non inverted boolean so true boolean representation

Donc !! n'est pas un opérateur, c'est juste le ! opérateur de à deux reprises.

Answer 2

C'est une façon horriblement obscure de faire une conversion de type.

! moyens NO . Ainsi !true est false y !false est true . !0 est true y !1 est false .

Il s'agit donc de convertir une valeur en booléen, de l'inverser, puis de l'inverser à nouveau.

// Maximum Obscurity:
val.enabled = !!userId;

// Partial Obscurity:
val.enabled = (userId != 0) ? true : false;

// And finally, much easier to understand:
val.enabled = (userId != 0);

// Or just
val.enabled = Boolean(userId);

Nota: les deux dernières expressions ne sont pas exactement équivalentes à la première lorsqu'il s'agit de certains cas limites (lorsque userId est [] par exemple), en raison de la façon dont les != l'opérateur fonctionne et quelles sont les valeurs prises en compte sincère .

Answer 3

!!expr (deux ! suivi d'une expression) renvoie une valeur booléenne ( true o false ) en fonction de la vérité de l'expression. Elle a plus de sens lorsqu'elle est utilisée sur des types non booléens. Examinez les exemples suivants, en particulier le troisième exemple et les suivants :

          !!false === false
           !!true === true

              !!0 === false
!!parseInt("foo") === false // NaN is falsy
              !!1 === true
             !!-1 === true  // -1 is truthy
          !!(1/0) === true  // Infinity is truthy

             !!"" === false // empty string is falsy
          !!"foo" === true  // non-empty string is truthy
        !!"false" === true  // ...even if it contains a falsy value

     !!window.foo === false // undefined value is falsy
      !!undefined === false // undefined primitive is falsy
           !!null === false // null is falsy

             !!{} === true  // an (empty) object is truthy
             !![] === true  // an (empty) array is truthy; PHP programmers beware!

Answer 4

Préparez du thé :

!! n'est pas un opérateur. C'est la double utilisation de ! -- qui est l'opérateur logique "non".

---

En théorie :

! détermine la "vérité" de ce qu'une valeur n'est pas :

• La vérité est que false n'est pas true (c'est pourquoi !false résultats en true )

• La vérité est que true n'est pas false (c'est pourquoi !true résultats en false )

---

!! détermine la "vérité" de ce qu'est une valeur pas pas :

• La vérité est que true n'est pas pas true (c'est pourquoi !!true se traduit par true )

• La vérité est que false n'est pas pas false (c'est pourquoi !!false se traduit par false )

---

Ce que nous souhaitons déterminer dans la comparaison, c'est la "vérité" à propos de la valeur d'une référence, et non la valeur de la référence elle-même. Il existe un cas d'utilisation où l'on peut vouloir connaître la vérité sur une valeur, même si l'on s'attend à ce que la valeur soit false (ou falsey), ou si l'on s'attend à ce que la valeur ne soit pas de typeof boolean .

---

En pratique :

Considérons une fonction concise qui détecte la fonctionnalité d'une caractéristique (et dans ce cas, la compatibilité avec la plate-forme) au moyen de la fonction dactylographie dynamique (alias "dactylographie du canard"). Nous voulons écrire une fonction qui renvoie true si le navigateur de l'utilisateur prend en charge la norme HTML5 <audio> mais nous ne voulons pas que la fonction génère une erreur si l'élément <audio> est indéfini ; et nous ne voulons pas utiliser try ... catch pour gérer les erreurs éventuelles (parce qu'elles sont grossières) ; et aussi nous ne voulons pas utiliser une vérification à l'intérieur de la fonction qui ne révélerait pas systématiquement la vérité sur la caractéristique (par exemple, document.createElement('audio') créera toujours un élément appelé <audio> même si HTML5 <audio> n'est pas pris en charge).

---

Voici les trois approches :

// this won't tell us anything about HTML5 `<audio>` as a feature
var foo = function(tag, atr) { return document.createElement(tag)[atr]; }

// this won't return true if the feature is detected (although it works just fine)
var bar = function(tag, atr) { return !document.createElement(tag)[atr]; }

// this is the concise, feature-detecting solution we want
var baz = function(tag, atr) { return !!document.createElement(tag)[atr]; }

foo('audio', 'preload'); // returns "auto"
bar('audio', 'preload'); // returns false
baz('audio', 'preload'); // returns true

Chaque fonction accepte un argument pour un <tag> et un attribute à rechercher, mais ils renvoient chacun des valeurs différentes en fonction de ce que les comparaisons déterminent.

Mais ce n'est pas tout !

Certains d'entre vous ont probablement remarqué que dans cet exemple spécifique, on pourrait simplement vérifier la présence d'une propriété à l'aide de la fonction légèrement plus performant les moyens de vérifier si l'objet en question a une propriété. Il y a deux façons de procéder :

// the native `hasOwnProperty` method
var qux = function(tag, atr) { return document.createElement(tag).hasOwnProperty(atr); }

// the `in` operator
var quux = function(tag, atr) { return atr in document.createElement(tag); }

qux('audio', 'preload');  // returns true
quux('audio', 'preload'); // returns true

Nous nous éloignons du sujet...

Aussi rares que soient ces situations, il peut exister quelques scénarios dans lesquels le moyen le plus concis, le plus performant et, par conséquent, le plus préférable d'obtenir true à partir d'une valeur non booléenne, éventuellement indéfinie, se fait en utilisant la fonction !! . J'espère que cela sera ridiculement clair.

Answer 5

!! convertit la valeur située à sa droite en une valeur booléenne équivalente. (Pensez à la méthode du pauvre pour la "fonte de type".) Son intention est généralement de faire comprendre au lecteur que le code ne se préoccupe pas de ce qui se passe dans le pays. ce que la valeur de la variable, mais ce que sa "valeur "vérité es.