Was ist der !! (nicht nicht) Operator in JavaScript?

Question

Ich habe einen Code gesehen, der einen mir unbekannten Operator in Form von zwei Ausrufezeichen zu verwenden scheint, etwa so: !! . Kann mir bitte jemand sagen, was dieser Operator macht?

Der Kontext, in dem ich dies sah, war,

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

Answer 1

!! ist ähnlich wie die Verwendung des Boolescher Konstruktor oder wohl eher die Boolesche Funktion.

console.log(Boolean(null)); // Preferred 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-Werte in Javascript erzwingen a falsch y wahrhaftige Werte erzwingen a wahr. Falsche und wahrheitsgemäße Werte können auch verwendet werden in if Anweisungen und werden im Wesentlichen auf ihren entsprechenden booleschen Wert "abgebildet". Allerdings werden Sie wahrscheinlich nicht oft mit echten booleschen Werten arbeiten müssen, da sie sich meist in der Ausgabe (Rückgabewerte) unterscheiden.

Auch wenn dies dem Casting ähnlich zu sein scheint, handelt es sich realistischerweise wahrscheinlich um eine nur Zufall und ist nicht "gebaut" oder absichtlich für und wie ein boolescher Cast gemacht. Also sollten wir es nicht so nennen.

---

Warum und wie es funktioniert

Um es kurz zu machen: Es sieht ungefähr so aus: `! ( !null )`. Wobei `null` **falsch** ist, also wäre `!null` **wahr**. Dann wäre `!true` **false** und es würde im Wesentlichen *zurückkehren* zu dem, was es vorher war, nur dieses Mal als *richtiger boolescher Wert* (oder sogar *umgekehrt* mit *wahren Werten* wie `{}` oder `1`).

Um auf Ihr Beispiel zurückzukommen

Insgesamt passt der Kontext, den Sie gesehen haben, einfach `this.vertical` an, je nachdem, ob `vertical` definiert ist oder nicht, und wenn ja, wird er auf den resultierenden booleschen Wert von vertical gesetzt, andernfalls ändert er sich nicht. Mit anderen Worten, wenn `vertical` definiert ist, wird `this.vertical` auf den booleschen Wert von vertical gesetzt, andernfalls bleibt es gleich. Ich denke, das ist an sich ein Beispiel dafür, wie man `!!` verwenden kann und was es bewirkt.

Vertikales E/A-Beispiel

Führen Sie dieses Beispiel aus und ändern Sie den vertikalen Wert in der Eingabe. Sehen Sie sich an, was das Ergebnis ist, damit Sie den Code Ihres Kontexts besser verstehen können. Geben Sie in die Eingabe einen beliebigen gültigen Javascript-Wert ein. Vergessen Sie nicht, die Anführungszeichen einzuschließen, wenn Sie eine Zeichenfolge testen. Kümmern Sie sich nicht zu sehr um den CSS- und HTML-Code, führen Sie einfach dieses Snippet aus und spielen Sie damit herum. Sie sollten jedoch einen Blick auf den nicht DOM-bezogenen Javascript-Code werfen (die Verwendung des Example-Konstruktors und der vertikalen Variablen).

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>

Answer 2

Einige Operatoren in JavaScript führen implizite Typkonvertierungen durch, und sind manchmal für Typumwandlungen verwendet.

Der unäre ! Operator wandelt seinen Operanden in einen Booleschen Wert um und negiert ihn.

Diese Tatsache führte zu dem folgenden Idiom, das Sie in Ihrem Quellcode sehen können:

!!x // Same as Boolean(x). Note double exclamation mark

Answer 3

a = 1;
alert(!a) // -> false : a is not not defined
alert(!!a) // -> true : a is not not defined

Für !a prüft sie, ob a es ノット definiert, während !!a prüft, ob die Variable definiert ist.

!!a ist dasselbe wie !(!a) . Wenn a definiert ist, a es true , !a es false y !!a es true .

Answer 4

So wandeln Sie Ihre JavaScript-Variablen in Boolesche um,

var firstname = "test";
//type of firstname is string
var firstNameNotEmpty = !!firstname;
//type of firstNameNotEmpty is boolean

javascript falsch für "",0,undefiniert und null

Javascript ist wahr für Zahlen ungleich Null, nicht leere Strings, {},[] und new Date() also,

!!("test") /*is true*/
!!("") /*is false*/

Answer 5

!! ist einfach NOT-Operator zweimal. Netto-Effekt ist nur konvertieren alles zu gewährleisten, booleschen Datentyp. z.B..

!!undefined ist falsch !!0 ist falsch !!null ist falsch !!anyobject ist wahr !!true ist wahr !!false ist falsch !0 ist wahr !1 ist falsch