practicas - diferencia entre null y undefined en JavaScript?

undefined javascript

Question

De acuerdo con ¿Cuál es la diferencia entre nulo e indefinido en JavaScript? , null y undefined son dos objetos diferentes (con tipos diferentes) en Javascript. Pero cuando intento este código

var a=null;
var b;
alert(a==null); // expecting true
alert(a==undefined); // expecting false
alert(b==null); // expecting false
alert(b==undefined); // expecting true

La salida del código anterior es:

true
true
true
true

Ahora como == solo coincide con el valor, pensé que tanto undefined como null deben tener el mismo valor. Así que intenté:

alert(null) -> da null

alert(undefined) -> da undefined

No entiendo cómo es esto posible.

Aquí está la demo .

Editar

Entiendo que === dará el resultado esperado porque undefined y null tienen diferentes tipos, pero ¿cómo funciona la conversión de tipos en Javascript en el caso de == ? ¿Podemos hacer conversión explícita de tipos como lo hacemos en Java? Me gustaría aplicar una conversión de tipo manual en undefined y null .

Answer 1

Debe utilizar el operador de identidad === , no el operador de igualdad == . Con este cambio, su código funciona como se espera :

alert(a===null); // true
alert(a===undefined); // false
alert(b===null); // false
alert(b===undefined); // true

La razón por la que el operador de igualdad falla en este caso es porque intenta realizar una conversión de tipo. undefined es de tipo undefined , y null es de tipo object ; Al intentar comparar los dos, Javascript convierte ambos en false , por lo que termina considerándolos iguales. Por otro lado, el operador de identidad no hace una conversión de tipo, y requiere que los tipos sean iguales para concluir la igualdad.

Editar Gracias a @ user1600680 por señalar, lo anterior no es del todo correcto; La especificación ECMAScript define el valor nulo a indefinido como un caso especial e igual. No hay conversión intermedia a false .

Un ejemplo más simple de conversión de tipo es número a cadena:

console.log(5 == "5"); // true
console.log(5 === "5"); // false

La respuesta anterior tiene una buena cita de Javascript de Douglas Crockford : Las partes buenas :

[El operador "==" hace lo correcto cuando los operandos son del mismo tipo, pero si son de diferentes tipos, intentan forzar los valores. Las reglas por las que hacen eso son complicadas y no memorables.

Si no cree que las reglas sean complicadas y no memorables , un vistazo rápido a esas reglas le disuadirá de esa noción.

Answer 2

Necesitas usar === en lugar de ==. El operador === se comporta de la misma manera que el operador ==, excepto que no realiza ninguna conversión de tipo.

Answer 3

Para aclarar una respuesta anterior, la razón por la que == funciona de esta manera es porque, a diferencia de === , hace conversión de tipo

Answer 4

También me gustaría decir que lo undefined se usa con el tipo de. La comparación debe ser como:

if( typeof(b)=="undefined" ){}

que da los mismos resultados que

if( b === undefined ){}

y he incluido estas pruebas adicionales en su código http://jsfiddle.net/A89Qj/5/

Answer 5

typeof undefined es undefined pero el tipo de null es object. null === undefined le dará falso. pero null == undefined te dará la verdad. Como boh son de diferentes tipos de datos pero tienen el mismo valor.

Answer 6

undefined y null tienen significados semánticos muy diferentes.

undefined normalmente significa "No hubo respuesta" y null significa "Hubo una respuesta y esa respuesta no fue nada".

Por ejemplo, si he creado este objeto:

var gameState = {
state: loaded,
lastPlayer: null,
lastScore: null
};

Esto no significa que "no sé quién fue el último jugador", sino que significa que "no hubo un último jugador".

Answer 7

 var a;
var b = null;

a no está definido, b es completamente nulo.

== se usa para comparar la igualdad de una manera deliberadamente flexible, que a menudo es útil

alert("3" == 3.0);

Eso nos da la true aunque son claramente diferentes: un número y una cadena.

Muchas veces, sin embargo, esto es genial.

Del mismo modo, muchas veces no me importa si algo no tiene un valor real porque no estaba definido, o porque se estableció explícitamente en nulo.

Aunque a veces es útil, también es necesario que sepamos las coincidencias de tipo exactas y el valor, por lo que también tenemos === .