如何检查JavaScript中的空值？

如何在JavaScript中检查空值？我在下面编写了代码，但是没有用。

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

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

}   

在JavaScript程序中如何找到错误？

Javascript在检查“空”值方面非常灵活。我猜您实际上是在寻找空字符串，在这种情况下，这种简单的代码将起作用：

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

这将检查空字符串（""）， ，，null 以及数字和undefinedfalse0NaN

请注意，如果您专门检查数字，则0使用此方法时常会犯错，对于返回的函数，它num !== 0是首选（num !== -1或~num（或（也针对hack代码-1）））-1，例如indexOf）

检查null 具体你可以使用这样的：

if (variable === null)

本次测试将只通过了null，也不会通过的""，undefined，false，0，或NaN。

此外，我还提供了对每个“假值”值的绝对检查（对于，该值将返回true !variable）。

请注意，对于某些绝对检查，您将需要使用absolutely equals: ===和typeof。

我在这里创建了一个JSFiddle来显示所有单独的测试

这是每个检查的输出：

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

如您所见，要进行测试有点困难NaN；

只需更换==用===在所有地方。

== 是一个松散或抽象的相等比较

=== 是严格的平等比较

有关更多详细信息，请参见MDN上有关“ 平等比较和相同性”的文章。

严格等于运算符：-

我们可以通过检查null ===

if ( value === null ){

}

只需使用 if

if( value ) {

}

如果值不是，将评估为true ：

• 空值
• 未定义
• N
• 空字符串（“”）
• 假
• 0

通过显式检查null但使用简化的语法来改进可接受的答案：

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

首先，您有一个没有函数体的return语句。可能会引发错误。

一种更清洁的检查方法是简单地使用!！操作员：

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

    alert("fill all columns");

}

您可以最终使用try catch

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

您也throw可以自己输入错误。看到这个。

在JavaScript中，没有字符串等于null。

也许您期望pass == null在pass为空字符串时为true，因为您知道松散的相等运算符==会执行某些类型的强制转换。

例如，此表达式为true：

'' == 0

相反，严格相等运算符===说这是错误的：

'' === 0

鉴于''和0大致相等，您可以合理地猜想''和null大致相等。但是，事实并非如此。

此表达式是错误的：

'' == null

将任何字符串与比较的结果null为false。因此，pass == null您的所有其他测试始终为假，并且用户永远不会收到警报。

要修复代码，请将每个值与空字符串进行比较：

pass === ''

如果您确定这pass是一个字符串，那么pass == ''也将起作用，因为只有一个空字符串大致等于该空字符串。另一方面，一些专家说，除非您特别想执行松散相等运算符执行的类型强制，否则始终在JavaScript中始终使用严格相等是一种好习惯。

如果您想知道哪些值对大致相等，请参阅有关此主题的Mozilla文章中的“相似性比较”表。

要检查javascript中的undefined和null，只需编写以下代码：

if (!var) {
        console.log("var IS null or undefined");
} else {
        console.log("var is NOT null or undefined");
}

这是对WebWanderer有关检查NaN的解决方案的评论（我没有足够的代表留下正式评论）。解决方案读为

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

但这对于舍入到的有理数将失败0，例如variable = 0.1。更好的测试是：

if(isNaN(variable) && typeof variable === "number")

实际上，我认为您可能需要使用， if (value !== null || value !== undefined) 因为如果使用，if (value)您可能还会过滤0或false值。

考虑以下两个功能：

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

在我的情况，我只需要检查，如果该值为null和undefined，我不想过滤器0或false或''值。因此我使用了第二项测试，但是您可能也需要过滤它们，这可能会导致您使用第一项测试。

我发现了另一种测试该值是否为null的方法：

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

null同时充当number和object。比较null >= 0或null <= 0结果true。比较null === 0或null > 0或null < 0将导致错误。但是作为null对象，我们也可以将其检测为null。

我做了一个更复杂的函数，natureof会比typeof更好，并且可以被告知要包含或保持分组的类型

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

我做了一个非常简单的功能，使奇迹产生了作用：

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

路线是可以爆炸的任何价值链。我将它用于jQuery / cheerio和对象等。

示例1：一个简单的对象，例如this const testObj = {items: [{ val: 'haya' }, { val: null }, { val: 'hum!' }];};。

但这可能是我们甚至还没有制造的非常大的物体。所以我通过它：

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

当然，如果您愿意，可以使用null或'No value'...随您的需要。

通常，如果找不到DOM查询或jQuery选择器，则可能会引发错误。但是使用类似：

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

您可以使用lodash模块检查值是否为null或未定义

_.isNil(value)
Example 

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

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

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

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

参考链接：https : //lodash.com/docs/#isNil

如果来自DB的布尔值来自ex，则这将不起作用：

 value = false

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

声明变量但未分配值的JAVASCRIPT中的 AFAIK ，其类型为。所以我们可以检查变量，即使这将是一个持有一些实例到位的价值。undefinedobject

创建一个用于检查返回的无效性的辅助方法，true并在您的API中使用它。

帮助程序函数，以检查变量是否为空：

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

尝试捕获异常API调用：

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

一些测试用例：

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

检查错误情况：

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

尝试这个：

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