En JavaScript, ¿por qué "0" es igual a falso, pero cuando se prueba con 'if' no es falso por sí mismo?

Lo siguiente muestra que "0"es falso en Javascript:

>>> "0" == false
true

>>> false == "0"
true

Entonces, ¿por qué se imprime lo siguiente "ha"?

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

La razón es porque cuando lo haces explícitamente "0" == false, ambos lados se convierten en números, y luego se realiza la comparación.

Cuando lo hace:, if ("0") console.log("ha")el valor de la cadena se está probando. Cualquier cadena no vacía es true, mientras que una cadena vacía es false.

Igual (==)

Si los dos operandos no son del mismo tipo , JavaScript convierte los operandos y luego aplica una comparación estricta. Si cualquiera de los operandos es un número o un booleano , los operandos se convierten en números si es posible; de lo contrario, si cualquiera de los operandos es una cadena , el otro operando se convierte en una cadena si es posible. Si ambos operandos son objetos , entonces JavaScript compara referencias internas que son iguales cuando los operandos se refieren al mismo objeto en la memoria.

(De operadores de comparación en la red de desarrolladores de Mozilla)

Tablas que muestran el problema:

y ==

Moraleja del uso de la historia ===

crédito de generación de tablas: https://github.com/dorey/JavaScript-Equality-Table

Es de acuerdo a las especificaciones.

12.5 La declaración if 
.....

2. Si ToBoolean (GetValue (exprRef)) es verdadero, entonces 
a. Devuelve el resultado de evaluar la primera declaración.
3. De lo contrario, 
....

ToBoolean, según las especificaciones, es

La operación abstracta ToBoolean convierte su argumento a un valor de tipo booleano según la Tabla 11:

Y esa tabla dice esto sobre cadenas:

El resultado es falso si el argumento es la cadena vacía (su longitud es cero); de lo contrario el resultado es verdadero

Ahora, para explicar por "0" == falsequé debería leer el operador de igualdad, que establece que su valor de la operación abstracta GetValue(lref)coincide con el lado derecho.

Que describe esta parte relevante como:

si IsPropertyReference (V), entonces 
a. Si HasPrimitiveBase (V) es falso, entonces vamos a ser el método interno de base [[Get]], de lo contrario, vamos a obtener
sea ​​el método interno especial [[Get]] definido a continuación. 
si. Devuelve el resultado de llamar al método interno get usando base como su valor, y pasando
GetReferencedName (V) para el argumento

O, en otras palabras, una cadena tiene una base primitiva, que vuelve a llamar al método interno get y termina pareciendo falso.

Si desea evaluar las cosas usando la operación GetValue use ==, si desea evaluar usando el ToBooleanuso, ===(también conocido como el operador de igualdad "estricto")

Es PHP donde la cadena "0"es falsa (false-when-used-in-boolean-context). En JavaScript, todas las cadenas no vacías son verdaderas.

El truco es que ==contra un valor booleano no se evalúa en un contexto booleano, se convierte en número, y en el caso de cadenas que se realiza analizando como decimal. Entonces obtienes Number en 0lugar de la verdad booleana true.

Este es un diseño de lenguaje realmente pobre y es una de las razones por las que tratamos de no utilizar el desafortunado ==operador. Usar en su ===lugar.

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

Sus comillas alrededor lo 0convierten en una cadena, que se evalúa como verdadera.

Elimine las comillas y debería funcionar.

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

Todo se debe a las especificaciones de ECMA ... "0" == falsedebido a las reglas especificadas aquí http://ecma262-5.com/ELS5_HTML.htm#Section_11.9.3 ... Y se if ('0')evalúa como verdadero debido a las reglas especificadas aquí http: / /ecma262-5.com/ELS5_HTML.htm#Section_12.5

La expresión "if" prueba la veracidad, mientras que la prueba de doble igualdad para la equivalencia independiente del tipo. Una cadena siempre es verdadera, como han señalado otros aquí. Si el doble igual probara la veracidad de sus dos operandos y luego comparara los resultados, obtendría el resultado que suponía intuitivamente, es decir ("0" == true) === true. Como dice Doug Crockford en su excelente JavaScript: las partes buenas , "las reglas por las cuales [== coacciona los tipos de sus operandos] son ​​complicadas e inmemorables ... La falta de transitividad es alarmante". Es suficiente decir que uno de los operandos está forzado para coincidir con el otro, y que "0" termina siendo interpretado como un cero numérico,

== El operador de igualdad evalúa los argumentos después de convertirlos a números. Entonces la cadena cero "0" se convierte al tipo de datos Number y boolean false se convierte al Número 0. Entonces

"0" == false // true

Lo mismo se aplica a `

false == "0" //true

=== La estricta verificación de igualdad evalúa los argumentos con el tipo de datos original

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

Lo mismo se aplica a

false === "0" // false

En

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

La cadena "0" no se compara con ningún argumento, y la cadena es un valor verdadero hasta que, o a menos que se compare con algún argumento. Es exactamente como

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

Pero

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

``

Esto se debe a que JavaScript usa la coerción de tipo en contextos booleanos y su código

if ("0") 

será forzado a verdadero en contextos booleanos.

Hay otros valores de verdad en Javascript que se convertirán en verdaderos en contextos booleanos y, por lo tanto, ejecutarán el bloque 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) 

coacciona x usando toBoolean interno de JavaScript (http://es5.github.com/#x9.2)

x == false

coacciona a ambos lados usando la coerción interna toNumber (http://es5.github.com/#x9.3) o toPrimitive para objetos (http://es5.github.com/#x9.1)

Para más detalles ver http://javascriptweblog.wordpress.com/2011/02/07/truth-equality-and-javascript/