Valori falsi vs stringa nulla, non definita o vuota

Ho lavorato con jQuery nel corso degli anni. Tuttavia, recentemente, mi sono trovato ad approfondire il linguaggio JavaScript. Di recente, ho sentito parlare di "verità" e valori di falsità. Tuttavia, non li capisco del tutto. Attualmente, ho un codice simile a questo:

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

Devo identificare se i campi sono nulli, non definiti o hanno una lunghezza di 0. So che la strada da percorrere è:

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

La mia domanda è la seguente è la stessa:

if (!fields)  {
 ...
}

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

Nel caso di C, qualsiasi espressione valutata a zero viene interpretata come falsa. In Javascript, l'espressione valuein

if(value) {
}

valuterà vero se valuenon lo è:

null
undefined
NaN
empty string ("")
0
false

Vedi anche
Esiste una funzione standard per verificare la presenza di variabili nulle, non definite o vuote in JavaScript?

L'insieme dei valori "verità" e "falsità" in JavaScript proviene dall'operazione ToBooleanastratta definita nelle specifiche ECMAScript , che viene utilizzata quando si coordina un valore in 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 vederlo nulle undefinedsiamo costretti a farlo falsein un contesto booleano. Tuttavia, il tuo fields.length === 0non viene generalmente mappato 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à forzata true.

Se fieldsdovrebbe essere una stringa, allora !fieldsè un predicato sufficiente. Se fieldsè un array, il miglior controllo potrebbe essere:

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

Risposta breve:

No , non sono gli stessi.

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à.

Si tratta di cosa succede quando si valuta qualcosa come un valore booleano. In JavaScript, questo accade quando si usano cose come le ifdichiarazioni; operatori logici come ||, !o &&; o la Boolean()funzione.

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

Per esempio:

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

Vai avanti e prova questo in un nodo di sostituzione.

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

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

In JavaScript, ci sono solo 6 valori falsi. Valori che verranno falsevalutati come booleani. Essi sono: false, 0, "", null, undefined, e NaN. Quindi, se uno di questi valori viene valutato come booleano, saranno falsi:

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

Ciò significa che qualsiasi altro valore, in JavaScript, sarà truevalutato quando booleano. Quindi ogni altro valore in JavaScript è veritiero.

Un altro modo semplice per valutare qualcosa come booleanè usando l' !operatore. Proprio come la Booleanfunzione, questo valuta un valore come un valore booleano. Ma i valori della verità diventano falsee i valori della falsità diventano true.

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

Ancora una volta, prova questo in un nodo di sostituzione o qualcosa per assicurarti di capire.

Quindi questa affermazione:

if (!fields) { ... }

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

Per quanto riguarda la tua prima affermazione:

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

Stai lavorando con l'operatore logico OR, che vale la pena leggere per accertarti di aver capito. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators

Il tuo codice significa:

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

Ora options.fieldsviene convertito in un valore booleano. Per definizione null, undefined, 0, ""viene convertito false, (per lo più) ogni altra cosa viene convertito in true(ma io non voglio essere così precisi).

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

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

Puoi provare (!! campi) se l'elemento campi è nullo, indefinito o ha una lunghezza di 0 restituirà vero. Oppure (!!! campi), questo ritornerebbe vero.

Il doppio ! o !! forzerà vero o falso. Vorrei poter trovare una buona definizione per questo, ma non riesco a ritrovarla.