Quelle est la! (non pas) opérateur en JavaScript?

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 que c'était,

this.vertical = vertical !== undefined ? !!vertical : this.vertical;
2435
demandé sur mc10 2009-04-24 12:13:58
la source

30 ответов

Contraint oObject boolean. Si c'était falsey (par ex. 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 l'opérateur ! deux fois.

Monde Réel, par Exemple "Test la version de IE":

let isIE8 = false;  
isIE8 = !! navigator.userAgent.match(/MSIE 8.0/);  
console.log(isIE8); // returns true or false 

si vous ⇒

console.log(navigator.userAgent.match(/MSIE 8.0/));  
// returns null  

mais si vous ⇒

console.log(!!navigator.userAgent.match(/MSIE 8.0/));  
// returns true or false
2173
répondu stevehipwell 2018-04-04 08:56:44
la source

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

! est PAS . Donc !true est false , et !false est true . !0 est true , et !1 est false .

donc vous convertissez une valeur en booléen, puis vous l'inversez, puis vous l'inversez à nouveau.

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

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

// And finally, much easier to understand:
val.enabled = (userId != 0);
747
répondu Tom Ritter 2011-09-26 18:08:52
la source

!!expr renvoie une valeur booléenne ( true ou false ) en fonction de la trukness de l'expression. Il est plus logique lorsqu'il est utilisé sur les types non-booléens. Considérez ces exemples, 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

             !!"" === 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 is falsy
           !!null === false // null is falsy

             !!{} === true  // an (empty) object is truthy
             !![] === true  // an (empty) array is truthy; PHP programmers beware!
388
répondu Salman A 2015-10-25 00:00:47
la source

brasser du thé:

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


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 résulte en true )

  • la vérité est que false n'est pas pas false (c'est pourquoi !!false résulte en false )


ce que nous voulons déterminer dans la comparaison est la "vérité" à propos de la valeur d'une référence, pas la valeur de la référence elle-même. Il y a un cas d'utilisation où nous pourrions vouloir connaître la vérité sur une valeur, même si nous nous attendons à ce que la valeur soit false (ou falsey), ou si nous nous attendons à ce que la valeur ne soit pas de type boolean .


dans la pratique:

considère une fonction concise qui détecte la fonctionnalité de caractéristique (et dans ce cas, la compatibilité de plate-forme) par le biais de typage dynamique (alias"duck typing"). Nous voulons écrire une fonction qui retourne true si le navigateur d'un utilisateur supporte L'élément HTML5 <audio> , mais nous ne voulons pas que la fonction lance une erreur si <audio> est Non défini; et nous ne voulons pas utiliser try ... catch pour gérer toutes les erreurs possibles (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élera pas systématiquement la vérité sur la fonctionnalité (par exemple, document.createElement('audio') créera toujours un élément appelé <audio> même si HTML5 <audio> n'est pas supporté).


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 des valeurs différentes basées sur ce que les comparaisons déterminent.

mais attendez, il y a plus!

certains d'entre vous ont probablement remarqué que dans cet exemple spécifique, on pourrait simplement vérifier une propriété en utilisant le légèrement plus performant moyens de vérifier si l'objet en question a une propriété. Il y a deux façons de le faire:

// 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 digress...

aussi rares que ces situations puissent être, il peut exister quelques scénarios où le moyen le plus concis, le plus performant, et donc le plus préféré pour obtenir true à partir d'une valeur non booléenne, peut-être non définie est en effet en utilisant !! . J'espère que cela ridiculement efface.

134
répondu Benny 2013-02-23 03:45:27
la source

!! convertit la valeur à sa droite à sa valeur booléenne équivalente. (Pensez à la façon dont le pauvre homme "type-casting"). Son intention est généralement de faire comprendre au lecteur que le code ne se soucie pas ce que valeur est dans la variable, mais ce qu'il est "vérité" valeur est.

89
répondu Crescent Fresh 2009-09-10 21:26:53
la source

!!foo s'applique le unary pas opérateur deux fois et est utilisé pour mouler à type booléen similaire à l'utilisation de unary plus +foo pour mouler à nombre et concaténer une corde vide ''+foo pour mouler à corde.

au lieu de ces hacks, vous pouvez également utiliser les fonctions de constructeur correspondant aux types primitifs ( sans en utilisant new ) pour lancer explicitement des valeurs, i.e.

Boolean(foo) === !!foo
Number(foo)  === +foo
String(foo)  === ''+foo
61
répondu Christoph 2009-09-11 01:15:16
la source

beaucoup de réponses à faire la moitié du travail. Oui, !!X pourrait être interprété comme"la véracité de X [représenté comme un booléen]". Mais !! n'est pas, en pratique, si important pour déterminer si une seule variable est (ou même si plusieurs variables sont) vraie ou fausse. !!myVar === true est le même que juste myVar . Comparer !!X à un "vrai" booléen n'est pas vraiment utile.

ce que vous gagnez avec !! est la capacité de vérifier le truthiness de plusieurs variables les uns contre les autres d'une façon répétitive, standardisé (JSLint de l'environnement) de la mode.

il suffit de casting :(

C'est-à-dire...

  • 0 === false est false .
  • !!0 === false est true .

ce qui précède n'est pas si utile. if (!0) vous donne les mêmes résultats que if (!!0 === false) . Je Je ne peux pas penser à un bon cas pour mouler une variable à booléen et ensuite comparer à un" vrai " booléen.

Voir "== et != "from jslint's directions (note: Crockford déplace son site autour d'un peu; ce lien est susceptible de mourir à un moment donné) pour un peu sur le pourquoi:

L' == et != les opérateurs font de la coercition de type avant de comparer. Ce est mauvais parce qu'il provoque \t\r\n' == 0 pour être vrai. Cela peut type de masque erreur. JSLint ne peut pas déterminer de façon fiable si == est utilisé correctement, il est préférable de ne pas utiliser == et != du tout et toujours utiliser le plus fiable = = = et != = opérateurs à la place.

si vous vous souciez seulement qu'une valeur est vraie ou fausse, alors utilisez la forme courte. Au lieu de

(foo != 0)

"1519480920 de dire"

(foo)

et au lieu de

(foo == 0)

dire

(!foo)

notez Qu'il y a quelques cas unintuitifs où un booléen sera moulé à un nombre ( true est moulé à 1 et false à 0 ) en comparant un booléen à un nombre. Dans ce cas, !! pourrait être utile mentalement. Bien que, encore une fois, ce sont des cas où vous êtes comparer un non-booléen à un booléen dur-typé, qui est, imo, une grave erreur. if (-1) est toujours la voie à suivre.

╔═══════════════════════════════════════╦═══════════════════╦═══════════╗
║               Original                ║    Equivalent     ║  Result   ║
╠═══════════════════════════════════════╬═══════════════════╬═══════════╣
║ if (-1 == true) console.log("spam")   ║ if (-1 == 1)      ║ undefined ║
║ if (-1 == false) console.log("spam")  ║ if (-1 == 0)      ║ undefined ║
║   Order doesn't matter...             ║                   ║           ║
║ if (true == -1) console.log("spam")   ║ if (1 == -1)      ║ undefined ║
╠═══════════════════════════════════════╬═══════════════════╬═══════════╣
║ if (!!-1 == true) console.log("spam") ║ if (true == true) ║ spam      ║ better
╠═══════════════════════════════════════╬═══════════════════╬═══════════╣
║ if (-1) console.log("spam")           ║ if (truthy)       ║ spam      ║ still best
╚═══════════════════════════════════════╩═══════════════════╩═══════════╝

et les choses deviennent encore plus folles selon votre moteur. WScript, par exemple, gagne le prix.

function test()
{
    return (1 === 1);
}
WScript.echo(test());

à cause de quelques fenêtres historiques jive , qui va sortir -1 dans une boîte de message! Essayez-la dans un cmd.exe invite et vous verrez! Mais WScript.echo(-1 == test()) vous donne toujours 0, ou false de WScript . regardez ailleurs. Il est hideux.

Comparing truthness:)

mais que se passe-t-il si j'ai deux valeurs que je dois vérifier pour l'égalité truthi/falsi-ness?

prétendre que nous avons myVar1 = 0; et myVar2 = undefined; .

  • myVar1 === myVar2 est 0 === undefined et est évidemment faux.
  • !!myVar1 === !!myVar2 est !!0 === !!undefined et est vrai! Même truthiness! (Dans ce cas, les deux "ont une véracité de falsy".)

donc le seul endroit où vous auriez vraiment besoin d'utiliser des "variables booléennes" serait si vous aviez une situation où vous vérifiez si les deux variables ont la même véracité, Non? C'est-à-dire, utiliser !! si vous avez besoin de voir si deux RPV sont à la fois vrai ou faux (ou non), c'est-à-dire, d'égal (ou non) trukness .

Je ne peux pas penser à un grand, cas d'utilisation non-inventé pour ce offhand. Peut-être avez-vous des champs "liés" dans un formulaire?

if (!!customerInput.spouseName !== !!customerInput.spouseAge ) {
    errorObjects.spouse = "Please either enter a valid name AND age " 
        + "for your spouse or leave all spouse fields blank.";
}

donc maintenant si vous avez un vrai pour les deux ou un faux pour le nom et l'âge du conjoint, vous pouvez continuer. Sinon, vous n'avez qu'un seul champ avec une valeur (ou un mariage arrangé très tôt) et avez besoin de créer une erreur supplémentaire sur votre errorObjects de la collection.


EDIT 24 Oct 2017:

bibliothèques de tiers qui attendent des valeurs booléennes explicites

Voici un cas intéressant... !! peut être utile lorsque des libs tiers s'attendent à des valeurs booléennes explicites.

par exemple, False in JSX (React) a un sens spécial qui n'est pas déclenché sur simple falsiness. Si vous avez essayé de rendre quelque chose comme ce qui suit dans votre JSX, en attendant un int dans messageCount ...

{messageCount && <div>You have messages!</div>}

... vous pourriez être surpris de voir React afficher un 0 lorsque vous avez zéro message. Vous devez explicitement retourner false pour que JSX ne rende pas. La déclaration ci-dessus retourne 0 , que JSX rend volontiers, comme il se doit. Il ne peut pas dire que vous n'avez pas eu Count: {messageCount && <div>Get your count to zero!</div>} (ou quelque chose de moins artificiel).

  • un point concerne le bangbang, qui transforme 0 en !!0 , qui est false :

    {!!messageCount && <div>You have messages!</div>}

  • JSX' docs vous suggère d'être plus explicite, écrire auto-commenter le code, et d'utiliser une comparaison de la force à une valeur Booléenne.

    {messageCount > 0 && <div>You have messages!</div>}

  • je suis de plus en plus je suis à l'aise avec un ternaire.--

    {messageCount ? <div>You have messages!</div> : false}

gardez à l'esprit que cette est une convention JSX , pas un inhérent à JavaScript .

mais si vous voyez étrange 0 s dans votre JSX Rendu, pensez à la gestion de falsy lâche.

52
répondu ruffin 2017-10-24 18:30:25
la source

c'est juste l'opérateur logique non, deux fois - il est utilisé pour convertir quelque chose en booléen, par exemple:

true === !!10

false === !!0
47
répondu Greg 2009-04-24 12:18:49
la source

convertit le suffixe en valeur booléenne.

29
répondu Paul McMillan 2009-10-30 00:22:40
la source

c'est une double opération not . Le premier ! convertit la valeur booléenne et inverse sa valeur logique. Le second ! inverse la valeur logique.

23
répondu Bill the Lizard 2009-09-10 21:28:46
la source

il simule le comportement de la fonction de coulée Boolean() . Le premier NOT renvoie une valeur booléenne peu importe l'opérande qui lui est donnée. Le second NOT nie la valeur Boolean et donne ainsi la valeur booléenne true d'une variable. Le résultat final est le même que l'utilisation de la fonction Boolean() sur une valeur.

21
répondu Prakash 2011-03-23 14:53:45
la source

il semble que l'opérateur !! résulte en une double négation.

var foo = "Hello World!";

!foo // Result: false
!!foo // Result: true
19
répondu Steve Harrison 2011-11-09 14:35:33
la source

! est "booléen pas", qui caractérise essentiellement la valeur de" permettre " à son opposé booléen. Le deuxième ! retourne cette valeur. Ainsi, !!enable signifie "Ne pas permettre", vous donnant la valeur de enable comme un booléen.

17
répondu Annika Backstrom 2009-09-10 21:29:18
la source

je pense qu'il vaut la peine de mentionner est, qu'une condition combinée avec logique et / ou ne retournera pas une valeur booléenne mais dernier succès ou premier échec en cas de && et premier succès ou dernier échec en cas de / / chaîne de condition.

res = (1 && 2); // res is 2
res = (true && alert) // res is function alert()
res = ('foo' || alert) // res is 'foo'

afin de lancer la condition à un vrai booléen littéral nous pouvons utiliser la double négation:

res = !!(1 && 2); // res is true
res = !!(true && alert) // res is true
res = !!('foo' || alert) // res is true
16
répondu GreQ 2016-05-25 13:18:34
la source

la construction !! est un moyen simple de transformer n'importe quelle expression JavaScript en son équivalent Booléen.

par exemple: !!"he shot me down" === true et !!0 === false .

13
répondu Navin Rauniyar 2015-09-10 11:20:11
la source

ce n'est pas un seul opérateur, c'est deux. C'est équivalent à celui-ci et est un moyen rapide pour lancer une valeur booléenne.

val.enabled = !(!enable);
11
répondu Justin Johnson 2009-09-11 01:19:09
la source

je soupçonne que c'est un reliquat de C++ où les gens outrepassent le ! opérateur mais pas l'opérateur booléen.

donc pour obtenir une réponse négative(ou positive) dans ce cas, vous devez d'abord utiliser le ! opérateur pour obtenir un booléen, mais si vous vouliez vérifier le cas positif serait d'utiliser !!.

9
répondu Darren Clark 2009-04-24 12:33:39
la source

les énoncés if et while et l'opérateur ? utilisent des valeurs de vérité pour déterminer quelle branche de code exécuter. Par exemple, les nombres zéro et NaN et la chaîne vide sont faux, mais les autres nombres et chaînes sont vrais. Les objets sont true, mais la valeur non définie et null sont toutes deux false.

l'opérateur de négation double !! calcule la valeur de vérité d'une valeur. Il s'agit en fait de deux opérateurs, où !!x signifie !(!x) , et se comporte comme suit:

  • si x est une fausse valeur, !x est true , et !!x est false .
  • si x est une valeur vraie, !x est false , et !!x est true .

lorsqu'il est utilisé au niveau supérieur d'un contexte booléen ( if , while , ou ? ), l'opérateur !! est comportementalement un non-op. Par exemple, if (x) et if (!!x) signifient la même chose.

utilisations pratiques

cependant il a plusieurs utilisations pratiques.

L'un des usages est de comprimer un objet avec perte à sa valeur de vérité, de sorte que votre code ne tienne pas une référence à un grand objet et ne le garde pas en vie. Attribuer !!some_big_object à une variable au lieu de some_big_object laisse tomber pour le collecteur d'ordures. Ceci est utile pour les cas qui produisent un objet ou une fausse valeur comme null ou la valeur non définie, comme la détection de fonctionnalité du navigateur.

une autre utilisation, que j'ai mentionnée dans une réponse à propos de C correspondant !! opérateur , est avec des outils" lint " qui cherchent des fautes de frappe courantes et des diagnostics d'impression. Par exemple, en C et JavaScript, quelques fautes de frappe courantes pour les opérations booléennes produisent d'autres comportements dont la sortie N'est pas aussi booléenne.:

  • if (a = b) est d'affectation, suivi par l'utilisation de la valeur de vérité de b ; if (a == b) est une comparaison d'égalité.
  • if (a & b) est un bit à bit ET; if (a && b) est un ET logique. 2 & 5 est 0 (une fausse valeur); 2 && 5 est vrai.

l'opérateur !! rassure l'outil peluche que ce que vous avez écrit Est ce que vous vouliez dire: faire cette opération, puis prendre la valeur de vérité de la raison.

une troisième utilisation est de produire XOR logique et XNOR logique. En C et JavaScript, a && b exécute un logique et (vrai si les deux côtés sont vrais), et a & b exécute un bitwise et. a || b exécute un logique ou (true si au moins un est vrai), et a | b exécute un bitwise OR. Il y a un XOR bitwise (exclusif ou) comme a ^ b , mais il n'y a pas d'opérateur intégré pour XOR logique (VRAI si exactement un côté est vrai). Vous pourriez, par exemple, pour permettre à l'utilisateur d'entrer du texte dans exactement un des deux champs. Ce que vous pouvez faire est de convertir chacun à une valeur de vérité et de les comparer: !!x !== !!y .

8
répondu Damian Yerrick 2016-03-06 17:46:50
la source

double négation booléenne. Souvent utilisée pour vérifier si la valeur n'est pas indéfini.

7
répondu Sergey Ilinsky 2010-12-02 23:21:14
la source

des tonnes de bonnes réponses ici, mais si vous avez lu jusqu'ici, cela m'a aidé à "l'obtenir". Ouvrez la console sur Chrome (etc), et commencez à taper:

!(!(1))
!(!(0))
!(!('truthy')) 
!(!(null))
!(!(''))
!(!(undefined))
!(!(new Object())
!(!({}))
woo = 'hoo'
!(!(woo))
...etc, etc, until the light goes on ;)

naturellement ,cela revient à taper!!quelque chose, mais les parenthèses ajoutées pourraient aider à le rendre plus compréhensible.

7
répondu Warren Davis 2014-04-24 17:05:49
la source

!!x est une abréviation de Boolean(x)

le premier bang force le moteur js à tourner Boolean(x) mais a aussi l'effet secondaire d'inverser la valeur. Donc le deuxième coup annule l'effet secondaire.

7
répondu Greg0 2015-12-04 15:50:49
la source

!! il utilise NOT opération deux fois ensemble, ! convertissez la valeur en boolean et inversez-la, voici un exemple simple pour voir comment !! fonctionne:

à la première place, vous avez:

var zero = 0;

puis vous faites !0 , il sera converti en booléen et sera évalué à true , parce que 0 est falsy , donc vous obtenez la valeur inversée et converti en booléen, donc il obtient évalué à true .

!zero; //true

mais nous ne voulons pas de la version booléenne inversée de la valeur, donc nous pouvons l'Inverser à nouveau pour obtenir notre résultat! C'est pourquoi nous utilisons un autre ! .

en gros, !! assurez-nous, la valeur que nous obtenons est booléenne, pas falsy, truthy ou string etc...

donc c'est comme utiliser la fonction Boolean en javascript, mais de manière simple et plus courte pour convertir une valeur en booléen:

var zero = 0;
!!zero; //false
5
répondu Alireza 2018-07-18 14:10:25
la source

voici un morceau de code d'angular js

var requestAnimationFrame = $window.requestAnimationFrame ||
                                $window.webkitRequestAnimationFrame ||
                                $window.mozRequestAnimationFrame;

 var rafSupported = !!requestAnimationFrame;

leur intention est de définir rafsupportés à vrai ou faux en fonction de la disponibilité de la fonction dans requestAnimationFrame

il peut être réalisé en contrôlant de la manière suivante en général:

if(typeof  requestAnimationFrame === 'function')
rafSupported =true;
else
rafSupported =false;

la voie courte pourrait être l'utilisation !!

rafSupported = !!requestAnimationFrame ;

donc si requestAnimationFrame a été assignée une fonction puis !requestAnimationFrame serait faux et une de plus ! de lui serait vrai

si requestAnimationFrame était non défini alors !requestAnimationFrame serait vrai et une de plus ! de lui serait faux

4
répondu JeevanReddy Avanaganti 2015-03-04 11:25:35
la source

certains opérateurs en JavaScript effectuent des conversions implicites de type, et sont parfois utilisé pour la conversion de type.

l'opérateur unaire ! convertit son opérande en booléen et la nie.

ce fait conduit à l'idiome suivant que vous pouvez voir dans votre code source:

!!x // Same as Boolean(x). Note double exclamation mark
3
répondu GibboK 2015-07-01 10:29:12
la source

renvoie la valeur booléenne d'une variable.

à la place, la classe Boolean peut être utilisée.

(veuillez lire les descriptions des codes)

var X = "test"; // X value is "test" as a String value
var booleanX = !!X // booleanX is `true` as a Boolean value beacuse non-empty strings evaluates as `true` in boolean
var whatIsXValueInBoolean = Boolean(X) // whatIsXValueInBoolean is `true` again
console.log(Boolean(X) === !!X) // writes `true`

à savoir, Boolean(X) = !!X en usage.

s'il vous Plaît vérifier l'extrait de code ci-après

let a = 0
console.log("a: ", a) // writes a value in its kind
console.log("!a: ", !a) // writes '0 is NOT true in boolean' value as boolean - So that's true.In boolean 0 means false and 1 means true.
console.log("!!a: ", !!a) // writes 0 value in boolean. 0 means false.
console.log("Boolean(a): ", Boolean(a)) // equals to `!!a`
console.log("\n") // newline

a = 1
console.log("a: ", a)
console.log("!a: ", !a)
console.log("!!a: ", !!a) // writes 1 value in boolean
console.log("\n") // newline

a = ""
console.log("a: ", a)
console.log("!a: ", !a) // writes '"" is NOT true in boolean' value as boolean - So that's true.In boolean empty strings, null and undefined values mean false and if there is a string it means true.
console.log("!!a: ", !!a) // writes "" value in boolean
console.log("\n") // newline

a = "test"
console.log("a: ", a) // writes a value in its kind
console.log("!a: ", !a)
console.log("!!a: ", !!a) // writes "test" value in boolean

console.log("Boolean(a) === !!a: ", Boolean(a) === !!a) // writes true
3
répondu efkan 2017-07-11 10:22:44
la source
a = 1;
alert(!a) // -> false : a is not not defined
alert(!!a) // -> true : a is not not defined

pour !a , il vérifie si a est Non défini, tandis que !!a vérifie si la variable est définie.

!!a est le même que !(!a) . Si a est défini, a est true , !a est false , et !!a est true .

2
répondu user3698272 2014-06-28 07:35:13
la source

utilisez logical not operator deux fois

cela signifie !vrai= faux

et !!vrai = vrai

2
répondu Abhay Dixit 2016-07-15 13:25:01
la source

après avoir vu toutes ces grandes réponses, je voudrais ajouter une autre raison pour utiliser !! . Currenty je travaille dans Angular 2-4 (TypeScript) et je veux retourner un booléen comme false quand mon utilisateur n'est pas authentifié. S'il n'est pas authentifié, la chaîne de caractères sera null ou "" . Je peux le faire en utilisant le bloc de code suivant:

public isAuthenticated(): boolean {
   return !!this.getToken();
}
2
répondu Wouter Vanherck 2017-03-29 10:15:21
la source

!! est similaire à l'utilisation du Boolean constructor , ou sans doute plus comme le fonction booléenne.

console.log(Boolean(null)); // Preffered over the Boolean object

console.log(new Boolean(null).valueOf()); // Not recommended for coverting non-boolean values

console.log(!!null); // A hacky way to omit calling the Boolean function, but essentially does the same thing. 


// The context you saw earlier (your example)
var vertical;

function Example(vertical)
{
        this.vertical = vertical !== undefined ? !!vertical : 
        this.vertical; 
        // Let's break it down: If vertical is strictly not undefined, return the boolean value of vertical and set it to this.vertical. If not, don't set a value for this.vertical (just ignore it and set it back to what it was before; in this case, nothing).   

        return this.vertical;
}

console.log( "\n---------------------" )

// vertical is currently undefined

console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical
console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical

vertical = 12.5; // set vertical to 12.5, a truthy value.
console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical which happens to be true anyway
console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical

vertical = -0; // set vertical to -0, a falsey value.
console.log(new Example(vertical).vertical); // The falsey or truthy value of this.vertical which happens to be false either way
console.log(!!new Example(vertical).vertical); // Coerced value of this.vertical

Falsey valeurs javascript forcer à false , et truthy valeurs contraindre à vrai. les valeurs Falsey et truthy peuvent aussi être utilisées dans les énoncés if et seront essentiellement "map" à leur valeur booléenne correspondante. Cependant, vous ne vous trouverez probablement pas avoir à utiliser des valeurs booléennes appropriées souvent, car ils diffèrent la plupart du temps en sortie (valeurs de retour).

bien que cela puisse sembler similaire à la fonte, de façon réaliste c'est probablement une simple coïncidence et n'est pas "construit" ou fait exprès pour et comme un moulage booléen. Afin de ne pas laisser l'appeler comme ça.


pourquoi et comment ça marche

Pour être concis, il ressemble à quelque chose comme ceci: ! ( !null ) . Alors que, null est falsey , donc !null serait vrai . Alors !true serait faux et il serait essentiellement inverser retour à ce qu'il était avant, sauf cette fois comme une valeur booléenne appropriée (ou même vice versa avec valeurs truthy comme {} ou 1 ).



retour à votre exemple

dans l'ensemble, le contexte que vous avez vu ajuste simplement this.vertical selon si oui ou non vertical est défini, et si c'est le cas, il sera défini à la valeur booléenne résultante de vertical, sinon il ne changera pas. En d'autres termes, si vertical est défini; this.vertical sera défini à la valeur booléenne de celui-ci, sinon, il restera le même. Je suppose que c'est en soi un exemple de la façon dont vous utiliseriez !! , et ce qu'il fait.



Vertical I / O Example

Exécuter ce exemple et tripoter avec la valeur verticale dans l'entrée. Voyez ce que le résultat coerce pour que vous puissiez pleinement comprendre le code de votre contexte. Dans la saisie, entrez toute valeur javascript valide. n'oubliez pas d'inclure les citations si vous testez une chaîne de caractères. ne vous souciez pas trop du code CSS et HTML, il suffit de lancer ce snippet et de jouer avec. Cependant, vous pourriez vouloir jeter un oeil au code javascript Non-DOM-related (l'utilisation de L'exemple constructeur et la variable verticale).

var vertical = document.getElementById("vertical");
var p = document.getElementById("result");

function Example(vertical)
{
        this.vertical = vertical !== undefined ? !!vertical : 
        this.vertical;   

        return this.vertical;
}

document.getElementById("run").onclick = function()
{

  p.innerHTML = !!( new Example(eval(vertical.value)).vertical );
  
}
input
{
  text-align: center;
  width: 5em;
} 

button 
{
  margin: 15.5px;
  width: 14em;
  height: 3.4em;
  color: blue;
}

var 
{
  color: purple;
}

p {
  margin: 15px;
}

span.comment {
  color: brown;
}
<!--Vertical I/O Example-->
<h4>Vertical Example</h4>
<code id="code"><var class="var">var</var> vertical = <input type="text" id="vertical" maxlength="9" />; <span class="comment">// enter any valid javascript value</span></code>
<br />
<button id="run">Run</button>
<p id="result">...</p>
2
répondu WEB_UI 2017-04-17 19:32:12
la source

il force toutes choses à booléen.

par exemple:

console.log(undefined); // -> undefined
console.log(!undefined); // -> true
console.log(!!undefined); // -> false

console.log('abc'); // -> abc
console.log(!'abc'); // -> false
console.log(!!'abc'); // -> true

console.log(0 === false); // -> undefined
console.log(!0 === false); // -> false
console.log(!!0 === false); // -> true
2
répondu Khuong 2018-09-06 05:02:50
la source

Autres questions sur javascript operators