Wartości Falsy vs null, niezdefiniowany lub pusty ciąg

Przez lata pracowałem z jQuery. Jednak ostatnio odkryłem, że zagłębiam się w język JavaScript. Ostatnio słyszałem o wartościach „prawdy” i falseyu. Jednak nie do końca je rozumiem. Obecnie mam trochę kodu, który wygląda następująco:

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

Muszę ustalić, czy pola są puste, niezdefiniowane lub mają długość 0. Wiem, że długą drogą jest:

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

Moje pytanie brzmi: czy to samo:

if (!fields)  {
 ...
}

W programowaniu prawdą lub fałszem jest jakość tych wyrażeń boolowskich, które nie przekładają się na rzeczywistą wartość boolowską, ale które mimo to są interpretowane jako wynik boolowski.

W przypadku C każde wyrażenie, które ma wartość zero, interpretowane jest jako fałsz. W JavaScript, wyrażenie valuew

if(value) {
}

oceni prawdę, jeśli valuenie jest:

null
undefined
NaN
empty string ("")
0
false

Zobacz także
Czy istnieje standardowa funkcja sprawdzania zmiennych JavaScript, niezdefiniowanych lub pustych w JavaScript?

Zestaw wartości „truey” i „falsey” w JavaScript pochodzi z ToBooleanabstrakcyjnej operacji zdefiniowanej w specyfikacji ECMAScript , która jest używana podczas wymuszania wartości na wartość logiczną:

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

Z tej tabeli możemy to zobaczyć nulli undefinedoba są wymuszone falsew kontekście logicznym. Jednak twoje fields.length === 0mapowanie nie jest generalnie fałszywe. Jeśli fields.lengthjest łańcuchem, to będzie traktowane jako false(ponieważ jest łańcuchem o zerowej długości false), ale jeśli jest to obiekt (w tym tablica), będzie zmuszony true.

Jeśli fieldspowinien być ciągiem, to !fieldsjest wystarczającym predykatem. Jeśli fieldsjest tablicą, najlepszym sprawdzeniem może być:

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

Krótka odpowiedź:

Nie , nie są tacy sami.

Ale to:

if (!fields) { ... }

Jest taki sam jak ten:

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

Długa (i lepsza) odpowiedź:

Porozmawiajmy najpierw o wartościach prawdy i fałszu.

Chodzi o to, co się dzieje, gdy oceniasz coś jako wartość logiczną. W JavaScript dzieje się tak, gdy używasz rzeczy takich jak ifinstrukcje; operatory logiczne podoba ||, !lub &&; lub Boolean()funkcja.

Boolean()Funkcja przyjmuje wartość i powraca albo trueczy false.

Na przykład:

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

Śmiało i wypróbuj to w replice węzła.

Wartość logiczna może być tylko truelub false, więc zwracana wartość Boolean() musi wynosić albo truealbo false. W tym przypadku przekazaliśmy wartość 1, a gdy jest oceniana jako wartość logiczna, 1jest true.

Ważne: Przy ocenie jako wartość logiczna wartość musi być prawdą lub fałszem. To jedyne dwie opcje.

W JavaScript jest tylko 6 wartości fałszowania. Wartości, które zostaną falseocenione jako wartość logiczna. Są to: false, 0, "", null, undefined, i NaN. Więc jeśli którakolwiek z tych wartości zostanie oszacowana jako wartość logiczna, będą one fałszywe:

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

Oznacza to, że każda inna wartość w JavaScript zostanie uznana trueza wartość logiczną. Tak więc każda inna wartość w JavaScript jest prawdziwa.

Innym łatwym sposobem oceny czegoś jako booleanjest użycie !operatora. Podobnie jak Booleanfunkcja, wartość ta przyjmuje wartość logiczną. Ale prawdziwe stają się wartości, falsea stają się wartości fałszywe true.

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

Ponownie, wypróbuj to w replice węzła lub coś, aby upewnić się, że rozumiesz.

Więc to stwierdzenie:

if (!fields) { ... }

Mówi, co następuje: „jeśli jeśli fieldszostanie ocenione jako wartość logiczna, jest fałszywe, uruchom kod w tej instrukcji if”.

Co do twojego pierwszego oświadczenia:

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

Pracujesz z logicznym operatorem OR, który warto przeczytać, aby upewnić się, że rozumiesz. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators

Twój kod oznacza:

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

Teraz options.fieldsjest konwertowany na wartość logiczną. Z definicji null, undefined, 0, ""przekształca się false(przeważnie) cokolwiek innego przekształca się true(ale nie chcę być tak precyzyjny).

To nie znaczy tego samego, ponieważ fields.length === 0linia. Puste tablice i inne obiekty są konwertowane na true.

Uwaga: JavaScript jest czasem dużym bałaganem ... Na przykład nie ma potrzeby używania 2 operatorów sprawdzania typu (typeof i instanceof). Po prostu myli ppl, gdy true instanceof Booleannie działa, a używanie typeof(true) == "boolean"jest podatne na błędy z powodu wpisywania łańcucha bez autouzupełniania. Być może w niektórych nowych wersjach problemy te zostaną rozwiązane.

Możesz spróbować (!! pola), jeśli element pola jest pusty, niezdefiniowany lub ma długość 0, zwróci wartość true. Lub (!!! pola), to zwróci prawdę.

podwójny ! lub !! wymusi prawdę lub fałsz. Chciałbym znaleźć dobrą definicję tego, ale wydaje mi się, że nie jestem w stanie znaleźć go ponownie.