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

如果尝试引用未声明的变量，则所有 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

您必须区分以下情况：

1. 变量可以是或未声明。如果您在除 以外的任何上下文中访问未声明的变量，则会出现错误。undefinedtypeof

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

已声明但未初始化的变量为 。undefined

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

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

   value = obj.prop || defaultValue
   

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

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

   value = ('prop' in obj) ? obj.prop : defaultValue
   

我认为测试“值是或”的最有效方法是nullundefined

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

所以这两行是等价的：

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

注1

如问题中所述，短变体要求已声明，否则将抛出 ReferenceError。但是，在许多用例中，您可以假设这是安全的：some_variable

检查可选参数：

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

检查现有对象的属性

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

另一方面可以处理未声明的全局变量（简单地返回）。然而，正如Alsciende所解释的那样，这些情况应该被减少到最低限度，这是有充分理由的。typeofundefined

注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

通常，建议使用代替 . 建议的解决方案是此规则的例外。出于这个原因，JSHint 语法检查器甚至提供了该选项。=====eqnull

在jQuery风格指南中：

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

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

编辑 2021-03：

如今，大多数浏览器都支持 Nullish 合并运算符 （？？） 和逻辑 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;

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

通常，表达式：

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

无法简化，因为 可能是未声明的，因此省略 将导致 ReferenceError。但是，您可以根据上下文简化表达式：variabletypeof(variable) != "undefined"

如果是全局的，则可以简化为：variable

if (window.variable != null)

如果它是局部变量，则可以避免未声明此变量的情况，并简化为：

if (variable != null)

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

if (obj.property != null)

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

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

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

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

 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 == nullval != null

正如其中一个答案中提到的，如果您谈论的是具有全局范围的变量，那么您可能会很幸运。您可能知道，全局定义的变量往往会添加到 Windows 对象中。你可以利用这个事实，所以假设你正在访问一个名为 bleh 的变量，只需使用双反转运算符 （！！）

!!window['bleh'];

这将返回一个 false，而 bleh 尚未声明并分配一个值。

测试空性 （） 或非空性 （） 比测试变量的定义状态要少得多。if (value == null)if (value != null)

此外，如果变量（或对象属性）是用布尔值定义的，则测试（或）以确保变量（或对象属性）的存在会失败。Caveat emptor :)if (value)if( obj.property)false

检查具有正常相等性的 null 也将返回 true for undefined。

if (window.variable == null) alert('variable is null or undefined');

使用严格的比较运算符可以很容易地区分这两个值。

示例代码：

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

在较新的 JavaScript 标准（如 ES5 和 ES6）中，您可以这样说

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

all 返回 false，这类似于 Python 对空变量的检查。 因此，如果你想围绕一个变量编写条件逻辑，只需说

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

在这里，“null”或“空字符串”或“undefined”将被有效地处理。

您可以检查变量是否有值。意义

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
}

无论 yyy 是 undefined 还是 null，它都将返回 true

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

是的

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

不

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

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

你可以看到所有的人都在转换为 false，这意味着这三个都假设 javascript “缺乏存在”。因此，您无需在代码中显式检查所有这三个，如下所示。

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

另外，我还想指出一件事。

Boolean（0） 的结果是什么？

当然是假的。当 0 是预期结果中的有效值时，这将在代码中创建一个 bug。因此，请确保在编写代码时检查这一点。

这是使用 Array includes（） 方法的另一种方法：

[undefined, null].includes(value)

我使用这种方法完成了此操作

将 ID 保存在某个变量中

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

然后使用 if 条件

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

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

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

与你所拥有的类似，你可以做类似的事情

if (some_variable === undefined || some_variable === null) { do stuff }

在 ES5 或 ES6 中，如果您需要多次检查它，您可以执行以下操作：

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

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

使用 Ramda，您可以简单地使 Lodash 和其他辅助库具有相同的功能。R.isNil(yourValue)

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

const a = some_variable ?? '';

这将确保如果为 或 ，则变量将被分配给空字符串（或任何其他默认值）。some_variablenullundefined

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

这是一个非常罕见的情况示例，建议使用代替 .表达式将返回 true for 和 ，但返回 false 对于其他所有内容（如果未声明变量，则出错）。=====somevar == nullundefinednull

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

现代编辑器不会警告使用 或运算符 ，因为这几乎总是所需的行为。==!=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 },
]);

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

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

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

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

正在发生的事情非常清楚，很难误解。这可能非常重要！:-)

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

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

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 的答案复制到测试中，您也可以单击“将片段复制到答案”按钮进行测试。

您可以使用库。lodash

_.isNil(value)为两者和truenullundefined

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

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

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

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

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

如果 value 不是，则上面的代码将计算为 true：

1. 零
2. 定义
3. 南
4. 空字符串 （“”）
5. 0
6. 假