javascript - Como determinar se a variável é 'indefinida' ou 'nula'?




12 Answers

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.

javascript jquery variables null undefined

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.




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 não declarada ou declarada e explicitamente definida como nula ou indefinida. A expressão booleana deve ser avaliada como falsa para qualquer variável declarada que tenha um valor não nulo real.




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 }



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.




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

if (object) { Somecode}

ou seja

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



Melhor maneira:

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

/* do your stuff */
}



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



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

if(typeof value == 'undefined'){



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”.




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
}



Em algumas circunstâncias, é possível alterar o valor de undefined . Embora sejam geralmente raras, às vezes pode ser melhor evitar o uso real do valor undefined .

Como resultado, e porque é mais rápido escrever, eu me acostumei a usar um atalho para undefined que é olhar o primeiro valor de um array vazio. Este valor é garantido como sendo o valor primitivo undefined e pode ser acessado com [][0] .

Esta verificação funcionará para procurar tanto undefined quanto null .

Aqui está um exemplo:

(function(undefined){
    var foo = { baz: null };
    console.log(foo.bar === undefined); //false
    console.log(foo.bar == [][0]); //true
    console.log(foo.baz == [][0]); //true
}(50))




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




Related