Valores de falsa versus cadena nula, indefinida o vacía

He trabajado con jQuery a lo largo de los años. Sin embargo, recientemente, me he encontrado profundizando en el lenguaje JavaScript. Recientemente, escuché acerca de los valores de "verdad" y falsey. Sin embargo, no los entiendo completamente. Actualmente, tengo un código que se ve así:

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

Necesito identificar si los campos son nulos, indefinidos o tienen una longitud de 0. Sé que el camino largo es hacerlo:

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

Mi pregunta es, ¿es lo mismo lo siguiente?

if (!fields)  {
 ...
}

En programación, la veracidad o falsedad es la calidad de esas expresiones booleanas que no se resuelven en un valor booleano real, pero que, sin embargo, se interpretan como un resultado booleano.

En el caso de C, cualquier expresión que se evalúe como cero se interpreta como falsa. En Javascript, la expresión valueen

if(value) {
}

evaluará a verdadero si valueno es:

null
undefined
NaN
empty string ("")
0
false

Consulte también
¿Existe una función estándar para verificar variables nulas, indefinidas o en blanco en JavaScript?

El conjunto de valores de "veracidad" y "falsey" en JavaScript proviene de la ToBooleanoperación abstracta definida en la especificación ECMAScript , que se utiliza al coaccionar un valor a un valor 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                                                     |
+--------------------------------------------------------------------------+

De esta tabla, podemos ver eso nully undefinedambos son forzados falseen un contexto booleano. Sin embargo, fields.length === 0generalmente no se asigna a un valor falso. Si fields.lengthes una cadena, entonces se tratará como false(porque es una cadena de longitud cero false), pero si es un objeto (incluida una matriz) se verá obligada a hacerlo true.

Si fieldsdebería ser una cadena, entonces !fieldses un predicado suficiente. Si fieldses una matriz, su mejor verificación podría ser:

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

Respuesta corta:

No , no son lo mismo.

Pero esto:

if (!fields) { ... }

Es lo mismo que esto:

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

Respuesta larga (y mejor):

Primero hablemos de los valores de verdad y falsedad.

Se trata de lo que sucede cuando evalúas algo como booleano. En JavaScript, esto sucede cuando usa cosas como ifdeclaraciones; operadores lógicos gusta ||, !o &&; o la Boolean()función.

La Boolean()función acepta un valor y devuelve trueo false.

Por ejemplo:

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

Siga adelante e intente esto en un nodo repl.

Un booleano solo puede ser trueo false, por lo que el valor de retorno de Boolean() debe ser trueo false. En este caso, pasamos el valor 1, y cuando se evalúa como booleano, 1es true.

Importante: cuando se evalúa como un valor booleano, un valor debe ser verdadero o falso. Esas son las únicas dos opciones.

En JavaScript, solo hay 6 valores falsos. Valores que serán falsecuando se evalúen como booleanos. Ellos son: false, 0, "", null, undefined, y NaN. Entonces, si alguno de estos valores se evalúa como booleano, serán falsos:

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

Esto significa que cualquier otro valor, en JavaScript, se trueevaluará como booleano. Por lo tanto, cualquier otro valor en JavaScript es verdadero.

Otra manera fácil de evaluar algo como a booleanes usando el !operador. Al igual que la Booleanfunción, esto evalúa un valor como booleano. Pero los valores verdaderos se vuelven falsey los valores falsos se vuelven true.

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

Nuevamente, intente esto en una respuesta de nodo o algo para asegurarse de que comprende.

Entonces esta declaración:

if (!fields) { ... }

Dice lo siguiente: "if fields, cuando se evalúa como booleano, es falso, entonces ejecuta el código dentro de esta instrucción if".

En cuanto a su primera declaración:

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

Está trabajando con el operador lógico OR, que vale la pena leer para asegurarse de que comprende. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators

Tu código significa:

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

Ahora options.fieldsse convierte en un valor booleano. Por definición null, undefined, 0, ""se convierte en false, (en su mayoría) todo lo demás se convierte en true(pero no quieren ser tan preciso).

No significa lo mismo, porque la fields.length === 0línea. Las matrices vacías y otros objetos se convierten a true.

nota: Javascript es a veces un gran desastre ... Por ejemplo, no hay una necesidad real de 2 operadores de verificación de tipos (typeof e instanceof). Simplemente confunde a ppl cuando true instanceof Booleanno funciona y su uso typeof(true) == "boolean"es propenso a errores debido a que escribe una cadena sin autocompletar. Quizás en algunas versiones nuevas se resuelvan estos problemas.

Puede probar (!! fields) si el elemento fields es nulo, indefinido o tiene una longitud de 0, devolvería verdadero. O (!!! campos) entonces esto devolvería verdadero.

el doble ! o !! forzará verdadero o falso. Desearía poder encontrar una buena definición para esto, pero parece que no puedo encontrarla nuevamente.