Verificação de JavaScript para null versus undefined e diferença entre == e ===

Eu sei, eu sei que deve haver alguns tópicos cobrindo este tópico. Mas eu usei a pesquisa e não obtive a resposta adequada às minhas necessidades. Aqui vamos nos:

  1. Como faço para verificar uma variável se é null ou undefined e qual é a diferença entre o null e undefined ?

  2. Qual é a diferença entre “==” e “===” (é difícil pesquisar no Google por === )?

   

Como faço para verificar uma variável se é null ou undefined

É a variável null :

 if (a === null) // or if (a == null) // but see note below 

… mas note que o último também será verdadeiro se a for undefined .

É undefined :

 if (typeof a === "undefined") // or if (a === undefined) // or if (a == undefined) // but see note below 

… mas, novamente, note que o último é vago; também será verdade se a for null .

Agora, apesar do que foi dito acima, a maneira usual de verificar isso é usar o fato de que eles são falsey :

 if (!a) { // `a` is falsey, which includes `undefined` and `null` // (and `""`, and `0`, and `NaN`, and [of course] `false`) } 

Isso é definido por ToBoolean na especificação.

… e qual a diferença entre o null e o undefined ?

Ambos são valores geralmente usados ​​para indicar a ausência de algo. undefined é o mais genérico, usado como o valor padrão de variables ​​até que seja atribuído algum outro valor, como o valor de argumentos de function que não foram fornecidos quando a function foi chamada, e como o valor que você obtém quando você pergunta a um object para uma propriedade que não tem. Mas também pode ser explicitamente usado em todas essas situações. (Há uma diferença entre um object não ter uma propriedade e ter a propriedade com o valor undefined ; há uma diferença entre chamar uma function com o valor undefined para um argumento e deixar esse argumento totalmente desligado.)

null é um pouco mais específico que undefined : é uma referência de object em branco. O JavaScript é fracamente typescript, é claro, mas nem todas as coisas com as quais o JavaScript interage são mal escritas. Se uma API como o DOM nos navegadores precisar de uma referência de object em branco, usaremos null , não undefined . E da mesma forma, a operação getElementById do DOM retorna uma referência de object – seja uma válida (se encontrar o elemento DOM), ou null (se não foi encontrada).

Curiosamente (ou não), eles são seus próprios tipos. Ou seja, null é o único valor no tipo nulo e undefined é o único valor no tipo indefinido.

Qual é a diferença entre “==” e “===”

A única diferença entre eles é que == fará coerção de tipo para tentar obter os valores correspondentes, e === não. Então, por exemplo, "1" == 1 é verdadeiro, porque "1" coage a 1 . Mas "1" === 1 é falso , porque os tipos não correspondem. ( "1" !== 1 é verdadeiro.) O primeiro passo (real) de === é “Os tipos dos operandos são os mesmos?” e se a resposta for “não”, o resultado é false . Se os tipos são os mesmos, faz exatamente o que == faz.

Tipo de coerção usa regras bastante complexas e pode ter resultados surpreendentes (por exemplo, "" == 0 é verdadeiro).

Mais na especificação:

  • Abstract Equality Comparison ( == , também chamado de igualdade “solta”)
  • Comparação estrita de igualdade ( === )

A diferença é sutil.

Em JavaScript, uma variável undefined é uma variável que nunca foi declarada ou nunca foi atribuída um valor. Vamos dizer que você declare var a; por exemplo, então a será undefined , porque nunca foi atribuído nenhum valor.

Mas se você, então, atribuir a = null; então a será agora null . Em JavaScript, null é um object (tente typeof null em um console JavaScript se você não acredita em mim), o que significa que null é um valor (na verdade, mesmo undefined é um valor).

Exemplo:

 var a; typeof a; # => "undefined" a = null; typeof null; # => "object" 

Isso pode ser útil em argumentos de function. Você pode querer ter um valor padrão, mas considerar nulo para ser aceitável. Nesse caso você pode fazer:

 function doSomething(first, second, optional) { if (typeof optional === "undefined") { optional = "three"; } // do something } 

Se você omitir o parâmetro optional doSomething(1, 2) then opcional será a string "three" mas se você passar doSomething(1, 2, null) , o opcional será null .

Quanto aos comparadores iguais == e estritamente iguais === , o primeiro é fraco, enquanto que estritamente igual também verifica o tipo de valores. Isso significa que 0 == "0" retornará verdadeiro; enquanto 0 === "0" retornará false, porque um número não é uma string.

Você pode usar esses operadores para verificar entre um null undefined . Por exemplo:

 null === null # => true undefined === undefined # => true undefined === null # => false undefined == null # => true 

O último caso é interessante, porque permite verificar se uma variável é indefinida ou nula e nada mais:

 function test(val) { return val == null; } test(null); # => true test(undefined); # => true 

A especificação é o lugar para obter respostas completas para essas perguntas. Aqui está um resumo:

  1. Para uma variável x , você pode:
    • verifique se é null por comparação direta usando === . Exemplo: x === null
    • verifique se ele é undefined por um dos dois methods básicos: comparação direta com undefined ou typeof . Por várias razões , prefiro typeof x === "undefined" .
    • verifique se é um de null e undefined usando == e confiando nas regras de coerção de tipo ligeiramente arcaico que significam x == null faz exatamente o que você quer.
  2. A diferença básica entre == e === é que se os operandos forem de tipos diferentes, === sempre retornará false enquanto == converterá um ou ambos os operandos no mesmo tipo usando regras que levem a um comportamento ligeiramente não intuitivo. Se os operandos forem do mesmo tipo (por exemplo, ambos são strings, como no typeof comparação acima), == e === se comportarão exatamente da mesma forma.

Mais leitura:

  • Verdade, Igualdade e JavaScript de Angus Croll
  • Coerção JavaScript de Andrea Giammarchi Desmistificada
  • comp.lang.javascript FAQs: conversão de tipo JavaScript

Indefinido

Isso significa que a variável ainda não está inicializada.

Exemplo:

 var x; if(x){ //you can check like this //code. } 

é igual (==)

Apenas o valor de verificação é igual a não tipo de dados.

Exemplo:

 var x = true; var y = new Boolean(true); x == y ; //returns true 

Porque verifica apenas o valor.

Igualdade Estrita (===)

Verifica o valor e o tipo de dados deve ser o mesmo.

Exemplo:

 var x = true; var y = new Boolean(true); x===y; //returns false. 

Porque ele verifica o tipo de dados x é um tipo primitivo e y é um object booleano.

Se a sua verificação (lógica) é para uma negação (!) E você deseja capturar tanto JS null quanto undefined (como Navegadores diferentes fornecerão resultados diferentes) você usaria a comparação menos restritiva: por exemplo:

 var ItemID = Item.get_id(); if (ItemID != null) { //do stuff } 

Isso irá capturar tanto null quanto undefined

Como faço para verificar uma variável se é nula ou indefinida

Basta verificar se uma variável tem um valor válido como este:

 if(variable) 

ele retornará true se a variável não contiver:

  • nulo
  • Indefinido
  • 0
  • falso
  • “” (uma string vazia)
  • NaN