Em JavaScript, por que “0” é igual a falso, mas quando testado por 'if', não é falso por si só?

O seguinte mostra que "0"é falso em Javascript:

>>> "0" == false
true

>>> false == "0"
true

Então, por que o seguinte é impresso "ha"?

>>> if ("0") console.log("ha")
ha

A razão é porque quando você faz explicitamente "0" == false, ambos os lados estão sendo convertidos em números, e , em seguida, a comparação é realizada.

Quando você faz if ("0") console.log("ha"):, o valor da sequência está sendo testado. Qualquer string não vazia é true, enquanto uma string vazia é false.

Igual (==)

Se os dois operandos não forem do mesmo tipo , o JavaScript os converterá e aplicará uma comparação estrita. Se um operando for um número ou um booleano , os operandos serão convertidos em números, se possível; caso contrário, se um operando for uma sequência , o outro operando será convertido em uma sequência, se possível. Se ambos os operandos são objetos , o JavaScript compara referências internas que são iguais quando os operandos se referem ao mesmo objeto na memória.

(Dos operadores de comparação na Mozilla Developer Network)

Tabelas exibindo o problema:

e ==

Moral da história use ===

crédito de geração da tabela: https://github.com/dorey/JavaScript-Equality-Table

Está de acordo com as especificações.

12.5 A declaração if 
.....

2. Se ToBoolean (GetValue (exprRef)) for verdadeiro, então 
uma. Retorne o resultado da avaliação da primeira instrução.
3. Senão, 
....

ToBoolean, de acordo com as especificações, é

A operação abstrata ToBoolean converte seu argumento em um valor do tipo Booleano, de acordo com a Tabela 11:

E essa tabela diz isso sobre strings:

O resultado é falso se o argumento for a String vazia (seu comprimento é zero); caso contrário, o resultado é verdadeiro

Agora, para explicar por que "0" == falsevocê deve ler o operador de igualdade, que afirma que ele obtém seu valor da operação abstrata GetValue(lref)corresponde ao mesmo para o lado direito.

Que descreve esta parte relevante como:

se IsPropertyReference (V), então 
uma. Se HasPrimitiveBase (V) for falso, então get seja o método interno da [[Get]] base, caso contrário, deixe get
seja o método interno especial [[Get]] definido abaixo. 
b. Retorne o resultado de chamar o método interno get usando base como este valor e passando
GetReferencedName (V) para o argumento

Ou, em outras palavras, uma string tem uma base primitiva, que chama de volta o método get interno e acaba parecendo falsa.

Se você deseja avaliar coisas usando a operação GetValue ==, se você deseja avaliar usando o ToBoolean, use ===(também conhecido como operador de igualdade "estrito")

É no PHP que a string "0"é falsa (false quando usado no contexto booleano). No JavaScript, todas as cadeias não vazias são verdadeiras.

O truque é que, ==contra um booleano não é avaliado em um contexto booleano, ele é convertido em número e, no caso de strings feitas pela análise como decimal. Então você obtém Number em 0vez da veracidade booleana true.

Esse é realmente um pouco pobre de design de linguagem e é uma das razões pelas quais tentamos não usar o infeliz ==operador. Use em ===vez disso.

// I usually do this:

x = "0" ;

if (!!+x) console.log('I am true');
else      console.log('I am false');

// Essentially converting string to integer and then boolean.

Suas aspas ao redor do texto 0tornam-no uma sequência, que é avaliada como verdadeira.

Remova as aspas e deve funcionar.

if (0) console.log("ha") 

É tudo por causa das especificações do ECMA ... "0" == falsepor causa das regras especificadas aqui http://ecma262-5.com/ELS5_HTML.htm#Section_11.9.3 ... E if ('0')avaliado como verdadeiro por causa das regras especificadas aqui http: / /ecma262-5.com/ELS5_HTML.htm#Section_12.5

A expressão "if" testa a veracidade, enquanto a dupla é igual à equivalência independente do tipo. Uma string é sempre verdadeira, como outras pessoas apontaram aqui. Se o duplo igual estivesse testando ambos os operandos quanto à veracidade e depois comparando os resultados, você obteria o resultado que estava assumindo intuitivamente, ou seja ("0" == true) === true. Como Doug Crockford diz em seu excelente JavaScript: the Good Parts , "as regras pelas quais [== força os tipos de seus operandos] são complicadas e imemoráveis ​​... A falta de transitividade é alarmante". Basta dizer que um dos operandos é coagido a combinar com o outro e que "0" acaba sendo interpretado como um zero numérico,

== O operador de igualdade avalia os argumentos após convertê-los em números. Então seqüência zero "0" é convertido para o tipo de dados Número e boolean false é convertido em número 0. Assim,

"0" == false // true

O mesmo se aplica a `

false == "0" //true

=== A verificação rigorosa de igualdade avalia os argumentos com o tipo de dados original

"0" === false // false, because "0" is a string and false is boolean

O mesmo se aplica a

false === "0" // false

No

if("0") console.log("ha");

A String "0" não se compara a nenhum argumento, e a string é um valor verdadeiro até ou a menos que seja comparada com qualquer argumento. É exatamente como

if(true) console.log("ha");

Mas

if (0) console.log("ha"); // empty console line, because 0 is false

`

Isso ocorre porque o JavaScript usa coerção de tipo em contextos booleanos e seu código

if ("0") 

será coagido a ser verdadeiro em contextos booleanos.

Existem outros valores reais em Javascript que serão coagidos a verdade em contextos booleanos e, portanto, executam o bloco if:

if (true)
if ({})
if ([])
if (42)
if ("0")
if ("false")
if (new Date())
if (-42)
if (12n)
if (3.14)
if (-3.14)
if (Infinity)
if (-Infinity)

if (x) 

coage x usando o toBoolean interno do JavaScript (http://es5.github.com/#x9.2)

x == false

coage ambos os lados usando coerção interna toNumber (http://es5.github.com/#x9.3) ou toPrimitive para objetos (http://es5.github.com/#x9.1)

Para obter detalhes completos, consulte http://javascriptweblog.wordpress.com/2011/02/07/truth-equality-and-javascript/