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

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

它将检查空字符串（“”）、null、undefined、false以及数字0和NaN。

请注意，如果您是专门检查数字，则使用此方法错过0是一个常见错误，num！==对于返回-1的函数（例如indexOf），首选0（或num！==-1或~num（同时检查-1的黑客代码））。

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

一个更干净的检查方法是简单地使用！操作员：

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

    alert("fill all columns");

}

你可以使用try-catch finally

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

您也可以抛出自己的错误。看看这个。

只要在所有地方用==替换==即可。

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

==是严格的相等比较

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

要检查空值，请使用以下命令：

if (variable === null)

此测试仅通过null，不通过“”、undefined、false、0或NaN。

此外，我还为每个“类假”值提供了绝对检查（对于！变量返回true）。

注意，对于某些绝对检查，您需要使用绝对等于：==和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有点困难；

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

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

但对于将舍入为0的有理数（例如变量=0.1），这将失败。更好的测试是：

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

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

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

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

当pass为空字符串时，您可能希望pass==null为真，因为您知道松散的相等运算符==执行某些类型的强制。

例如，此表达式为true：

'' == 0

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

'' === 0

假定“”和0大致相等，您可以合理地推测“”和null大致相等。然而，事实并非如此。

此表达式为false：

'' == null

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

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

pass === ''

如果您确定pass是一个字符串，pass==“”也会起作用，因为只有空字符串与空字符串大致相等。另一方面，一些专家表示，在JavaScript中始终使用严格相等是一种好的做法，除非您特别想执行松散相等运算符执行的类型强制。

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

JAVASCRIPT中的AFAIK当变量已声明但未赋值时，其类型未定义。所以我们可以检查变量，即使它是一个持有某个实例代替值的对象。

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

检查变量是否为空的helper函数：

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

试试看：

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

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

 value = false

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

严格相等运算符：-

我们可以通过===

if ( value === null ){

}

仅通过使用if

if( value ) {

}

如果值不是：

无效的未定义NaN公司空字符串（“”）假的0

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

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

//测试let pass=1，cpass=1，email=1，cemail=1，user=1；//只是为了测试if（[pass，cpass，email，cemail，user].every（x=>x！==null））{//你的代码在这里。。。console.log（“Yayy！它们都不是空的”）；}其他{console.log（“哎呀！至少其中一个为空”）；}

实际上，我认为你可能需要使用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和未定义，我不想过滤0、false或“”值。所以我使用了第二个测试，但你可能也需要过滤它们，这可能会导致你使用第一个测试。

我找到了另一种方法来测试该值是否为空：

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

null同时充当数字和对象。比较null>=0或null<=0结果为true。比较null==0或null>0或null<0将导致false。但由于null也是一个对象，我们可以将其检测为null。

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

/*函数性质of（变量，[包含类型]）包括的类型有null-null将导致“未定义”，如果包含，则将导致“null”NaN-NaN将导致“未定义”，或如果包含，将导致“NaN”-infinity-将负-无穷与“无限”分开number-将数字拆分为“int”或“double”array-将“array”与“object”分开空-空的“字符串”将导致“空”或空=未定义-空“字符串”将导致“未定义”*/函数性质of（v，…类型）{/*null*/if（v===null）返回类型。includes（'null'）？“null”：“未定义”；/*NaN*/if（typeof v==“number”）返回（isNaN（v））？类型。包括（'NaN'）？“NaN”：“未定义”：/*-无穷大*/（v+1===v）？（types.includes（'-infinity'）&&v==Number.NEGATIVE_infinity）？“-无限”：“无限”：/*number*/（types.includes（'number'））？（数字.isInteger（v））？“int”：“double”：“number”；/*array*/if（typeof v==“object”）return（types.includes（'array'）&&array.isArray（v））？“array”：“object”；/*空*/if（typeof v==“string”）返回（v==”）？types.includes（“空”）？“空”：/*空=未定义*/types.includes（'empty=未定义'）？“undefined”：“string”：“字符串”；否则返回v的类型}//演示let types=[null，“”，“string”，undefined，NaN，Infinity，-Invinity，false，“false”，true，“true”，0，1，-1，0.1，“test”，｛var:1｝，[1，2]，｛0:1，1:2，长度：2｝]for（i在类型中）{console.log（“natureof”，类型[i]，“=”，natureof（类型[i]”，“null”，“NaN”，“-ninfinity”，“number”，“array”，“empty=undefined”））}

我做了一个非常简单的功能，效果很好：

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

路线是任何一条价值链都会爆炸。我将它用于jQuery/cacherio和对象等。

示例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或“无值”。。。任何适合您需要的。

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

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

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

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

检查错误条件：

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

您可以检查某些值是否为空，如下所示

[pass,cpass,email,cemail,user].some(x=> x===null) 

let pass=1；设cpass=2；让电子邮件=3；let cemail=空；让用户＝5；如果（[pass，cpass，email，cemail，user].some（x=>x==null））{警报（“填充所有列”）；//return false；}

奖金：为什么==比==更清楚（来源）

a==b

a===b

乍一看，这似乎是一个简单的覆盖和严格之间的权衡。

==包含多个值，可以用更少的代码处理更多的场景。==是最严格的，这使得它可以预测。

可预测性总是获胜的，这似乎是一个万能的解决方案。

但这是错误的。尽管==是可预测的，但它并不总是产生可预测的代码，因为它忽略了场景。

const options = { };
if (options.callback !== null) {
  options.callback();      // error --> callback is undefined.
}

通常，==为空检查执行更可预测的工作：

一般来说，null和undefined都意味着同一件事：“缺少了什么”。为了实现可预测性，您需要检查这两个值。然后==null做得很好，因为它正好覆盖了这两个值。（即==null等同于==null&&==未定义）在特殊情况下，您确实需要明确区分null和undefined。在这些情况下，最好使用严格的==未定义或==null。（例如，缺失/忽略/跳过和空/清除/删除之间的区别。）但这很少见。

这不仅是罕见的，也是需要避免的。不能在传统数据库中存储undefined。由于互操作性的原因，在API设计中也不应该依赖未定义的值。但即使你根本不做区分，你也不能假设未定义不会发生。我们周围的人都间接地采取了泛化空/未定义的行为（这就是为什么像这样的问题被封闭为“固执己见”的原因）。

所以，回到你的问题。使用==null没有错。它正是它应该做的。

// FIX 1 --> yes === is very explicit
const options = { };
if (options.callback !== null && 
    options.callback !== undefined) {
  options.callback();
}


// FIX 2 --> but == covers both
const options = { };
if (options.callback != null) {
  options.callback();
}

// FIX 3 --> optional chaining also covers both.
const options = { };
options.callback?.();

与操作员进行可选检查怎么样？

例如：

// check mother for null or undefined and 
// then if mother exist check her children also
// this 100% sure it support and valid in JS today.
// Apart of that C# have almost the same operator using the same way
if (mother?.children) {

}
else {
 // it is null, undefined, etc...

}

空值的简单解决方案：

function isEmpty(value) {
        return (
            value === null || value === undefined || value === '' ||
            (Array.isArray(value) && value.length === 0) ||
            (!(value instanceof Date) && typeof value === 'object' && Object.keys(value).length === 0)
        );
    }

“Object.is（）”方法可用于确定两个值是否相同。因此，您可以使用它来检查对象是否为空。

检查空值

let testA = null; //null
console.log(Object.is(testA, null)); //true //null === null

if(Object.is(testA, null)) {
  console.log("This is a Null Value");
}

Output:
true
This is a Null Value

检查未定义的值

let testB; //undefined
console.log(Object.is(testB, undefined)); //true //undefined === undefined

if(Object.is(testB, undefined)) {
  console.log("This is an undefined Value");
}

Output:
true
This is an undefined Value

如果要同时检查undefined和null，请使用此选项。

let testC; //undefined
console.log(Object.is(testC, undefined)); //true //undefined === undefined
console.log(Object.is(testC, null)); //false //undefined === null

if (Object.is(testC, undefined) || Object.is(testC, null)){
  console.log("The value is either undefined or null");
}

if (!(Object.is(testC, undefined) || Object.is(testC, null))){
  console.log("The value is neither undefined nor null");
}

Output:
true
false
The value is either undefined or null

看看他们：https://onecompiler.com/javascript/3ymdqd34v

Mozilla解释：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is

这是一个非常非人的代码。但有效：

if((pass, cpass, email, cemail, user !== null)){

试试看，帮你找到答案