Falsche Werte gegen null, undefinierte oder leere Zeichenfolge

Ich habe über die Jahre mit jQuery gearbeitet. In letzter Zeit habe ich mich jedoch tiefer mit der JavaScript-Sprache befasst. Vor kurzem habe ich von "wahrheitsgemäßen" und falschen Werten gehört. Ich verstehe sie jedoch nicht vollständig. Derzeit habe ich einen Code, der so aussieht:

var fields = options.fields || ['id', 'query'];

Ich muss feststellen, ob Felder null oder undefiniert sind oder eine Länge von 0 haben. Ich weiß, dass der lange Weg darin besteht:

if ((fields === null) || (fields === undefined) || (fields.length === 0)) {
 ...                    
}

Meine Frage ist, ist das gleiche das gleiche:

if (!fields)  {
 ...
}

Bei der Programmierung ist Wahrhaftigkeit oder Falschheit die Qualität jener booleschen Ausdrücke, die sich nicht in einen tatsächlichen booleschen Wert auflösen, aber dennoch als boolesches Ergebnis interpretiert werden.

Im Fall von C wird jeder Ausdruck, der mit Null ausgewertet wird, als falsch interpretiert. In Javascript ist der Ausdruck valuein

if(value) {
}

wird als wahr ausgewertet, wenn valuenicht:

null
undefined
NaN
empty string ("")
0
false

Siehe auch
Gibt es eine Standardfunktion, um in JavaScript nach null, undefinierten oder leeren Variablen zu suchen?

Die Menge der "truey" - und "falsey" -Werte in JavaScript stammt aus der ToBooleanabstrakten Operation, die in der ECMAScript-Spezifikation definiert ist und beim Erzwingen eines Werts in einen Booleschen Wert verwendet wird:

+--------------------------------------------------------------------------+
| Argument Type | Result                                                   |
|---------------+----------------------------------------------------------|
| Undefined     | false                                                    |
|---------------+----------------------------------------------------------|
| Null          | false                                                    |
|---------------+----------------------------------------------------------|
| Boolean       | The result equals the input argument (no conversion).    |
|---------------+----------------------------------------------------------|
| Number        | The result is false if the argument is +0, −0, or NaN;   |
|               | otherwise the result is true.                            |
|---------------+----------------------------------------------------------|
| String        | The result is false if the argument is the empty String  |
|               | (its length is zero); otherwise the result is true.      |
|---------------+----------------------------------------------------------|
| Object        | true                                                     |
+--------------------------------------------------------------------------+

Aus dieser Tabelle können wir das ersehen nullund undefinedwerden beide falsein einem booleschen Kontext dazu gezwungen . Ihr fields.length === 0wird jedoch im Allgemeinen nicht einem falschen Wert zugeordnet. Wenn fields.lengthes sich um eine Zeichenfolge handelt, wird sie als behandelt false(da es sich um eine Zeichenfolge mit der Länge Null handelt false). Wenn es sich jedoch um ein Objekt (einschließlich eines Arrays) handelt, wird es dazu gezwungen true.

Wenn fieldseine Zeichenfolge sein sollte, !fieldsist dies ein ausreichendes Prädikat. Wenn fieldses sich um ein Array handelt, ist Ihre beste Prüfung möglicherweise:

if (!fields || fields.length === 0)

Kurze Antwort:

Nein , sie sind nicht gleich.

Aber dieses:

if (!fields) { ... }

Ist das gleiche wie das:

if ((fields === null) || (fields === undefined) || (fields === 0) || (fields === '') || (fields === NaN) || (fields === flase)) { ...
}

Lange (und bessere) Antwort:

Lassen Sie uns zuerst über wahrheitsgemäße und falsche Werte sprechen.

Es geht darum, was passiert, wenn Sie etwas als Booleschen Wert bewerten. In JavaScript geschieht dies, wenn Sie beispielsweise ifAnweisungen verwenden. logische Operatoren wie ||, !oder &&; oder die Boolean()Funktion.

Die Boolean()Funktion akzeptiert einen Wert und gibt entweder trueoder zurück false.

Zum Beispiel:

var age = 1; // Let's evaluate age as a boolean Boolean(age); // true

Versuchen Sie dies in einer Knotenreplikation.

Ein boolean kann nur sein , trueoder false, so dass der Rückgabewert Boolean() muss entweder trueoder false. In diesem Fall haben wir den Wert übergeben 1und wenn er als Boolescher Wert ausgewertet wird, 1ist true.

Wichtig: Bei der Auswertung als Boolescher Wert muss ein Wert entweder wahr oder falsch sein. Dies sind die einzigen beiden Optionen.

In JavaScript gibt es nur 6 falsche Werte. Werte, falsedie als Boolescher Wert ausgewertet werden. Sie sind: false, 0, "", null, undefined, und NaN. Wenn einer dieser Werte als Boolescher Wert ausgewertet wird, ist er falsch:

Boolean(false) // false Boolean(0) // false Boolean("") // false Boolean(null) // false Boolean(undefined) // false Boolean(NaN) // false

Dies bedeutet, dass jeder andere Wert in JavaScript trueals Boolescher Wert ausgewertet wird. Jeder andere Wert in JavaScript ist also wahr.

Eine andere einfache Möglichkeit, etwas als zu bewerten, booleanist die Verwendung des !Operators. Genau wie die BooleanFunktion wertet dies einen Wert als Booleschen Wert aus. Aber wahrheitsgemäße Werte werden falseund fälschliche Werte werden true.

!false // true !0 // true !"" / true !null // true !undefined // true !NaN // true

Probieren Sie dies erneut in einer Knotenreplikation oder etwas anderem aus, um sicherzustellen, dass Sie es verstehen.

Also diese Aussage:

if (!fields) { ... }

Sagt Folgendes: "Wenn es fieldsals Boolescher Wert falsch ist, führen Sie den Code in dieser if-Anweisung aus."

Wie für Ihre erste Aussage:

var fields = options.fields || ['id', 'query'];

Sie arbeiten mit dem logischen ODER-Operator, über den Sie unbedingt lesen sollten, um sicherzustellen, dass Sie ihn verstehen. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators

Ihr Code bedeutet:

var fields;
if (options.fields)
    fields = options.fields;
else
    fields = ['id', 'query'];

Jetzt options.fieldswird in einen booleschen Wert konvertiert. Per Definition null, undefined, 0, ""umgewandelt wird false, (meistens) etwas anderes umgewandelt wird true(aber ich will nicht so genau sein).

Es bedeutet nicht dasselbe, weil die fields.length === 0Linie. Leere Arrays und andere Objekte werden in konvertiert true.

Hinweis: Javascript ist manchmal ein großes Durcheinander ... Zum Beispiel sind zwei Operatoren für die Typprüfung (typeof und instanceof) nicht wirklich erforderlich. Es verwirrt ppl nur, wenn true instanceof Booleanes nicht funktioniert und die Verwendung typeof(true) == "boolean"fehleranfällig ist, da eine Zeichenfolge ohne automatische Vervollständigung eingegeben wird. Vielleicht werden diese Probleme in einigen neuen Versionen gelöst.

Sie können versuchen (!! Felder), wenn das Feldelement null, undefiniert oder eine Länge von 0 hat, würde es true zurückgeben. Oder (!!! Felder) dann würde dies true zurückgeben.

der Doppelgänger ! oder !! wird wahr oder falsch erzwingen. Ich wünschte, ich könnte eine gute Definition dafür finden, aber ich scheine nicht in der Lage zu sein, sie wieder zu finden.