quitar - ¿Cuándo se usa nulo o indefinido en JavaScript?
variable null javascript (6)
Esta pregunta ya tiene una respuesta aquí:
Estoy realmente confundido cuando JavaScript devuelve null o undefined . También diferentes navegadores parecen estar devolviendo estos de manera diferente.
¿Podría dar algunos ejemplos de null / undefined con los navegadores que los devuelven?
Si bien ahora tengo claro el aspecto undefined , todavía no estoy 100% claro en null . ¿Es similar a un valor en blanco?
Por ejemplo, tiene un cuadro de texto que no tiene ningún valor establecido. Ahora cuando intenta acceder a su valor, ¿será null o undefined y son similares?
En relación con este tema, la especificación (ecma-262) es bastante clara
Lo encontré realmente útil y directo, así que lo comparto: Aquí encontrará el algoritmo de Igualdad . Aquí encontrará el algoritmo de igualdad estricta.
Me encontré con que decía "igualdad abstracta, igualdad estricta y el mismo valor" del sitio del desarrollador de mozilla, sección sameness.
Espero que le sea útil.
Encuentro que algunas de estas respuestas son vagas y complicadas, y creo que la mejor manera de descubrir estas cosas es simplemente abrir la consola y probarla usted mismo.
var x;
x == null // true
x == undefined // true
x === null // false
x === undefined // true
var y = null;
y == null // true
y == undefined // true
y === null // true
y === undefined // false
typeof x // ''undefined''
typeof y // ''object''
var z = {abc: null};
z.abc == null // true
z.abc == undefined // true
z.abc === null // true
z.abc === undefined // false
z.xyz == null // true
z.xyz == undefined // true
z.xyz === null // false
z.xyz === undefined // true
null = 1; // throws error: invalid left hand assignment
undefined = 1; // works fine: this can cause some problems
Este es definitivamente uno de los matices más sutiles de JavaScript. Como puede ver, puede anular el valor de undefined , por lo que es poco fiable en comparación con null . Utilizando el operador == , puede usar de forma fiable null e undefined intercambiable por lo que yo sé. Sin embargo, debido a la ventaja de que null no se puede redefinir, podría usarlo cuando use == .
Por ejemplo, la variable != null SIEMPRE devolverá falso si la variable es null o undefined , mientras que la variable != undefined devolverá falso si la variable es null o undefined MENOS QUE undefined se reasigne de antemano.
Puede usar de manera confiable el operador === para diferenciar entre undefined y null , si necesita asegurarse de que un valor no está undefined (en lugar de null ).
De acuerdo con la especificación ECMAScript 5:
-
NullyUndefinedson dos de los seis tipos integrados.
4.3.9 valor indefinido
valor primitivo utilizado cuando a una variable no se le ha asignado un valor
4.3.11 valor nulo
valor primitivo que representa la ausencia intencional de cualquier valor de objeto
Los métodos DOM getElementById() , nextSibling() , childNodes[n] , parentNode() y así sucesivamente vuelven null (definidos pero no tienen ningún valor) cuando la llamada no devuelve un objeto nodo.
La propiedad está definida, pero el objeto al que se refiere no existe.
Esta es una de las pocas veces que puede que no quiera probar para la igualdad-
if(x!==undefined) será verdadero para un valor nulo
pero if(x!= undefined) será verdadero (solo) para valores que no son ni undefined ni null .
No se define para los diferentes escenarios:
Usted declara una variable con var pero nunca la establece.
var foo;
alert(foo); //undefined.
Intenta acceder a una propiedad en un objeto que nunca ha establecido.
var foo = {};
alert(foo.bar); //undefined
Intenta acceder a un argumento que nunca se proporcionó.
function myFunction (foo) {
alert(foo); //undefined.
}
Como los lobos señalaron en un comentario sobre otra respuesta, funciones que no devuelven un valor.
function myFunction () {
}
alert(myFunction());//undefined
Por lo general, un nulo debe establecerse intencionalmente en una variable o propiedad (consulte los comentarios de un caso en el que puede aparecer sin haber sido configurado). Además, un nulo es de tipo object e indefinido es de tipo undefined .
También debería tener en cuenta que null es válido en JSON pero undefined no es:
JSON.parse(undefined); //syntax error
JSON.parse(null); //null
Una propiedad, cuando no tiene definición, no está definida. null es un objeto. Su tipo es nulo. indefinido no es un objeto, su tipo no está definido.
Este es un buen artículo explicando la diferencia y también dando algunos ejemplos.
Puede que me esté perdiendo algo, pero afaik, solo se define como undefined
Actualización: Ok, me extrañé mucho, tratando de completar:
Te vuelves undefined ...
... cuando intenta acceder a las propiedades de un objeto que no existe:
var a = {}
a.foo // undefined
... cuando ha declarado una variable pero no la ha inicializado:
var a;
// a is undefined
... cuando accede a un parámetro para el que no se pasó ningún valor:
function foo (a, b) {
// something
}
foo(42); // b inside foo is undefined
... cuando una función no devuelve un valor:
function foo() {};
var a = foo(); // a is undefined
Es posible que algunas funciones integradas devuelvan null en algún error, pero si es así, entonces está documentado. null es un valor concreto en JavaScript, undefined no lo es.
Normalmente no es necesario distinguir entre esos. Dependiendo de los valores posibles de una variable, es suficiente usar if(variable) para probar si un valor está establecido o no (ambos, null e undefined evalúan como false ).
También diferentes navegadores parecen estar devolviendo estos de manera diferente.
Por favor da un ejemplo concreto.