Como verifico valores nulos em JavaScript?

576

Como posso verificar valores nulos em JavaScript? Eu escrevi o código abaixo, mas não funcionou.

if (pass == null || cpass == null || email == null || cemail == null || user == null) {      

    alert("fill all columns");
    return false;  

}   

E como posso encontrar erros nos meus programas JavaScript?

Mahdi_Nine
fonte
Tem certeza de que os valores que você está testando são realmente nulos e não apenas uma sequência vazia?
Jan-Peter Vos
72
testando nullem js deve ser feito com o operador estrito===
Davin
3
@ David - verdade, mas não o problema aqui, pois se fosse a declaração ainda funcionaria.
Mark Kahn
3
@ lobos, se eu pensasse que era o problema, eu teria feito esse comentário uma resposta. Confira minha redação, estou claramente fazendo uma declaração geral sobre o idioma em referência à prática do OP, e não estou propondo que isso resolva seu problema.
davin 14/05
2
@TRiG as alterações propostas alteram fundamentalmente a natureza da pergunta até o ponto em que as respostas (não apenas as minhas) perdem o contexto e não fazem sentido. A edição deve ser apenas um comentário.
Ic3b3rg

Respostas:

742

Javascript é muito flexível no que diz respeito à verificação de valores "nulos". Suponho que você esteja realmente procurando por cadeias vazias; nesse caso, esse código mais simples funcionará:

if(!pass || !cpass || !email || !cemail || !user){

Que irá verificar se há cadeias vazias ( ""), null, undefined, falsee os números 0eNaN

Observe que, se você estiver procurando especificamente por números, é um erro comum errar 0com esse método e num !== 0é preferido ( num !== -1ou ~num(código hacky que também controla -1)) funções que retornam -1, por exemplo indexOf)

Mark Kahn
fonte
4
Seria muito útil saber quais partes deste teste para quais valores. Às vezes você está procurando um em particular.
inorganik
2
Um pouco de uma declaração tardia, mas sim, você pode executar testes contra cada um deles @inorganik, veja a minha resposta abaixo #
WebWanderer
28
Leitores, tenha cuidado ao usar este tipo de teste em dados numéricos. Não use !ou !!para testar nullou undefinedem dados normalmente-numérico menos que você também quer jogar fora os valores de 0.
NickS
4
A resposta em si afirma: "... e os números 0...". Acredito que esta resposta seja perfeitamente apropriada para a pergunta, dado o contexto (que estou deduzindo é "nome de usuário, senha, email"), eles não estão verificando 0valores. Dada a popularidade desta pergunta e resposta, no entanto, concordo que vale a pena mencionar na própria resposta.
Mark Kahn
4
@ Hendeca - revira os olhos Vá ler o código na pergunta real. Está perguntando claramente sobre nomes de usuário e senhas. Não estou adivinhando nada, só estava sendo educado. Você está incomodado pelo fato de eu ter respondido o que eles precisavam e não o que eles pediam, o que é um absurdo. É assim, na maioria das vezes as pessoas não sabem o que deveriam estar pedindo. No contexto da pergunta original, esta resposta está correta. Agora pare de adicionar ruído.
Mark Kahn #
420

Para verificar se há nulo ESPECIFICAMENTE, você usaria isso:

if (variable === null)

Este teste apenas passar para nulle não vai passar para "", undefined, false, 0, ou NaN.

Além disso, forneci verificações absolutas para cada valor "falso" (um que retornaria verdadeiro para !variable).

Observe que, para algumas verificações absolutas, você precisará implementar o uso de absolutely equals: ===e typeof.

Eu criei um JSFiddle aqui para mostrar todos os testes individuais funcionando

Aqui está a saída de cada verificação:

Null Test:

if (variable === null)

- variable = ""; (false) typeof variable = string

- variable = null; (true) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Empty String Test:

if (variable === '')

- variable = ''; (true) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number




Undefined Test:

if (typeof variable == "undefined")

-- or --

if (variable === undefined)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (true) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



False Test:

if (variable === false)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (true) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (false) typeof variable = number



Zero Test:

if (variable === 0)

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (true) typeof variable = number

- variable = NaN; (false) typeof variable = number



NaN Test:

if (typeof variable == 'number' && !parseFloat(variable) && variable !== 0)

-- or --

if (isNaN(variable))

- variable = ''; (false) typeof variable = string

- variable = null; (false) typeof variable = object

- variable = undefined; (false) typeof variable = undefined

- variable = false; (false) typeof variable = boolean

- variable = 0; (false) typeof variable = number

- variable = NaN; (true) typeof variable = number

Como você pode ver, é um pouco mais difícil testar NaN;

WebWanderer
fonte
9
Qual é o objetivo da verificação de tipo se você usa ===igualdade estrita? Obrigado. Também para o teste NaN, você pode usar isNaN(value)isso retornará trueapenas se a variável for igual a NaN.
Michael Malinovskij
16
Existe um caso em que, variable === nullmas não é do tipo "objeto"? Se não houver, por que não simplificar a verificação variable === null, jogando fora o segundo conjunto? Obrigado.
Hunan Rostomyan
7
@ HununRostomyan Boa pergunta, e sinceramente, não, eu não acho que exista. Você provavelmente está seguro o suficiente usando o variable === nullque acabei de testar aqui neste JSFiddle . A razão pela qual eu também usei `&& typeof variable === 'object' 'não foi apenas para ilustrar o fato interessante de que um nullvalor é um typeof object, mas também para acompanhar o fluxo das outras verificações. Mas sim, em conclusão, você pode usar com segurança variable === null.
WebWanderer
1
jsfiddle.net/neoaptt/avt1cgem/1 Aqui está esta resposta dividida em funções. Não é muito útil, mas eu fiz de qualquer maneira.
Neoaptt 18/04
1
Eu vou fazer algo que quase nunca é uma boa idéia: altere o código nesta resposta. Especificamente, remova o teste totalmente desnecessário para o tipo de objeto, ao verificar se há nulo. Este é um trecho de código fundamental : não é uma boa idéia que um único iniciante aprenda mal que eles precisam fazer esse teste detalhado.
Home
59

basta substituir o ==com ===em todos os lugares.

== é uma comparação de igualdade livre ou abstrata

=== é uma comparação estrita da igualdade

Veja o artigo da MDN sobre comparações de igualdade e igualdade para obter mais detalhes.

ic3b3rg
fonte
2
Isso só funciona se você considerar undefinedque não null. Caso contrário, isso levará a um comportamento inesperado. Geralmente, se você estiver interessado em ambos null/ undefinedmas os valores não Falsas, então use ==(um dos poucos casos em que você deve fazê-lo).
Andrew Mao
2
@AndrewMao undefined não é null : stackoverflow.com/a/5076962/753237
ic3b3rg
2
Acredito que é o que @AndrewMao estava dizendo, realmente. Sua primeira frase pode ser reescrita "Isso só funciona em situações em que indefinido e nulo não são equivalentes práticos".
BobRodes
1
@BobRodes Obrigado por esclarecer a minha escrita pobre, eu aprecio isso :)
Andrew Mao
@AndrewMao De nada. E eu não consideraria sua escrita pobre, pessoalmente; Eu diria que é muito melhor que a média. :)
BobRodes
30

Operador de igualdade estrita: -

Podemos verificar nulo por ===

if ( value === null ){

}

Apenas usando if

if( value ) {

}

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

  • nulo
  • Indefinido
  • NaN
  • sequência vazia ("")
  • falso
  • 0 0
Arshid KV
fonte
9

Aprimoramento sobre a resposta aceita verificando explicitamente, nullmas com uma sintaxe simplificada:

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
}

// Test
let pass=1, cpass=1, email=1, cemail=1, user=1; // just to test

if ([pass, cpass, email, cemail, user].every(x=>x!==null)) {
    // your code here ...
    console.log ("Yayy! None of them are null");
} else {
    console.log ("Oops! At-lease one of them is null");
}

deekshith
fonte
6

Primeiro, você tem uma declaração de retorno sem um corpo de função. As chances são de que isso gerará um erro.

Uma maneira mais limpa de fazer sua verificação seria simplesmente usar o! operador:

if (!pass || !cpass || !email || !cemail || !user) {

    alert("fill all columns");

}
Joey C.
fonte
12
Esse código é, provavelmente, em uma função, ele simplesmente não mostrá-lo;)
Mark Kahn
4

você pode usar tentar pegar finalmente

 try {
     document.getElementById("mydiv").innerHTML = 'Success' //assuming "mydiv" is undefined
 } catch (e) {

     if (e.name.toString() == "TypeError") //evals to true in this case
     //do something

 } finally {}   

você também pode ter throwseus próprios erros. Veja isso .

DrStrangeLove
fonte
1
Eu acho que isso se qualifica como código "paranóico". se você realmente escreveu algo assim, seria entendendo que "mydiv" não poderia existir. não devemos alcançar esse código a menos que estejamos confiantes, e teremos muitos caminhos, como códigos de resposta, para garantir que estamos confiantes antes de tentar essa linha.
Calql8edkos
Não use try and catch para fluxo de controle. Esta não é uma boa solução.
Andrew S
4

Em JavaScript, nenhuma string é igual a null.

Talvez você esperasse pass == nullser verdadeiro quando passhouver uma sequência vazia, porque você sabe que o operador de igualdade frouxa ==executa certos tipos de coerção de tipo.

Por exemplo, esta expressão é verdadeira:

'' == 0

Por outro lado, o operador de igualdade estrita ===diz que isso é falso:

'' === 0

Dado que ''e 0são fracamente iguais, você pode razoavelmente conjeturar isso ''e nullsão fracamente iguais. No entanto, eles não são.

Esta expressão é falsa:

'' == null

O resultado da comparação de qualquer cadeia de caracteres nullé falso. Portanto, pass == nulle todos os seus outros testes são sempre falsos, e o usuário nunca recebe o alerta.

Para corrigir seu código, compare cada valor com a sequência vazia:

pass === ''

Se você tiver certeza de que passé uma sequência, pass == ''também funcionará porque apenas uma sequência vazia é fracamente igual à sequência vazia. Por outro lado, alguns especialistas dizem que é uma boa prática sempre usar igualdade estrita no JavaScript, a menos que você queira especificamente fazer a coerção de tipo que o operador de igualdade frouxa executa.

Se você deseja saber quais pares de valores são fracamente iguais, consulte a tabela "Comparações de similaridade" no artigo da Mozilla sobre este tópico .

Michael Laszlo
fonte
4

para verificar indefinido e nulo em javascript, basta escrever o seguinte:

if (!var) {
        console.log("var IS null or undefined");
} else {
        console.log("var is NOT null or undefined");
}
Nejmeddine Jammeli
fonte
6
! var é verdadeiro com 0, "", NaN e falso também.
Matt
3

Este é um comentário sobre a solução do WebWanderer sobre a verificação de NaN (ainda não tenho representante suficiente para deixar um comentário formal). A solução lê como

if(!parseInt(variable) && variable != 0 && typeof variable === "number")

mas isso falhará em números racionais que arredondariam para 0 , como variable = 0.1. Um teste melhor seria:

if(isNaN(variable) && typeof variable === "number")
Gabriel
fonte
1
Obrigado por apontar o bug Gabriel, eu coloquei a correção na minha resposta. Além disso, fui capaz de corrigir o teste mudando parseIntpara parseFloat (o que deveria ter sido óbvio para mim em primeiro lugar). Evitei usar a isNanfunção porque sinto que muitos desenvolvedores veem funções isNaNcomo algum tipo de "caixa mágica" em que os valores entram e os booleanos saem, e eu queria testar um pouco mais a fundo. Mas sim, seu teste sugerido funcionará e é perfeitamente adequado para uso. Desculpe, não notei sua postagem até agora.
WebWanderer
1
Ótimo, isso parece funcionar. Obrigado pelo comentário sobre por que você também evitou isNaN, posso ficar por trás dessa lógica. Há também o método Underscore.js, que parece ainda mais confuso / blackbox, mas vale a pena notar de qualquer maneira, porque tira proveito NaN !== NaN. Object.prototype.toString.call(variable) === '[object Number]' && variable !== +variable
Gabriel
2

Na verdade, acho que você pode precisar usar, if (value !== null || value !== undefined) porque se você if (value)também pode filtrar 0 ou valores falsos.

Considere estas duas funções:

const firstTest = value => {
    if (value) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}
const secondTest = value => {
    if (value !== null && value !== undefined) {
        console.log('passed');
    } else {
        console.log('failed');
    }
}

firstTest(0);            // result: failed
secondTest(0);           // result: passed

firstTest(false);        // result: failed
secondTest(false);       // result: passed

firstTest('');           // result: failed
secondTest('');          // result: passed

firstTest(null);         // result: failed
secondTest(null);        // result: failed

firstTest(undefined);    // result: failed
secondTest(undefined);   // result: failed

Na minha situação, eu só precisava para verificar se o valor for nulo e indefinido e eu não queria filtro 0ou falseou ''valores. então usei o segundo teste, mas talvez seja necessário filtrá-los, o que pode fazer com que você use o primeiro teste.

Naeem Baghi
fonte
1

Eu encontrei uma outra maneira de testar se o valor é nulo:

if(variable >= 0 && typeof variable === "object")

nullatua como numbere objectao mesmo tempo. Comparando null >= 0ou null <= 0resultando em true. Comparar null === 0ou null > 0ou null < 0resultará em falso. Mas como nulltambém é um objeto, podemos detectá-lo como um nulo.

Eu criei uma função mais complexa, a natureza de bruxa fará melhor do que typeof e pode ser dito quais tipos incluir ou manter agrupados

/* function natureof(variable, [included types])
included types are 
    null - null will result in "undefined" or if included, will result in "null"
    NaN - NaN will result in "undefined" or if included, will result in "NaN"
    -infinity - will separate negative -Inifity from "Infinity"
    number - will split number into "int" or "double"
    array - will separate "array" from "object"
    empty - empty "string" will result in "empty" or
    empty=undefined - empty "string" will result in "undefined"
*/
function natureof(v, ...types){
/*null*/            if(v === null) return types.includes('null') ? "null" : "undefined";
/*NaN*/             if(typeof v == "number") return (isNaN(v)) ? types.includes('NaN') ? "NaN" : "undefined" : 
/*-infinity*/       (v+1 === v) ? (types.includes('-infinity') && v === Number.NEGATIVE_INFINITY) ? "-infinity" : "infinity" : 
/*number*/          (types.includes('number')) ? (Number.isInteger(v)) ? "int" : "double" : "number";
/*array*/           if(typeof v == "object") return (types.includes('array') && Array.isArray(v)) ? "array" : "object";
/*empty*/           if(typeof v == "string") return (v == "") ? types.includes('empty') ? "empty" : 
/*empty=undefined*/ types.includes('empty=undefined') ? "undefined" : "string" : "string";
                    else return typeof v
}

// DEMO
let types = [null, "", "string", undefined, NaN, Infinity, -Infinity, false, "false", true, "true", 0, 1, -1, 0.1, "test", {var:1}, [1,2], {0: 1, 1: 2, length: 2}]

for(i in types){
console.log("natureof ", types[i], " = ", natureof(types[i], "null", "NaN", "-infinity", "number", "array", "empty=undefined")) 
}

Tarmo Saluste
fonte
1

Eu fiz essa função muito simples que faz maravilhas:

function safeOrZero(route) {
  try {
    Function(`return (${route})`)();
  } catch (error) {
    return 0;
  }
  return Function(`return (${route})`)();
}

A rota é qualquer cadeia de valores que possa explodir. Eu uso para jQuery / cheerio e objetos e tal.

Exemplos 1: um objeto simples como este const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};.

Mas poderia ser um objeto muito grande que nem sequer fizemos. Então eu passo por:

let value1 = testobj.items[2].val;  // "hum!"
let value2 = testobj.items[3].val;  // Uncaught TypeError: Cannot read property 'val' of undefined

let svalue1 = safeOrZero(`testobj.items[2].val`)  // "hum!"
let svalue2 = safeOrZero(`testobj.items[3].val`)  // 0

Claro que se você preferir, pode usar nullou 'No value'... Qualquer que seja a sua necessidade.

Geralmente, uma consulta DOM ou um seletor de jQuery pode gerar um erro se não for encontrado. Mas usando algo como:

const bookLink = safeOrZero($('span.guidebook > a')[0].href);
if(bookLink){
  [...]
}
Carles Alcolea
fonte
1

Você pode usar o módulo lodash para verificar se o valor é nulo ou indefinido

_.isNil(value)
Example 

 country= "Abc"
    _.isNil(country)
    //false

   state= null
    _.isNil(state)
    //true

city= undefined
    _.isNil(state)
    //true

   pin= true
    _.isNil(pin)
    // false   

Link de referência: https://lodash.com/docs/#isNil

Ashita.gupta
fonte
0

Isso não funcionará no caso de valores booleanos provenientes do DB para ex:

 value = false

 if(!value) {
   // it will change all false values to not available
   return "not available"
 }
Codiee
fonte
0

AFAIK em JAVASCRIPT quando uma variável é declarada, mas não possui valor atribuído, seu tipo é undefined. para que possamos verificar a variável, mesmo que isso ocorra em objectalguma instância no lugar do valor .

crie um método auxiliar para verificar a nulidade que retorna truee use-a na sua API.

função auxiliar para verificar se a variável está vazia:

function isEmpty(item){
    if(item){
        return false;
    }else{
        return true;
    }
}

chamada excepcional à API do try-catch:

try {

    var pass, cpass, email, cemail, user; // only declared but contains nothing.

    // parametrs checking
    if(isEmpty(pass) || isEmpty(cpass) || isEmpty(email) || isEmpty(cemail) || isEmpty(user)){
        console.log("One or More of these parameter contains no vlaue. [pass] and-or [cpass] and-or [email] and-or [cemail] and-or [user]");
    }else{
        // do stuff
    }

} catch (e) {
    if (e instanceof ReferenceError) {
        console.log(e.message); // debugging purpose
        return true;
    } else {
        console.log(e.message); // debugging purpose
        return true;
    }
}

alguns casos de teste:

var item = ""; // isEmpty? true
var item = " "; // isEmpty? false
var item; // isEmpty? true
var item = 0; // isEmpty? true
var item = 1; // isEmpty? false
var item = "AAAAA"; // isEmpty? false
var item = NaN; // isEmpty? true
var item = null; // isEmpty? true
var item = undefined; // isEmpty? true

console.log("isEmpty? "+isEmpty(item));
Kaleem Ullah
fonte
1
O que? Esta resposta não tem nada a ver com este post. Você postou esta resposta neste tópico por acidente?
WebWanderer 02/11/2015
Essa isEmptyfunção se comporta exatamente como !. Não há necessidade de inventar uma função. Apenas faça if (!pass || !cpass || !email ...). (O que já é mostrado na resposta aceita.) E pelo comentário do WebWanderer, a parte do meio desta postagem, "try-catch excepcional API call", não parece ser relevante para esta pergunta. Por favor, explique sua intenção - quando isso é útil? Como isso se relaciona com a pergunta?
Home
0

Verificando condições de erro:

// Typical API response data
let data = {
  status: true,
  user: [],
  total: 0,
  activity: {sports: 1}
}

// A flag that checks whether all conditions were met or not
var passed = true;

// Boolean check
if (data['status'] === undefined || data['status'] == false){
  console.log("Undefined / no `status` data");
  passed = false;
}

// Array/dict check
if (data['user'] === undefined || !data['user'].length){
  console.log("Undefined / no `user` data");
  passed = false;
}

// Checking a key in a dictionary
if (data['activity'] === undefined || data['activity']['time'] === undefined){
   console.log("Undefined / no `time` data");
   passed = false;
}

// Other values check
if (data['total'] === undefined || !data['total']){
  console.log("Undefined / no `total` data");
  passed = false;
}

// Passed all tests?
if (passed){
  console.log("Passed all tests");
}
PS
fonte
-1

Tente o seguinte:

if (!variable && typeof variable === "object") {
    // variable is null
}
user5520516
fonte
null é a única coisa que é "falsy" e typeof retorna "object".
user5520516
2
Como isso é melhor que if (variable === null)? Também alguém já forneceu essa resposta no ano passado: stackoverflow.com/a/27550756/218196 .
Felix Kling #