javascript - strings - js if and




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

! ist "boolean not", was den Wert von "enable" im Wesentlichen in sein boolesches Gegenteil umwandelt. Der Zweite ! dreht diesen Wert um. !!enable bedeutet also: "nicht aktivieren" und gibt Ihnen den Wert von enable als Boolean.

Ich habe einen Code gesehen, der einen Operator zu verwenden scheint, den ich nicht kenne, und zwar in Form von zwei Ausrufezeichen: !! . Kann mir bitte jemand sagen, was dieser Operator macht?

Der Kontext, in dem ich das sah, war

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

Das Suffix wird in einen booleschen Wert konvertiert.


Die if und while Aussagen und die ? Operator verwendet Wahrheitswerte, um zu bestimmen, welcher Codezweig ausgeführt werden soll. Beispielsweise sind Null- und NaN-Nummern und die leere Zeichenfolge falsch, andere Zahlen und Zeichenfolgen sind jedoch wahr. Objekte sind wahr, aber der undefinierte Wert und null sind beide falsch.

Der doppelte Negationsoperator !! berechnet den Wahrheitswert eines Werts. Es sind zwei Operatoren, wobei !!x !(!x) und sich wie folgt verhält:

  • Wenn x ein falscher Wert ist, ist !x true und !!x ist false .
  • Wenn x ein wahrer Wert ist, ist !x false und !!x ist true .

Bei Verwendung auf der obersten Ebene eines booleschen Kontextes ( if , while oder ? ) if der !! Operator ist verhaltensmäßig ein No-Op. Zum Beispiel, if (x) und if (!!x) dasselbe bedeuten.

Praktische Anwendungen

Es hat jedoch mehrere praktische Anwendungen.

Eine Verwendung ist das verlustbehaftete Komprimieren eines Objekts auf seinen Wahrheitswert, sodass der Code keinen Verweis auf ein großes Objekt enthält und es am Leben erhält. Durch das Zuweisen von !!some_big_object zu einer Variablen anstelle von some_big_object es für den Garbage-Collector some_big_object . Dies ist nützlich in Fällen, in denen entweder ein Objekt oder ein falscher Wert erzeugt wird, z. B. null oder der nicht definierte Wert, z. B. die Erkennung von Browserfunktionen.

Eine andere Verwendung, die ich in einer Antwort über die Entsprechung von C erwähnt habe !! Operator , ist mit "Flusen" Tools, die nach gängigen Tippfehlern und Druckdiagnose suchen. In C und in JavaScript führen beispielsweise einige häufige Tippfehler für boolesche Operationen zu anderen Verhalten, deren Ausgabe nicht ganz so boolesch ist:

  • if (a = b) eine Zuordnung ist, gefolgt von der Verwendung des Wahrheitswerts von b ; if (a == b) ist ein Gleichheitsvergleich.
  • if (a & b) ist ein bitweises AND; if (a && b) ist ein logisches AND. 2 & 5 ist 0 (ein falscher Wert); 2 && 5 ist wahr.

Die !! Der Bediener versichert dem Fusselwerkzeug, dass das, was Sie geschrieben haben, das war, was Sie meinten: Führen Sie diesen Vorgang aus, und nehmen Sie dann den Wahrheitswert des Ergebnisses.

Eine dritte Anwendung ist die Erzeugung von logischem XOR und logischem XNOR. Sowohl in C als auch in JavaScript führt a && b ein logisches AND aus (true, wenn beide Seiten wahr sind), und a & b führt ein bitweises AND aus. a || b a || b führt ein logisches ODER aus (wahr, wenn mindestens eins wahr ist) und a | b a | b führt ein bitweises ODER aus. Es gibt ein bitweises XOR (exklusives OR) als a ^ b , aber es gibt keinen integrierten Operator für logisches XOR (true, wenn genau eine Seite wahr ist). Möglicherweise möchten Sie dem Benutzer beispielsweise erlauben, Text in genau einem von zwei Feldern einzugeben. Was Sie tun können, ist, jeden in einen Wahrheitswert umzuwandeln und zu vergleichen: !!x !== !!y .


Doppelte boolesche Negation. Wird häufig verwendet, um zu überprüfen, ob der Wert nicht undefiniert ist.


Es ist eine doppelte Operation. Der erste wandelt den Wert in boolean um und invertiert seinen logischen Wert. Der zweite kehrt den logischen Wert zurück.


Es ist eine schrecklich obskure Art, eine Typumwandlung durchzuführen.

! ist NICHT So ist !true false und true !false . !0 ist true und !1 ist false .

Sie konvertieren also einen Wert in einen booleschen Wert, invertieren ihn und invertieren ihn dann erneut.

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

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

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

Es ist nur der logische NOT-Operator, zweimal - es wird verwendet, um etwas in Boolean umzuwandeln, zB:

true === !!10

false === !!0

Es scheint, dass die !! Operator führt zu einer doppelten Negation.

var foo = "Hello World!";

!foo // Result: false
!!foo // Result: true

Gibt den booleschen Wert einer Variablen zurück.

Stattdessen kann eine Boolean Klasse verwendet werden.

(bitte Codebeschreibungen lesen)

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`

Boolean(X) = !!X verwendet.

Bitte überprüfen Sie den Code-Ausschnitt unter

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


Hier ist ein Code aus dem Winkel js

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

 var rafSupported = !!requestAnimationFrame;

Sie beabsichtigen, rafSupported basierend auf der Verfügbarkeit der Funktion in requestAnimationFrame auf true oder false zu setzen

Dies kann erreicht werden, indem allgemein auf folgende Weise geprüft wird:

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

der kurze Weg könnte sein !!

rafSupported = !!requestAnimationFrame ;

Wenn also requestAnimationFrame eine Funktion zugewiesen wurde, wäre! requestAnimationFrame false und noch eine! davon wäre wahr

Wenn requestAnimationFrame nicht definiert wurde, dann wäre! requestAnimationFrame wahr und noch eins! davon wäre falsch


Ich vermute, das ist ein Überbleibsel aus C ++, wo die Leute das überschreiben! Operator, aber nicht der Bool-Operator.

Um in diesem Fall eine negative (oder positive) Antwort zu erhalten, müssten Sie zuerst das! Operator, um einen booleschen Wert zu erhalten, aber wenn Sie den positiven Fall überprüfen möchten, verwenden Sie !!.


So viele Antworten machen die halbe Arbeit. Ja, !!X kann als "die Wahrhaftigkeit von X [als boolescher Darstellung]" gelesen werden. Aber !! In der Praxis ist es nicht so wichtig, um herauszufinden, ob eine einzelne Variable (oder sogar wenn viele Variablen) wahr oder falsch sind. !!myVar === true ist das gleiche wie nur myVar . Der Vergleich von !!X mit einem "echten" Boolean ist nicht wirklich nützlich.

Was gewinnen Sie mit !! ist die Fähigkeit, die Wahrhaftigkeit mehrerer Variablen auf wiederholbare, standardisierte (und JSLint-freundliche) Weise gegeneinander zu überprüfen.

Einfach gießen :(

Das ist...

  • 0 === false ist false .
  • !!0 === false ist true .

Das obige ist nicht so nützlich. if (!0) liefert die gleichen Ergebnisse wie if (!!0 === false) . Ich kann mir keinen guten Grund vorstellen, eine Variable in Boolean umzuwandeln und dann mit einem "echten" Boolean zu vergleichen.

Siehe "== and! =" Aus den Anweisungen von JSLint (Hinweis: Crockford bewegt seine Website ein wenig; dieser Link kann irgendwann sterben), warum:

Die Operatoren == und! = Geben Zwang vor dem Vergleich ein. Das ist schlecht, weil '\ t \ r \ n' == 0 wahr ist. Dies kann Typfehler maskieren. JSLint kann nicht zuverlässig feststellen, ob == korrekt verwendet wird. Daher sollten Sie == und! = Nicht verwenden und stattdessen immer die zuverlässigeren === und! == -Operatoren verwenden.

Wenn Sie nur darauf achten, dass ein Wert wahr oder falsch ist, verwenden Sie die Kurzform. Anstatt
(foo != 0)

Sag nur
(foo)

und statt
(foo == 0)

sagen
(!foo)

Beachten Sie, dass es einige unbeabsichtigte Fälle gibt, in denen ein boolescher Wert in eine Zahl umgewandelt wird ( true wird in 1 und false in 0 ), wenn ein boolescher Wert mit einer Zahl verglichen wird. In diesem Fall !! könnte geistig nützlich sein. Auch hier handelt es sich um Fälle, in denen Sie einen Nicht-Boolean-Wert mit einem harten Boolean-Typ vergleichen, was imo ein schwerwiegender Fehler ist. if (-1) ist der Weg hier noch zu gehen.

╔═══════════════════════════════════════╦═══════════════════╦═══════════╗
║               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
╚═══════════════════════════════════════╩═══════════════════╩═══════════╝

Je nach Motor werden die Dinge noch verrückter. WScript zum Beispiel gewinnt den Preis.

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

Aufgrund einiger historischer Windows-Jives wird -1 in einem Meldungsfeld ausgegeben! Versuchen Sie es in einer Eingabeaufforderung cmd.exe und sehen Sie! WScript.echo(-1 == test()) gibt Ihnen jedoch immer noch 0 oder WScript's false . Schau weg. Es ist abscheulich

Wahrhaftigkeit vergleichen :)

Was aber, wenn ich zwei Werte habe, die ich auf gleiche Wahrheit / Falschheit überprüfen muss?

myVar1 = 0; wir haben myVar1 = 0; und myVar2 = undefined; .

  • myVar1 === myVar2 ist 0 === undefined und ist offensichtlich falsch.
  • !!myVar1 === !!myVar2 ist !!0 === !!undefined und ist wahr! Gleiche Wahrhaftigkeit! (In diesem Fall haben beide "eine Falschheit").

Der einzige Ort, an dem Sie wirklich "boolean-cast-Variablen" verwenden müssten, wäre, wenn Sie sich in einer Situation befinden würden, in der Sie prüfen, ob beide Variablen die gleiche Wahrheit haben, oder? Das heißt, verwenden !! Wenn Sie sehen müssen, ob zwei Vars sowohl wahr sind als auch beide falsch sind (oder nicht), das heißt, gleich (oder nicht) Wahrhaftigkeit .

Ich kann mir keinen großartigen, nicht erfundenen Anwendungsfall für diesen spontanen Gebrauch vorstellen. Vielleicht haben Sie Felder in einem Formular "verlinkt"?

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

Wenn Sie also einen Wahrheitsgehalt für beide oder eine Fälschung für den Namen und das Alter der Ehepartner haben, können Sie fortfahren. Andernfalls haben Sie nur ein Feld mit einem Wert (oder einer sehr früh arrangierten Ehe) und müssen einen zusätzlichen Fehler in Ihrer errorObjects Auflistung errorObjects .

BEARBEITEN 24. Oktober 2017:

Drittanbieter-Bibliotheken, die explizite boolesche Werte erwarten

Hier ist ein interessanter Fall ... !! kann nützlich sein, wenn Drittanbieter-Libs explizite boolesche Werte erwarten.

Zum Beispiel hat False in JSX (React) eine besondere Bedeutung , die nicht durch einfache Falschheit ausgelöst wird. Wenn Sie versucht haben, etwa Folgendes in Ihrer JSX zurückzugeben, erwarten Sie ein int in messageCount ...

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

... Sie werden überrascht sein zu sehen, dass React eine 0 wenn Sie keine Nachrichten haben. Sie müssen explizit false zurückgeben, damit JSX nicht gerendert wird. Die obige Anweisung gibt 0 , was JSX glücklich wiedergibt, wie es sollte. Es kann nicht gesagt werden, dass Sie Count: {messageCount && <div>Get your count to zero!</div>} nicht hatten Count: {messageCount && <div>Get your count to zero!</div>} (oder etwas anderes).

  • Ein Fix beinhaltet den Bangbang, der 0 zu !!0 zwingt, was false :
    {!!messageCount && <div>You have messages!</div>}

  • Die JSX-Dokumente weisen darauf hin, dass Sie expliziter sind, selbstkommentierenden Code schreiben und einen Vergleich verwenden, um ein Boolean zu erzwingen.
    {messageCount > 0 && <div>You have messages!</div>}

  • Ich fühle mich eher mit Falschheit mit einem Dreier -
    {messageCount ? <div>You have messages!</div> : false}

Beachten Sie, dass es sich hierbei um eine JSX-Konvention handelt , nicht um JavaScript .

Wenn Sie jedoch in Ihrem gerenderten JSX seltsame Nullen sehen, denken Sie an ein lockeres Falsy-Management.


Zwingt zu boolean. Wenn es Falsey war (z. B. 0, null , undefined usw.), ist es false , sonst true .

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

Also !! ist kein Operator, es ist nur der ! Bediener zweimal.

Real World Beispiel "Test IE version":

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

Wenn Sie ⇒

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

aber wenn Sie ⇒

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

!! es verwendet NOT zwei Operationen zusammen ! Konvertieren Sie den Wert in einen boolean Wert und kehren Sie ihn um. Hier ein einfaches Beispiel, um zu sehen wie !! arbeitet:

Zuerst haben Sie:

var zero = 0;

Dann tun Sie !0 , es wird in boolean konvertiert und in true ausgewertet, da 0 falsy ist. Sie erhalten also den umgekehrten Wert und werden in boolean konvertiert, sodass es in true ausgewertet wird.

!zero; //true

Wir möchten jedoch nicht die umgekehrte boolesche Version des Werts, also können wir ihn erneut umkehren, um unser Ergebnis zu erhalten! Deshalb benutzen wir noch einen ! .

Grundsätzlich !! Vergewissern Sie sich, der Wert, den wir erhalten, ist boolean, nicht falsy, wahrheitsgemäß oder string usw ...

Es ist also so, als würde man die Boolean Funktion in Javascript verwenden, aber einen einfachen und kürzeren Weg, um einen Wert in einen booleschen Wert zu konvertieren:

var zero = 0;
!!zero; //false

!!ähnelt der Verwendung des Booleschen Konstruktors oder eher der Booleschen Funktion.

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-Werte in Javascript zwingen zu falsch , und wahrheitsgemäße Werte zwingen zu wahr. Falsey- und Wahrheitswerte können auch in ifAnweisungen verwendet werden und werden im Wesentlichen auf ihren entsprechenden Booleschen Wert " abgebildet ". Sie werden jedoch wahrscheinlich nicht häufig richtige boolesche Werte verwenden müssen, da sich diese meist in der Ausgabe (Rückgabewerte) unterscheiden.

Obwohl dies dem Casting ähneln mag, ist dies wahrscheinlich ein reiner Zufall und wird nicht „gebaut“ oder absichtlich für einen booleschen Cast gemacht. Also nennen wir es nicht so.

Warum und wie es funktioniert

Um präzise, sieht es so etwas wie folgt aus : ! ( !null ). Während, nullist Falsey , so !nullwäre wahr . Dann !truewäre es falsch und es würde sich im Wesentlichen auf den vorherigen Wert umkehren , außer diesmal als richtiger boolescher Wert (oder sogar umgekehrt mit wahrheitsgemäßen Werten wie {}oder 1).


Gehen Sie zurück zu Ihrem Beispiel

Insgesamt wird der Kontext, den Sie gesehen haben, einfach angepasst, this.verticalje nachdem, ob verticaldefiniert ist oder nicht . es wird auf den resultierenden booleschen Wert von vertical gesetzt, andernfalls wird es nicht geändert. Mit anderen Worten, wenn verticaldefiniert ist; this.verticalwird auf den booleschen Wert gesetzt, andernfalls bleibt er gleich. Ich denke, das ist an sich ein Beispiel dafür, wie man es benutzt !!und was es macht.


Vertikale I / O-Beispiel

Führen Sie dieses Beispiel aus und bewegen Sie sich mit dem vertikalen Wert in der Eingabe. Sehen Sie, wozu das Ergebnis führt, damit Sie den Code Ihres Kontextes vollständig verstehen können. Geben Sie in die Eingabe einen gültigen Javascript-Wert ein. Denken Sie daran, die Zitate einzuschließen, wenn Sie eine Zeichenfolge testen. Machen Sie sich nichts aus dem CSS- und HTML-Code, sondern führen Sie dieses Snippet einfach aus und spielen Sie damit herum. Sie können jedoch einen Blick auf den nicht-DOM-bezogenen Javascript-Code werfen (Verwendung des Beispielkonstruktors 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>


!!expr gibt je nach der Wahrheit des Ausdrucks einen booleschen Wert ( true oder false ) zurück. Bei nicht booleschen Typen ist es sinnvoller. Betrachten Sie diese Beispiele, insbesondere das 3. Beispiel und weiter:

          !!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!

!!x ist die Abkürzung für Boolean(x)

Der erste Schlag zwingt die js-Engine zum Ausführen von Boolean(x) , hat jedoch auch den Nebeneffekt, dass der Wert invertiert wird. Der zweite Knall macht also den Nebeneffekt rückgängig.


Tee aufbrühen:

!! ist kein Operator. Es ist die doppelte Verwendung von ! - Welches ist der logische "Nicht" -Operator.

In der Theorie:

! bestimmt die "Wahrheit" dessen, was ein Wert nicht ist:

  • Die Wahrheit ist, dass false nicht true (deshalb !false Ergebnisse in true )

  • Die Wahrheit ist, dass true nicht false (deshalb führt !true zu false )

!! bestimmt die "Wahrheit" dessen, was ein Wert nicht ist:

  • Die Wahrheit ist, dass true nicht true (deshalb !!true zu true )

  • Die Wahrheit ist, dass false nicht false (deshalb führt !!false Ergebnis zu false )

Was wir im Vergleich feststellen wollen, ist die "Wahrheit" über den Wert einer Referenz, nicht den Wert der Referenz selbst. Es gibt einen Anwendungsfall, in dem wir die Wahrheit über einen Wert wissen möchten, selbst wenn wir davon ausgehen, dass der Wert false (oder falsey), oder wenn wir erwarten, dass der Wert nicht vom Typ boolean .

In der Praxis:

Betrachten Sie eine prägnante Funktion, die Feature-Funktionen (und in diesem Fall Plattformkompatibilität) durch dynamisches Tippen (aka "duck typing") erkennt. Wir möchten eine Funktion schreiben, die true zurückgibt true wenn der Browser eines Benutzers das HTML5-Element <audio> unterstützt. Wir möchten jedoch nicht, dass die Funktion einen Fehler ausgibt, wenn <audio> definiert ist. und wir möchten try ... catch , um mögliche Fehler zu behandeln (weil sie grob sind); Außerdem möchten wir keine Überprüfung innerhalb der Funktion verwenden, die nicht immer die Wahrheit über die Funktion preisgibt (z. B. erstellt document.createElement('audio') immer noch ein Element mit dem Namen <audio> auch wenn HTML5 <audio> wird nicht unterstützt).

Hier sind die drei Ansätze:

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

Jede Funktion akzeptiert ein Argument für ein <tag> und ein attribute nach dem gesucht werden soll. Sie geben jedoch jeweils andere Werte zurück, je nachdem, was die Vergleiche bestimmen.

Aber warte, es gibt noch mehr!

Einige von Ihnen haben wahrscheinlich bemerkt, dass Sie in diesem speziellen Beispiel einfach nach einer Eigenschaft suchen können, indem Sie die etwas performantere Methode verwenden, um zu prüfen, ob das fragliche Objekt eine Eigenschaft hat. Es gibt zwei Möglichkeiten, dies zu tun:

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

Wir schweifen ab

So selten diese Situationen auch sein mögen, es gibt einige Szenarien, in denen die prägnantesten, leistungsstärksten und somit am meisten bevorzugten Mittel, um von einem nicht-booleschen, möglicherweise undefinierten Wert true , tatsächlich die Verwendung von !! . Hoffentlich klärt das lächerlich.


Nachdem ich all diese großartigen Antworten gesehen habe, möchte ich einen weiteren Grund für die Verwendung hinzufügen !! .Currenty Ich arbeite in Angular 2-4 (TypeScript) und möchte einen Boolean-Wert zurückgeben, falsewenn mein Benutzer nicht authentifiziert ist. Wenn er nicht authentifiziert wird, lautet der Token-String nulloder "". Ich kann dies tun, indem ich den nächsten Code-Block verwende:

public isAuthenticated(): boolean {
   return !!this.getToken();
}

Verwenden Sie logisch nicht Operator zwei Mal.
Dies bedeutet! True = false
und !! true = true





operators