Como verifico valores nulos em JavaScript?

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?

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)

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;

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.

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

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");
}

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");

}

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 .

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 .

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");
}

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")

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.

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")) 
}

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){
  [...]
}

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

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"
 }

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));

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");
}

Tente o seguinte:

if (!variable && typeof variable === "object") {
    // variable is null
}