¿Cuándo JavaScript devuelve null e indefinido?

Question

He estado usando JavaScript desde hace un par de años y nunca me ha importado la diferencia entre null & undefined anterior, siempre uso undefined para validar la existencia del objeto.

Pero recientemente llegué por this article. Aquí dijeron

distingue JavaScript entre null, que es un objeto de tipo 'objeto' que indica un no-valor deliberada, e indefinido, que es un objeto de tipo 'definido' que indica un valor no inicializado - que es decir, aún no se ha asignado un valor. Hablaremos de las variables más adelante, pero en JavaScript es posible declarar una variable sin asignarle un valor. Si hace esto, el tipo de variable no está definido.

Estoy completamente confundido ahora, lo que es exactamente no-valor aquí. Cómo este no valor difiere de undefined. Y cuáles son las circunstancias javascript devuelve null.

He probado el ejemplo siguiente

var sam; 
alert(sam); // returns undefined 

Y

try { 
    //var sam; 
    alert(sam); 
} catch(ex) { } // exception says: sam is undefined 

Y no estoy seguro acerca de cuándo js devolver valores nulos. ¿Puede alguien aclararme?

Answer 1

alert (sam); // devuelve indefinido

No, esa es una excepción.

Obtiene undefined cuando accede a una propiedad desarmada; se obtiene un error cuando utiliza un nombre no configurado directamente.

Las variables globales son interesantes porque se puede acceder ya sea usando un simple nombre de la variable, o mediante el uso de propiedades del objeto window mundial:

alert(window.sam);  // undefined 
alert(window['sam']); // undefined 
alert('sam' in window); // false 
alert(sam);    // ERROR 

Si sam se declara pero no inicializa, el acceso a window.sam todavía le consigue undefined, pero por un motivo diferente: hay una entrada en el objeto window para sam, pero apunta al mismo objeto undefined que se obtiene cuando se accede a una propiedad inexistente.

var sam; 
alert(window.sam);  // undefined 
alert(window['sam']); // undefined 
alert('sam' in window); // ** true 
alert(sam);    // ** undefined 

Esto es, por supuesto, un confuso y sangriento desastre; undefined es uno de los peores errores en el diseño del lenguaje JavaScript.

null por el contrario está bien y funciona prácticamente igual que null/nil/void/None values ​​en otros idiomas. No entra en ninguno de los anteriores.

Answer 2

<script type="text/javascript"> 
// variable with an unasigned value 
var a; 
if (a == undefined) { 
    alert('a is undefined'); 
} 

if (a == null) { 
    alert('a is undefined'); 
} 

// this will produce an error 
if (b == undefined) { 
    alert('b is undefined'); 
} 

// this is the right way to handle not defined variables 
if (typeof(c) == 'undefined') { 
    alert('c is blabla'); 
} 
</script> 

Answer 3

La forma en que los distinguen es indefinido ser "no he definido este valor", y nula ser "he definido este valor, pero no sabe o no puede averiguar cuál debería ser el valor."

Answer 4

Para que una variable reciba un valor nulo, debe asignarse. null se utiliza para indicar un valor desconocido o no importa. undefined por otro lado está diseñado para indicar que la propiedad a la que se accede nunca se ha asignado un valor. esto difiere de null.

Con null uno está diciendo deliberadamente "no sé qué valor debe tener presente sin embargo" o "no me importa qué valor se trata en este momento". OTH en undefined es realmente diciendo "¿Estás seguro de que deberías estar usando este valor que no ha sido asignado?"