ejemplos - javascript html

¿Por qué "indefinido es igual a falso" devuelve falso?

Question

Cuando comparo undefined y null contra Boolean false, la declaración devuelve false:

undefined == false;
null == false;

Devuelve falso. ¿Por qué?

Answer 1

Con la respuesta original apuntando a que se borraron las especificaciones, me gustaría proporcionar un enlace y un breve extracto de las especificaciones aquí.

http://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

El documento de especificaciones de ECMA enumera el motivo por el que undefined == false devuelve false. Aunque no dice directamente por qué es así, la parte más importante para responder esta pregunta se encuentra en esta oración:

The comparison x == y, where x and y are values, produces true or false.

Si buscamos la definición de nulo, encontramos algo como esto:

NULL or nil means "no value" or "not applicable".

En Javascript, undefined se trata de la misma manera. No tiene ningún valor. Sin embargo, falso tiene un valor. Nos está diciendo que algo no es así. Mientras que undefined y null no deben darnos ningún valor. Del mismo modo, no hay nada a lo que pueda convertir su comparación de igualdad abstracta, por lo tanto, el resultado siempre será falso. También es la razón por la cual null == undefined devuelve true (Ambos carecen de valor). Sin embargo, debe tenerse en cuenta que null === undefined devuelve false debido a sus diferentes tipos. (Utilice typeof(null) y typeof(undefined) en una consola para verificarlo)

Sin embargo, de lo que tengo curiosidad es que comparar NaN con cualquier cosa siempre será falso. Incluso cuando lo compara consigo mismo. [ NaN == NaN devuelve falso]

Además, otra información extraña: [tipo de typeof NaN devuelve "número"]

Igualdad estricta

Si es posible, debe evitar usar el operador == para comparar dos valores. En su lugar, use === para ver realmente si dos valores son iguales entre sí. == da la ilusión de que dos valores son exactamente iguales cuando pueden no estar utilizando la coerción. Ejemplos:

5 == "5" es cierto

5 === "5" es falso

"" == false es cierto

"" === false es falso

0 == false es verdadero

0 === false es falso

Answer 2

De acuerdo con la especificación que se mencionó anteriormente:

Si Type (y) es booleano, devuelva el resultado de la comparación x == ToNumber (y).

Number(undefined) = NaN;

false == NaN // false

Además si cambiamos de orden false == undefined

Si Type (x) es Boolean, devuelve el resultado de la comparación ToNumber (x) == y.

Number(false) = 0;
0 == undefined

No existe una regla para este caso, por lo tanto, trabaje el comportamiento predeterminado:

Falso retorno.

Answer 3

Esto es así porque es así. :)

Lea los estándares de ECMA aquí: https://www.ecma-international.org/ecma-262/5.1/#sec-11.9.3

Answer 4

Indefinido no puede ser falso porque no se ha definido, por lo que no se sabe si lo hace o no.

En inglés sería como decir Anonymous = Fred o Anonymous! = Fred.

Podría ser Fred, podría ser Bill, pero por el momento no tenemos ni idea.

Regla similar para Nulo. Es un poco doloroso darse la vuelta al principio, pero es una regla muy valiosa, sin ella todo tipo de ambigüedades pueden colarse en sus diseños.

Por ejemplo, cómo diferenciar entre algo que no se ha ingresado (nulo) o estar en blanco.

Answer 5

No definido no es lo mismo que falso, false es un objeto booleano (que tiene un valor de 0, por lo tanto, sí está definido).

Un ejemplo:

var my_var;
var defined = (my_var === undefined)
alert(defined);  //prints true.  It is true that my_var is undefined

my_var = 22;
defined = (my_var === undefined)
alert(defined);  //prints false.  my_var is now defined

defined = (false === undefined)
alert(defined);  //prints false, false is defined

defined = (true === undefined)
alert(defined);  //prints false, true is defined

Answer 6

Tan indefinido realmente significa indefinido. No es falso, no es verdadero, no es 0, no es cadena vacía. Entonces, cuando se compara indefinido con algo , el resultado siempre es falso, no es igual a eso.

Answer 7

Tu pregunta es mitad, ya que comparamos undefined / null con cualquier otro tipo. tendremos retorno falso. No hay coerción, incluso estamos usando == operador.

Answer 8

Desde el incomparable MDN, patrocinado por la compañía del creador de JavaScript.

JavaScript proporciona tres operaciones diferentes de comparación de valores:

• igualdad estricta (o "triple igual" o "identidad") usando ===,
• igualdad suelta ("doble es igual") usando ==,
• y Object.is (nuevo en ECMAScript> 6).

La elección de qué operación usar depende del tipo de comparación que desea realizar.

En resumen, los dobles iguales realizarán una conversión de tipo al comparar dos cosas; triple equals hará la misma comparación sin conversión de tipo (simplemente siempre devolviendo false si los tipos son diferentes); y Object.is se comportará de la misma manera que triple equals, pero con un manejo especial para NaN y -0 y +0 para que los dos últimos no sean los mismos, mientras que Object.is (NaN, NaN) será verdadero . (Comparando NaN con NaN ordinariamente, es decir, usando dobles iguales o triples equivalentes, se evalúa como falso, porque IEEE 754 lo dice). Observe que la distinción entre todos estos tiene que ver con su manejo de primitivas; ninguno de ellos compara si los parámetros son conceptualmente similares en estructura. Para cualquier objeto no primitivo xe y que tenga la misma estructura pero sean objetos distintos en sí mismos, todas las formas anteriores se evaluarán como falsas.

Para una visión general visual de la imagen completa de la igualdad en JavaScript: https://dorey.github.io/JavaScript-Equality-Table/

La verdad es que este aspecto aparentemente "malo" de JavaScript es una fuente de poder cuando comprendes cómo funciona.