Valores de falsidade vs cadeia nula, indefinida ou vazia

Eu trabalhei com o jQuery ao longo dos anos. No entanto, recentemente, eu me encontrei aprofundando a linguagem JavaScript. Recentemente, ouvi falar de valores "verdade" e falsey. No entanto, eu não os entendo completamente. Atualmente, eu tenho um código que se parece com isso:

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

Preciso identificar se os campos são nulos, indefinidos ou têm um comprimento igual a 0. Sei o longo caminho a fazer:

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

Minha pergunta é: é o mesmo:

if (!fields)  {
 ...
}

Na programação, veracidade ou falsidade é a qualidade daquelas expressões booleanas que não resolvem um valor booleano real, mas que, no entanto, são interpretadas como um resultado booleano.

No caso de C, qualquer expressão avaliada como zero é interpretada como falsa. Em Javascript, a expressão valueem

if(value) {
}

será avaliado como true se valuenão for:

null
undefined
NaN
empty string ("")
0
false

Consulte também
Existe uma função padrão para verificar variáveis ​​nulas, indefinidas ou em branco no JavaScript?

O conjunto de valores "truthy" e "falsey" no JavaScript vem da ToBooleanoperação abstrata definida na especificação ECMAScript , que é usada ao coagir um valor a um 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                                                     |
+--------------------------------------------------------------------------+

Nesta tabela, podemos ver isso nulle undefinedambos são coagidos falseem um contexto booleano. No entanto, o seu fields.length === 0geralmente não é mapeado para um valor falso. Se fields.lengthfor uma sequência, ela será tratada como false(porque é uma sequência de comprimento zero false), mas se for um objeto (incluindo uma matriz) será coagida true.

Se fieldsdeve ser uma sequência, !fieldsé um predicado suficiente. Se fieldsfor uma matriz, sua melhor verificação pode ser:

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

Resposta curta:

Não , eles não são os mesmos.

Mas isso:

if (!fields) { ... }

É o mesmo que isto:

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

Resposta longa (e melhor):

Vamos primeiro falar sobre valores de verdade e falsidade.

É tudo sobre o que acontece quando você avalia algo como um booleano. Em JavaScript, isso acontece quando você usa coisas como ifinstruções; operadores lógicos gosta ||, !ou &&; ou a Boolean()função.

A Boolean()função aceita um valor e retorna trueou false.

Por exemplo:

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

Vá em frente e tente isso em uma substituição de nó.

Um booleano pode ser apenas trueor false, portanto o valor de retorno de Boolean() deve ser trueou false. Nesse caso, passamos o valor 1e, quando avaliado como booleano, 1é true.

Importante: Quando avaliado como um booleano, um valor deve ser verdadeiro ou falso. Essas são as duas únicas opções.

Em JavaScript, existem apenas 6 valores de falsidade. Valores que serão falsequando avaliados como booleanos. Eles são: false, 0, "", null, undefined, e NaN. Portanto, se algum desses valores for avaliado como booleano, eles serão falsos:

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

Isso significa que qualquer outro valor, em JavaScript, será truequando avaliado como um booleano. Portanto, todos os outros valores no JavaScript são verdadeiros.

Outra maneira fácil de avaliar algo como booleanestá usando o !operador. Assim como a Booleanfunção, isso avalia um valor como booleano. Mas valores falseverdadeiros se tornam e valores falsificados se tornam true.

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

Novamente, tente isso em uma substituição de nó ou algo assim para garantir que você entenda.

Portanto, esta declaração:

if (!fields) { ... }

Está dizendo o seguinte: "se fields, quando avaliado como booleano, for falso, execute o código dentro desta instrução if".

Quanto à sua primeira declaração:

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

Você está trabalhando com o operador OR lógico, que vale a pena ler, para garantir que você entenda. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_Operators

Seu código significa:

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

Agora options.fieldsé convertido em um valor booleano. Por definição null, undefined, 0, ""é convertido em false, (a maioria) que qualquer outra coisa é convertido em true(mas eu não quero ser tão preciso).

Não significa o mesmo, porque a fields.length === 0linha. Matrizes vazias e outros objetos são convertidos em true.

Nota: Javascript às vezes é uma grande bagunça ... Por exemplo, não há necessidade real de dois operadores de verificação de tipo (typeof e instanceof). Ele apenas confunde as pessoas quando true instanceof Booleannão funciona e o uso typeof(true) == "boolean"é propenso a erros por causa da digitação de uma string sem preenchimento automático. Talvez em algumas novas versões esses problemas sejam resolvidos.

Você pode tentar (!! fields) se o elemento fields for nulo, indefinido ou tiver um comprimento de 0, ele retornará true. Ou (!!! campos), isso retornaria verdadeiro.

o dobro ! ou !! forçará verdadeiro ou falso. Eu gostaria de encontrar uma boa definição para isso, mas não consigo encontrá-la novamente.