Verificação de JavaScript nula vs. indefinida e diferença entre == e ===

1. Como verifico uma variável se é nullou undefinede qual é a diferença entre the nulle undefined?

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

Como verifico uma variável se é nullou undefined...

É a variável null:

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

... mas observe que o último também será verdadeiro se afor undefined.

É undefined:

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

... mas, novamente, observe que o último é vago; também será verdade se afor null.

Agora, apesar do acima exposto, a maneira usual de verificar esses itens é usar o fato de serem falsos :

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

Isso é definido pelo ToBoolean na especificação.

... e qual é a diferença entre the nulle 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 das variáveis ​​até que elas recebam algum outro valor, como o valor dos argumentos da função que não foram fornecidos quando a função foi chamada e como o valor que você obtém ao perguntar a um objeto para uma propriedade que não possui. Mas também pode ser usado explicitamente em todas essas situações. (Há uma diferença entre um objeto não ter uma propriedade e ter a propriedade com o valor undefined; há uma diferença entre chamar uma função com o valor undefinedpara um argumento e deixar esse argumento totalmente desativado.)

nullé um pouco mais específico que undefined: é uma referência de objeto em branco. É claro que o JavaScript é tipicamente digitado, mas nem todas as coisas com as quais ele interage são digitadas. Se uma API como o DOM nos navegadores precisar de uma referência de objeto em branco, usaremos isso null, não undefined. E da mesma forma, a getElementByIdoperação do DOM retorna uma referência de objeto - válida (se encontrou o elemento DOM) ou null(se não encontrou).

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 corresponderá. Então, por exemplo, "1" == 1é verdade, porque "1"obriga 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 será false. Se os tipos são os mesmos, ele faz exatamente o que ==faz.

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

Mais nas especificações:

• Comparação de Igualdade Abstrata ( ==também chamada de igualdade "solta")
• Comparação estrita da igualdade ( ===)

A diferença é sutil.

No JavaScript, uma undefinedvariável é uma variável que nunca foi declarada ou nunca atribuiu um valor. Digamos que você declara, var a;por exemplo, então aserá undefined, porque nunca foi atribuído nenhum valor.

Mas se você atribuir, a = null;então aserá null. Em JavaScript, nullé um objeto (tente typeof nullem um console JavaScript, se você não acredita em mim), o que significa que nulo é 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 função. Você pode querer ter um valor padrão, mas considere nulo aceitável. Nesse caso, você pode fazer:

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

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

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

Você pode usar esses operadores para verificar entre undefinedum null. 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 mais nada:

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 é nullpor comparação direta usando ===. Exemplo:x === null
   • verifique se é undefinedum dos dois métodos básicos: comparação direta com undefinedou typeof. Por várias razões , eu prefiro typeof x === "undefined".
   • verifique se é uma delas nulle undefineduse ==e confie nas regras de coerção do tipo ligeiramente arcano que significa que x == nullfaz exatamente o que você deseja.
     
     
2. A diferença básica entre ==e ===é que, se os operandos são de tipos diferentes, ===sempre retornam falseenquanto ==convertem um ou ambos os operandos no mesmo tipo usando regras que levam a algum comportamento pouco intuitivo. Se os operandos forem do mesmo tipo (por exemplo, ambos são strings, como na typeofcomparação acima), ==e ===se comportarão exatamente da mesma maneira.

Mais leitura:

• Verdade, Igualdade e JavaScript de Angus Croll
• A coerção JavaScript de Andrea Giammarchi desmistificou
• FAQs do comp.lang.javascript: Conversão de tipo JavaScript

Como verifico uma variável se ela é nula ou indefinida

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

if(variable)

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

• nulo
• Indefinido
• 0 0
• falso
• "" (uma sequência vazia)
• NaN

Indefinido

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

Exemplo:

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

é igual a (==)

Ele apenas verifica se o valor é igual a não o tipo de dados.

Exemplo:

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

Porque verifica apenas o valor.

Iguais estritos (===)

Verifica se o valor e o tipo de dados devem ser iguais.

Exemplo:

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

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

O anúncio 1. nullnão é um identificador para uma propriedade do objeto global, como undefined pode ser

let x;      // undefined
let y=null; // null
let z=3;    // has value
// 'w'      // is undeclared

if(!x) console.log('x is null or undefined');
if(!y) console.log('y is null or undefined');
if(!z) console.log('z is null or undefined');

try { if(w) 0 } catch(e) { console.log('w is undeclared') }
// typeof not throw exception for undelared variabels
if(typeof w === 'undefined') console.log('w is undefined');

Anúncio 2. Os ===valores e tipos de verificação. Eles ==não exigem os mesmos tipos e fizeram uma conversão implícita antes da comparação (usando .valueOf()e .toString()). Aqui você tem todos ( src ):

E se

== (sua negação ! = )

=== (sua negação ! == )

Se sua verificação (lógica) é negativa (!) E você deseja capturar JS nulle undefined (como diferentes navegadores 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 ambos nulleundefined

Tente com lógica diferente . Você pode usar o código abaixo para verificar todas as quatro (4) condições para validação, como não nulo, não em branco, não indefinido e não zero, use apenas este código (! (! (Variável))) em javascript e jquery.

function myFunction() {
var data;  //The Values can be like as null, blank, undefined, zero you can test

if(!(!(data)))
{
   //If data has valid value
    alert("data "+data);
} 
else 
{
    //If data has null, blank, undefined, zero etc.
    alert("data is "+data);
}

}