Como posso determinar se uma variável é 'indefinida' ou 'nula'?

Como determino se a variável é undefinedou null?

Meu código é o seguinte:

var EmpName = $("div#esd-names div#name").attr('class');
if(EmpName == 'undefined'){
  // DO SOMETHING
};

<div id="esd-names">
  <div id="name"></div>
</div>

Mas se eu fizer isso, o intérprete JavaScript interrompe a execução.

Você pode usar as qualidades do operador de igualdade abstrata para fazer isso:

if (variable == null){
    // your code here.
}

Porque null == undefinedé verdade, o código acima irá pegar ambos nulle undefined.

A maneira padrão de capturar nulle undefinedsimultaneamente é esta:

if (variable == null) {
     // do something 
}

--qual é 100% equivalente ao mais explícito, mas menos conciso:

if (variable === undefined || variable === null) {
     // do something 
}

Ao escrever JS profissional, é dado como certo que a igualdade de tipo e o comportamento de ==vs=== são entendidos. Portanto, usamos ==e apenas comparamos com null.

Edite novamente

Os comentários sugerindo o uso de typeofestão simplesmente errados. Sim, minha solução acima causará um ReferenceError se a variável não existir. Isto é uma coisa boa. Este ReferenceError é desejável: ajudará você a encontrar seus erros e corrigi-los antes de enviar seu código, assim como os erros do compilador em outros idiomas. Use try/ catchse você estiver trabalhando com informações sobre as quais não tem controle.

Você não deve ter nenhuma referência a variáveis ​​não declaradas no seu código.

Combinando as respostas acima, parece que a resposta mais completa seria:

if( typeof variable === 'undefined' || variable === null ){
    // Do stuff
}

Isso deve funcionar para qualquer variável que não seja declarada ou declarada e definida explicitamente como nula ou indefinida. A expressão booleana deve ser avaliada como false para qualquer variável declarada que tenha um valor não nulo real.

if (variable == null) {
    // Do stuff, will only match null or undefined, this won't match false
}

if (typeof EmpName != 'undefined' && EmpName) {

será avaliado como true se o valor não for:

• nulo

• Indefinido

• NaN

• sequência vazia ("")

• 0 0

• falso

A attr()função jQuery retorna uma string em branco ou o valor real (e nunca nullou undefined). A única vez que retornaundefined é quando o seletor não retorna nenhum elemento.

Então, você pode querer testar uma string em branco. Como alternativa, como cadeias em branco, nulas e indefinidas são falsas, você pode fazer isso:

if (!EmpName) { //do something }

Eu vim para escrever minha própria função para isso. JavaScript é estranho.

É utilizável em literalmente qualquer coisa. (Observe que isso também verifica se a variável contém algum valor utilizável . Mas, como essas informações geralmente também são necessárias, acho que vale a pena postar). Por favor, considere deixar uma nota.

function empty(v) {
    let type = typeof v;
    if (type === 'undefined') {
        return true;
    }
    if (type === 'boolean') {
        return !v;
    }
    if (v === null) {
        return true;
    }
    if (v === undefined) {
        return true;
    }
    if (v instanceof Array) {
        if (v.length < 1) {
            return true;
        }
    } else if (type === 'string') {
        if (v.length < 1) {
            return true;
        }
        if (v === '0') {
            return true;
        }
    } else if (type === 'object') {
        if (Object.keys(v).length < 1) {
            return true;
        }
    } else if (type === 'number') {
        if (v === 0) {
            return true;
        }
    }
    return false;
}

Compatível com TypeScript.

Esta função deve fazer exatamente a mesma coisa que a empty()função do PHP (consulteRETURN VALUES )

Considera undefined, null, false, 0, 0.0, "0" {}, []como esvaziar.

"0.0", NaN, " ", trueSão considerados não-vazia.

Se a variável que você deseja verificar for global, faça

if (window.yourVarName) {
    // Your code here
}

Essa maneira de verificar não gera um erro, mesmo que a yourVarNamevariável não exista.

Exemplo: quero saber se meu navegador suporta a API do histórico

if (window.history) {
    history.back();
}

Como isso funciona:

windowé um objeto que contém todas as variáveis ​​globais como suas propriedades e, em JavaScript, é legal tentar acessar uma propriedade de objeto não existente. Se historynão existir, window.historyretornará undefined. undefinedé falsey, portanto, o código em um if(undefined){}bloco não será executado.

O mais curto e fácil:

if(!EmpName ){
 // DO SOMETHING
}

isso avaliará true se EmpName for:

• nulo
• Indefinido
• NaN
• esvaziar
• corda ("")
• 0 0
• falso

Provavelmente, a maneira mais curta de fazer isso é:

if(EmpName == null) { /* DO SOMETHING */ };

Aqui está a prova:

function check(EmpName) {
  if(EmpName == null) { return true; };
  return false;
}

var log = (t,a) => console.log(`${t} -> ${check(a)}`);

log('null', null);
log('undefined', undefined);
log('NaN', NaN);
log('""', "");
log('{}', {});
log('[]', []);
log('[1]', [1]);
log('[0]', [0]);
log('[[]]', [[]]);
log('true', true);
log('false', false);
log('"true"', "true");
log('"false"', "false");
log('Infinity', Infinity);
log('-Infinity', -Infinity);
log('1', 1);
log('0', 0);
log('-1', -1);
log('"1"', "1");
log('"0"', "0");
log('"-1"', "-1");

// "void 0" case
console.log('---\n"true" is:', true);
console.log('"void 0" is:', void 0);
log(void 0,void 0); // "void 0" is "undefined" 

E aqui estão mais detalhes sobre ==(fonte aqui )

BÔNUS : o motivo pelo qual ===é mais claro do que ==(veja a resposta agc )

Acabei de ter esse problema, ou seja, verificar se um objeto é nulo.
Eu simplesmente uso isso:

if (object) {
    // Your code
}

Por exemplo:

if (document.getElementById("enterJob")) {
    document.getElementById("enterJob").className += ' current';
}

Como você está usando jQuery , é possível determinar se uma variável é indefinida ou se seu valor é nulo usando uma única função.

var s; // undefined
jQuery.isEmptyObject(s); // will return true;

s = null; // defined as null
jQuery.isEmptyObject(s); // will return true;

// usage
if(jQuery.isEmptyObject(s)){
    alert('Either variable: s is undefined or its value is null');
}else{
     alert('variable: s has value ' + s);
}

s = 'something'; // defined with some value
jQuery.isEmptyObject(s); // will return false;

O elemento de verificação do jQuery não é nulo:

var dvElement = $('#dvElement');

if (dvElement.length  > 0) {
    // Do something
}
else{
    // Else do something else
}

Em JavaScript, de acordo com meu conhecimento, podemos verificar uma variável indefinida, nula ou vazia, como abaixo.

if (variable === undefined){
}

if (variable === null){
}

if (variable === ''){
}

Verifique todas as condições:

if(variable === undefined || variable === null || variable === ''){
}

Você pode simplesmente usar o seguinte (eu sei que existem maneiras mais curtas de fazer isso, mas isso pode facilitar a observação visual, pelo menos para outras pessoas que olham o código).

if (x === null || x === undefined) {
 // Add your response code here, etc.
}

A maneira mais fácil de verificar é:

if(!variable) {
  // If the variable is null or undefined then execution of code will enter here.
}

Com a solução abaixo:

const getType = (val) => typeof val === 'undefined' || !val ? null : typeof val;
const isDeepEqual = (a, b) => getType(a) === getType(b);

console.log(isDeepEqual(1, 1)); // true
console.log(isDeepEqual(null, null)); // true
console.log(isDeepEqual([], [])); // true
console.log(isDeepEqual(1, "1")); // false
etc...

Eu posso verificar o seguinte:

• nulo
• Indefinido
• NaN
• esvaziar
• corda ("")
• 0 0
• falso

Para testar se uma variável é nula ou indefinida, uso o código abaixo.

    if(typeof sVal === 'undefined' || sVal === null || sVal === ''){
      console.log('variable is undefined or null');
    }

Eu executo este teste no console do Chrome. Usando (vazio 0), você pode verificar indefinido:

var c;
undefined
if (c === void 0) alert();
// output =  undefined
var c = 1;
// output =  undefined
if (c === void 0) alert();
// output =   undefined
// check c value  c
// output =  1
if (c === void 0) alert();
// output =  undefined
c = undefined;
// output =  undefined
if (c === void 0) alert();
// output =   undefined

Vamos olhar para isso,

1.  

   let apple; // Only declare the variable as apple
   alert(apple); // undefined

   Acima, a variável é declarada apenas como apple. Nesse caso, se chamarmos método, alertele será exibido indefinido.

2.  

      let apple = null; /* Declare the variable as apple and initialized but the value is null */
      alert(apple); // null

No segundo, ele exibe nulo, porque a variável de applevalor é nula.

Portanto, você pode verificar se um valor é indefinido ou nulo.

if(apple !== undefined || apple !== null) {
    // Can use variable without any error
}

Melhor maneira:

if(typeof variable==='undefined' || variable===null) {

/* do your stuff */
}

(null == undefined)  // true

(null === undefined) // false

Porque === verifica o tipo e o valor. O tipo de ambos é diferente, mas o valor é o mesmo.

var i;

if (i === null || typeof i === 'undefined') {
    console.log(i, 'i is undefined or null')
}
else {
    console.log(i, 'i has some value')
}

A foo == nullverificação deve executar o truque e resolver o caso "indefinido OU nulo" da maneira mais curta. (Não considerando o caso "foo não é declarado".) Mas as pessoas que costumam ter 3 iguais (como a melhor prática) podem não aceitá-lo. Basta olhar para eqeqeq ou triple-iguais em eslint e tslint ...

A abordagem explícita, quando estamos verificando se uma variável é undefinedou nullseparadamente, deve ser aplicada neste caso, e minha contribuição para o tópico (27 respostas não negativas por enquanto!) É usar void 0como uma maneira curta e segura de executar a verificação para undefined.

O uso foo === undefinednão é seguro porque indefinido não é uma palavra reservada e pode ser sombreada ( MDN ). O uso do typeof === 'undefined'cheque é seguro, mas se não vamos nos importar com o caso não declarado, a seguinte abordagem pode ser usada:

if (foo === void 0 || foo === null) { ... }

se você criar uma função para verificá-la:

export function isEmpty (v) {
 if (typeof v === "undefined") {
   return true;
 }
 if (v === null) {
   return true;
 }
 if (typeof v === "object" && Object.keys(v).length === 0) {
   return true;
 }

 if (Array.isArray(v) && v.length === 0) {
   return true;
 }

 if (typeof v === "string" && v.trim().length === 0) {
   return true;
 }

return false;
}

Chamar typeof null retorna um valor de "objeto", pois o valor especial nulo é considerado uma referência de objeto vazio. O Safari da versão 5 e o Chrome da versão 7 têm uma peculiaridade em que chamar typeof em uma expressão regular retorna "function", enquanto todos os outros navegadores retornam "object".

var x;
if (x === undefined) {
    alert ("only declared, but not defined.")
};
if (typeof y === "undefined") {
    alert ("not even declared.")
};

Você só pode usar o segundo: pois ele verificará tanto a definição quanto a declaração

Ainda acho que a melhor maneira / segura de testar essas duas condições é converter o valor em uma string:

var EmpName = $("div#esd-names div#name").attr('class');

// Undefined check
if (Object.prototype.toString.call(EmpName) === '[object Undefined]'){
    // Do something with your code
}

// Nullcheck
if (Object.prototype.toString.call(EmpName) === '[object Null]'){
    // Do something with your code
}

Você pode verificar se o valor é indefinido ou nulo usando simplesmente typeof:

if(typeof value == 'undefined'){

if(x==null)é uma má ideia em JavaScript. Julgue com "=="- pode causar uma coerção inesperada do tipo e não pode ser lida pelo CoffeeScript, nunca use "==" ou "! =" No julgamento da condição!

if(x)será melhor, mas tenha cuidado com 0 e "" . Será tratado como falso , e não o método igual com "!= null"é verdadeiro .

Consulte Práticas recomendadas para JavaScript .