Quando é null ou indefinido usado em JavaScript?

Estou muito confuso quanto ao JavaScript retorna null ou undefined . Também navegadores diferentes parecem estar retornando estes diferentemente.

Você poderia, por favor, dar alguns exemplos de null / undefined com os navegadores que os retornam.

Embora eu esteja claro sobre o aspecto undefined , ainda não estou 100% claro sobre o null . É semelhante a um valor em branco?

Por exemplo, você tem uma checkbox de texto que não possui nenhum valor definido. Agora, quando você tenta acessar seu valor, será null ou undefined e eles são semelhantes?

Os methods DOM getElementById() , nextSibling() , childNodes[n] , parentNode() e assim por diante retornam null (definido, mas sem valor) quando a chamada não retorna um object de nó.

A propriedade é definida, mas o object a que ela se refere não existe.

Esta é uma das poucas vezes em que você pode não querer testar a igualdade

if(x!==undefined) será verdadeiro para um valor nulo

mas if(x!= undefined) for verdadeiro (somente) para valores que não são undefined ou null .

Acho que algumas dessas respostas são vagas e complicadas, acho que a melhor maneira de descobrir essas coisas com certeza é simplesmente abrir o console e testá-las você mesmo.

 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 

Então essa é definitivamente uma das nuances mais sutis do JavaScript. Como você pode ver, é possível replace o valor de undefined , tornando-o pouco confiável em comparação com o valor null . Usando o operador == , você pode usar com segurança null e undefined intercambiável, tanto quanto eu posso dizer. No entanto, devido à vantagem de que null não pode ser redefinido, eu poderia usá-lo ao usar == .

Por exemplo, a variable != null Null retornará SEMPRE false se a variable for igual a null ou undefined , enquanto a variable != undefined retornará false se a variable for igual a null ou undefined SEM ABUSO, a undefined será reatribuída antecipadamente.

Você pode usar com segurança o operador === para diferenciar entre undefined e null , se precisar garantir que um valor seja realmente undefined (em vez de null ).

De acordo com a especificação do ECMAScript 5:

  • Ambos Null e Undefined são dois dos seis tipos embutidos.

4.3.9 valor indefinido

valor primitivo usado quando uma variável não foi atribuída um valor

4.3.11 valor nulo

valor primitivo que representa a ausência intencional de qualquer valor de object

Você fica indefinido para os vários cenários:

Você declara uma variável com var mas nunca a define.

 var foo; alert(foo); //undefined. 

Você tenta acessar uma propriedade em um object que você nunca definiu.

 var foo = {}; alert(foo.bar); //undefined 

Você tenta acessar um argumento que nunca foi fornecido.

 function myFunction (foo) { alert(foo); //undefined. } 

Como cwolves apontou em um comentário sobre outra resposta, funções que não retornam um valor.

 function myFunction () { } alert(myFunction());//undefined 

Um nulo geralmente tem que ser intencionalmente configurado em uma variável ou propriedade (veja os comentários para um caso em que possa aparecer sem ter sido definido). Além disso, um nulo é do tipo object e indefinido é do tipo undefined .

Também devo observar que null é válido em JSON, mas indefinido não é:

 JSON.parse(undefined); //syntax error JSON.parse(null); //null 

Eu posso estar faltando alguma coisa, mas afaik, você só fica undefined

Atualização: Ok, eu perdi muito, tentando completar:

Você fica undefined

… quando você tenta acessar propriedades de um object que não existem:

 var a = {} a.foo // undefined 

… quando você declarou uma variável mas não a inicializou:

 var a; // a is undefined 

… quando você acessa um parâmetro para o qual nenhum valor foi passado:

 function foo (a, b) { // something } foo(42); // b inside foo is undefined 

… quando uma function não retorna um valor:

 function foo() {}; var a = foo(); // a is undefined 

Pode ser que algumas funções null retornem null em algum erro, mas se assim for, então é documentado. null é um valor concreto em JavaScript, undefined não é.


Normalmente você não precisa distinguir entre esses. Dependendo dos valores possíveis de uma variável, é suficiente usar if(variable) para testar se um valor é setado ou não (ambos, null e undefined resultam em false ).

Também navegadores diferentes parecem estar retornando estes diferentemente.

Por favor, dê um exemplo concreto.

Em relação a este tópico, a especificação (ecma-262) é bastante clara

Eu achei realmente útil e direto, então compartilhei: – Aqui você encontrará o algoritmo Igualdade – Aqui você encontrará o algoritmo Strict equal

Eu esbarrei nele lendo “Resumo da igualdade, igualdade estrita e o mesmo valor” do site de desenvolvedor mozilla, a mesmice da seção.

Espero que você ache útil.

Uma propriedade, quando não tem definição, é indefinida. null é um object. Seu tipo é null. undefined não é um object, seu tipo é indefinido.

Este é um bom artigo explicando a diferença e também dando alguns exemplos.

null vs undefined