javascript - with - undefined var




Como determinar se a variável é 'indefinida' ou 'nula'? (16)

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

Então você pode querer testar contra uma string em branco. Como alternativa, como strings em branco, null e undefined são false-y, você pode fazer isso:

if (!EmpName) { //do something }

Como faço para determinar se a variável é undefined ou 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 interromperá a execução.


A maneira padrão de pegar null e undefined simultaneamente é esta:

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

- que é 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 tipos e o comportamento de == vs === sejam compreendidos. Portanto, usamos == e só comparamos com null .

Editar novamente

Os comentários que sugerem o uso do typeof estã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: ele ajudará você a encontrar seus erros e corrigi-los antes de enviar seu código, assim como os erros do compilador em outros idiomas.

Você não deve ter referências a variáveis ​​não declaradas em seu código.


Calling typeof null retorna um valor de “objeto”, já que o valor especial nulo é considerado uma referência de objeto vazio. O Safari através da versão 5 e do Chrome até a versão 7 tem um capricho onde chamar o tipo de uma expressão regular retorna “função” enquanto todos os outros navegadores retornam “objeto”.


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
  • falso

Como você está usando o 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;

Elemento de verificação jQuery não nulo

var dvElement = $('#dvElement');

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

Esta é uma questão muito antiga, mas eu ainda acho que a melhor maneira / seguro de testar essas duas condições é lançar o valor para 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
}

Eu executo este teste no console chrome, usando (void 0) você pode verificar undefined

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

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

Utilizável literalmente em qualquer coisa. (Observe que isso também verifica se a variável contém algum valor utilizável. Mas, como essa informação geralmente também é necessária, 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.

editar. esta função deve fazer exatamente a mesma coisa que a função emptys empty() PHP (veja RETURN VALUES )

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

"0.0" , NaN , " " , true são considerados não vazios.


Melhor maneira:

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

/* do your stuff */
}

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

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

Esta maneira de verificar não lançará um erro, mesmo que a variável yourVarName não exista.

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

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

Como isso funciona:

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


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

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

Como null == undefined é true, o código acima irá capturar null e undefined .


if(x==null) é uma má ideia em javascript, julgar com "==" pode causar coerção de tipo inesperado, e não pode ser lido por coffee-script, nunca use "==" ou "! =" em julgamento de condição !

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

https://www.w3schools.com/js/js_best_practices.asp


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

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

  • nulo

  • Indefinido

  • NaN

  • seqüência vazia ("")

  • 0

  • falso


var i;

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

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: como ele irá verificar tanto a definição quanto a declaração







undefined