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

您可以使用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

你可以使用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 {}   

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

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

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有点困难；

试试看：

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

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

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

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

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

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?.();