如何在 JavaScript 中检查未定义或 null 变量？

Question

我们经常在 JavaScript 代码中使用以下代码模式

if (typeof(some_variable) != 'undefined' && some_variable != null)
{
    // Do something with some_variable
}

是否有一种不太冗长的检查方法可以达到相同的效果？

根据一些论坛和文献的说法，简单来说以下应该具有相同的效果。

if (some_variable)
{
    // Do something with some_variable
}

不幸的是，Firebug 在 some_variable< 时将此类语句评估为运行时错误/code> 未定义，而第一个就可以了。这只是 Firebug 的（不需要的）行为还是这两种方式之间确实有一些区别？

Answer 1

我认为测试“value is null or undefined”的最有效方法是

if ( some_variable == null ){
  // some_variable is either null or undefined
}

所以这两行是等效的：

if ( typeof(some_variable) !== "undefined" && some_variable !== null ) {}
if ( some_variable != null ) {}

Note 1

正如中提到的问题是，短变体要求已声明 some_variable ，否则将引发 ReferenceError 。然而，在许多用例中，您可以假设这是安全的：

检查可选参数：

function(foo){
    if( foo == null ) {...}

检查现有对象的属性

if(my_obj.foo == null) {...}

另一方面，typeof 可以处理未声明的全局变量（简单地返回undefined ）。然而，正如阿尔森德所解释的那样，这些案例应该减少到最低限度，这是有充分理由的。

注释 2

这个 - 甚至更短 - 变体不等效：

if ( !some_variable ) {
  // some_variable is either null, undefined, 0, NaN, false, or an empty string
}

所以

if ( some_variable ) {
  // we don't get here if some_variable is null, undefined, 0, NaN, false, or ""
}

注释 3

一般来说，建议使用 ===< /code> 而不是 ==。
所提出的解决方案是该规则的一个例外。为此，JSHint 语法检查器 甚至提供了 eqnull 选项。

来自 jQuery 样式指南：

应该使用严格的相等检查（===）来支持 ==。唯一的
异常是通过 null 检查 undefined 和 null 时。

// Check for both undefined and null values, for some important reason. 
undefOrNull == null;

编辑 2021-03：

现在大多数浏览器
支持空值合并运算符 (??)
和 逻辑 nullish 赋值 (??=) ，它允许更简洁的方式
如果变量为 null 或未定义，则分配默认值，例如：

if (a.speed == null) {
  // Set default if null or undefined
  a.speed = 42;
}

可以写为以下任何形式

a.speed ??= 42;
a.speed ?? a.speed = 42;
a.speed = a.speed ?? 42;

Answer 2

您必须区分不同情况：

1. 变量可以是未定义或未声明。如果您在 typeof 之外的任何上下文中访问未声明的变量，您将会收到错误。

if(typeof someUndeclaredVar == whatever) // works
if(someUndeclaredVar) // throws error

已声明但未初始化的变量是未定义。

let foo;
if (foo) //evaluates to false because foo === undefined

2. 未定义的属性，例如someExistingObj.someUndefProperty。未定义的属性不会产生错误，只会返回 undefined，当转换为布尔值时，其计算结果为 false。所以，如果你不关心
   0 和 false，使用 if(obj.undefProp) 就可以了。基于这个事实有一个常见的习语：

   value = obj.prop ||默认值
   

   这意味着“如果obj具有属性prop，则将其分配给value，否则分配默认值defaultValue”。

   有些人认为这种行为令人困惑，认为它会导致难以发现的错误，并建议使用 in 运算符代替

   value = ('prop' in obj) ? obj.prop : 默认值
   

Answer 3

使用正常相等检查 null 也将针对未定义返回 true。

if (window.variable == null)alert('变量为 null 或未定义');

Answer 4

这是唯一应使用 == 和 != 的情况：

if (val == null) console.log('val is null or undefined')

if (val != null) console.log('val is neither null nor undefined')

对于任何其他比较，严格比较器（=== 和应使用 !==)。

• https://developer.mozilla.org/en-US/docs/Web /JavaScript/Equality_comparisons_and_sameness
• https://2ality.com/2011/12 /strict-equality-exemptions.html

Answer 5

在像 ES5 和 ES6 这样的新 JavaScript 标准中，你可以直接说

> Boolean(0) //false
> Boolean(null)  //false
> Boolean(undefined) //false

all return false，这类似于 Python 对空变量的检查。
因此，如果您想围绕变量编写条件逻辑，只需

if (Boolean(myvar)){
   // Do something
}

在这里说“null”或“空字符串”或“未定义”即可有效处理。

Answer 6

如果您尝试引用未声明的变量，则所有 JavaScript 实现都会抛出错误。

对象的属性不受相同条件的约束。如果尚未定义对象属性，则尝试访问它时不会抛出错误。因此，在这种情况下，您可以缩短：

 if (typeof(myObj.some_property) != "undefined" && myObj.some_property != null)

考虑到

if (myObj.some_property != null)

这一点，并且全局变量可以作为全局对象的属性进行访问（在浏览器中为 window），您可以使用以下内容对于全局变量：

if (window.some_variable != null) {
    // Do something with some_variable
}

在局部作用域中，确保在代码块的顶部声明变量总是有用的，这将节省 typeof 的重复使用。

Answer 7

首先你必须非常清楚你测试的内容。 JavaScript 具有各种隐式转换，以及两种不同类型的相等比较器：== 和 ===。

测试 null 或 undefined 的函数 test(val) 应该具有以下特征：

 test(null)         => true
 test(undefined)    => true
 test(0)            => false
 test(1)            => false
 test(true)         => false
 test(false)        => false
 test('s')          => false
 test([])           => false

让我们看看这里的哪些想法实际上通过了我们的测试。测试。

这些有效：

val == null
val === null || val === undefined
typeof(val) == 'undefined' || val == null
typeof(val) === 'undefined' || val === null

这些无效：

typeof(val) === 'undefined'
!!val

我创建了一个 jsperf 条目来比较这些方法的正确性和性能。目前结果尚无定论，因为在不同浏览器/平台上的运行还不够。请花一点时间在您的计算机上运行测试！

目前看来，简单的 val == null 测试给出了最好的性能。它也是最短的。如果您想要补码，则可以将测试否定为 val != null。

Answer 8

这是使用数组的另一种方法 includes() 方法：

[undefined, null].includes(value)

Answer 9

由于没有一个完整且正确的答案，我将尝试总结：

一般来说，表达式：

if (typeof(variable) != "undefined" && variable != null)

无法简化，因为 variable 可能未声明，因此省略 typeof(variable) ！ =“未定义”将导致ReferenceError。但是，您可以根据上下文简化表达式：

如果变量是全局，您可以简化为：

if (window.variable != null)

如果它是 local，你或许可以避免该变量未声明的情况，并且还可以简化为：

if (variable != null)

如果是对象属性，则不必担心ReferenceError：

if (obj.property != null)

Answer 10

这也是一种很好的（但很冗长）的方式：

if((someObject.someMember ?? null) === null) {
  // bladiebla
}

发生的事情非常清楚并且很难误解。这非常重要！ :-)

这使用 ?? 运算符 (https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Nullish_coalescing_operator）。如果 someObject.someMember 的值为 null 或 undefined，则 ?? 运算符将启动并生成值null。

说实话，我喜欢这个东西的明确性，但我通常更喜欢 someObject.someMember == null，它更具可读性，熟练的 JS 开发人员可能知道这里发生了什么。

Answer 11

这是一个极少数情况下的示例，建议使用 == 而不是 ===。表达式 somevar == null 将为 undefined 和 null 返回 true，但对于其他所有内容返回 false（如果变量未声明，则返回错误）。

使用 != 将翻转结果，如预期的那样。

现代编辑器不会对使用 == 或 != 运算符与 null 发出警告，因为这几乎总是所需的行为。

最常见的比较：

undeffinedVar == null     // true
obj.undefinedProp == null // true
null == null              // true
0 == null                 // false
'0' == null               // false
'' == null                // false

自己尝试一下：

let undefinedVar;
console.table([
    { test : undefinedVar,     result: undefinedVar     == null },
    { test : {}.undefinedProp, result: {}.undefinedProp == null },
    { test : null,             result: null             == null },
    { test : false,            result: false            == null },
    { test : 0,                result: 0                == null },
    { test : '',               result: ''               == null },
    { test : '0',              result: '0'              == null },
]);

Answer 12

您只需检查变量是否有值即可。意思是，

if( myVariable ) {
//mayVariable is not :
//null
//undefined
//NaN
//empty string ("")
//0
//false

}

如果您不知道变量是否存在（这意味着它是否已声明），您应该使用 typeof 运算符进行检查。例如

if( typeof myVariable !== 'undefined' ) {
    // myVariable will get resolved and it is defined
}

Answer 13

与您所拥有的类似，您可以执行类似

if (some_variable === undefined || some_variable === null) { 的 操作
做事
}

Answer 14

无论 yyy 未定义或为 null，它都会返回 true

if (typeof yyy == 'undefined' || !yyy) {
    console.log('yes');
} else {
    console.log('no');
}

yes

if (!(typeof yyy == 'undefined' || !yyy)) {
    console.log('yes');
} else {
    console.log('no');
}

no

Answer 15

在浏览器中打开开发者工具，然后尝试下图所示的代码。

Answer 16

如果 if 语句的目的是在为变量赋值之前检查 null 或 undefined 值，则可以使用 空值合并运算符。根据 caniuse 的数据，应该有大约 85% 的浏览器支持（截至 2021 年 1 月）。该运算符的示例如下所示：

const a = some_variable ?? '';

如果 some_variable 为 null 或 ，这将确保将变量分配给空字符串（或任何其他默认值） >未定义。

此运算符最适合您的用例，因为它不会返回其他类型的假值（例如 0 和 ''）的默认值。

Answer 17

您可以检查该值是否存在。

if(value){
    // True Condition
}else{
// False Condition
}

如果值不是以下值，上面的代码将计算为 true：

1. null
2. undefined
3. NaN
4. 空字符串 ("")
5. 0
6. false

Answer 18

正如其中一个答案中提到的，如果您谈论的是具有全局作用域的变量，那么您可能会很幸运。您可能知道，您全局定义的变量往往会添加到 windows 对象中。您可以利用这一事实，假设您正在访问一个名为 bleh 的变量，只需使用双倒置运算符 (!!)，

!!window['bleh'];

当 bleh 尚未声明并赋值时，这将返回 false。

Answer 19

为了理解，让我们分析一下 Javascript 引擎在转换 undefined 、 null 和 '' （也是一个空字符串）时返回的值是什么。您可以直接在开发者控制台上进行检查。

你可以看到所有都转换为 false ，意味着所有这三个都通过 javascript 假设“不存在”。因此，您无需像下面这样显式检查代码中的所有三个。

if (a === undefined || a === null || a==='') {
    console.log("Nothing");
} else {
    console.log("Something");
}

我还想指出一件事。

Boolean(0) 的结果是什么？

当然是假的。当 0 是预期结果中的有效值时，这会在代码中产生错误。因此，请确保在编写代码时检查这一点。

Answer 20

使用 Ramda，您只需执行 R.isNil(yourValue)
Lodash 和其他辅助库具有相同的功能。

Answer 21

您可以使用 lodash 库。

_.isNil(value) 为 null 和 undefined 提供 true

测试 - https://bazinga.tools/lodash

Answer 22

我已经使用此方法

将 id 保存在某个变量中

var someVariable = document.getElementById("someId");

然后使用 if 条件来完成此操作

if(someVariable === ""){
 //logic
} else if(someVariable !== ""){
 //logic
}

Answer 23

在 ES5 或 ES6 中，如果您需要多次检查，可以这样做：

const excluded = [null, undefined, ''];

if (!exluded.includes(varToCheck) {
  // it will bee not null, not undefined and not void string
}

Answer 24

let varToCheck = ""; //U have to define variable firstly ,or it throw error
const excluded = [null, undefined, ""];

if (!excluded.includes(varToCheck)) {
  // it will bee not null, not undefined and not void string
  console.log("pass");
} else {
  console.log("fail");
}

例如，我复制 vladernn 的答案进行测试，您也可以单击“复制代码片段以回答”按钮来测试。

Answer 25

您可以将以下内容与空合并一起使用

//if statement evaluates to true only for null and undefined falsy values, false for others)

const val = ''; 

if(typeof val !== typeof(val ?? 1)) {
    console.log('Matches only null or undefined');
}else {
    console.log('Any other value');
}

Answer 26

测试无效 (if (value == null)) 或非无效 (if (value != null)) 比测试变量的定义状态更简洁。

此外，如果使用布尔值定义变量（或对象属性），则测试 if (value) （或 if( obj.property)）来确保变量（或对象属性）是否存在会失败false 值。买者自负:)

Answer 27

将 undefined 或 null 或 0 与 ES5 和 ES6 标准进行比较的最佳方式

 if ((Boolean(some_variable_1) && Boolean(some_variable_2)) === false) {
    // do something
    }

Answer 28

您必须定义以下形式的函数：

validate = function(some_variable){
    return(typeof(some_variable) != 'undefined' && some_variable != null)
}

Answer 29

通过使用严格比较运算符可以轻松区分这两个值。

示例代码：

function compare(){
    var a = null; //variable assigned null value
    var b;  // undefined
    if (a === b){
        document.write("a and b have same datatype.");
    }
    else{
        document.write("a and b have different datatype.");
    }   
}