Falsy values vs null, undefined o empty string

Nella programmazione, la verità o la falsità è la qualità di quelle espressioni booleane che non si risolvono in un vero valore booleano, ma che tuttavia vengono interpretate come un risultato booleano.

Nel caso di C, qualsiasi espressione che valuti a zero viene interpretata come falsa. In Javascript, l'espressione value in

if(value) {
}

valuterà a vero se value non è:

null
undefined
NaN
empty string ("")
0
false

Vedi anche
Esiste una funzione standard per verificare le variabili nulle, indefinite o vuote in JavaScript?

L'insieme di valori "verità" e "falsi" in JavaScript proviene dal ToBoolean operazione astratta definita nella specifica ECMAScript , che viene utilizzata quando si costringe un valore a un valore booleano:

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

Da questa tabella, possiamo vedere che null e undefined sono entrambi forzati a false in un contesto booleano. Tuttavia, il tuo fields.length === 0 non mappa generalmente su un valore falso. Se fields.length è una stringa, verrà trattata come false (perché una stringa di lunghezza zero è false ), ma se è un oggetto (incluso un array), verrà forzato a true .

Se fields dovrebbe essere una stringa, quindi !fields è un predicato sufficiente. Se fields è un array, il tuo miglior controllo potrebbe essere:

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

Risposta breve:

No , non sono la stessa cosa.

Ma questo:

if (!fields) { ... }

È lo stesso di questo:

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

Risposta lunga (e migliore):

Parliamo prima dei valori di verità e falsità.

Riguarda cosa succede quando valuti qualcosa come un booleano. In JavaScript, questo succede quando usi cose come if statement; operatori logici come || , ! o && ; o la funzione Boolean() .

La funzione Boolean() accetta un valore e restituisce true o false .

Ad esempio:

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

Vai avanti e prova questo in un nodo repl.

Un valore booleano può essere solo true o false , quindi il valore di ritorno di Boolean() deve essere true o false . In questo caso, abbiamo passato il valore 1 , e quando valutato come booleano, 1 è true .

Importante: se valutato come booleano, un valore deve essere vero o falso. Quelle sono le uniche due opzioni.

In JavaScript, ci sono solo 6 valori falsy. Valori che saranno false se valutati come booleani. Sono: false , 0 , "" , null , undefined e NaN . Quindi se qualcuno di questi valori viene valutato come booleano, sarà falso:

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

Questo significa che qualsiasi altro valore, in JavaScript, sarà true se valutato come booleano. Quindi ogni altro valore in JavaScript è vero.

Un altro modo semplice per valutare qualcosa come boolean è usando l'operatore ! . Proprio come la funzione Boolean , questo valuta un valore come booleano. Ma i valori di verità diventano false e i valori di falsy diventano true .

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

Ancora una volta, prova questo in un nodo repl o qualcosa per assicurarti di aver capito.

Quindi questa affermazione:

if (!fields) { ... }

Sta dicendo il seguente: "se fields , quando valutato come booleano, è falso, quindi esegui il codice all'interno di questa istruzione if".

Per quanto riguarda la prima affermazione:

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

Stai lavorando con l'operatore logico OR, che vale la pena leggere per assicurarti di aver capito. link

Il tuo codice significa:

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

Ora options.fields viene convertito in un valore booleano. Per definizione null , undefined , 0 , "" è convertito in false , (principalmente) tutto il resto è convertito in true (ma non voglio essere così preciso).

Non significa lo stesso, perché la riga fields.length === 0 . Le matrici e gli altri oggetti vuoti vengono convertiti in true .

nota: Javascript a volte è un gran casino ... Per esempio non c'è bisogno di 2 operatori di controllo del tipo (typeof e instanceof). Confonde semplicemente ppl quando true instanceof Boolean non funziona e l'utilizzo di typeof(true) == "boolean" è soggetto ad errori a causa della digitazione di una stringa senza completamento automatico. Forse in alcune nuove versioni questi problemi saranno risolti.

Puoi provare (!! fields) se l'elemento fields è nullo, indefinito o ha una lunghezza pari a 0 restituisce true. Oppure (campi !!!) questo restituirebbe true.

il doppio! o !! Forzerò vero o falso. Vorrei poter trovare una buona definizione per questo, ma non riesco a trovarlo di nuovo.