如何在JavaScript中检查"undefined"？

Question

在JavaScript中测试变量是否未定义的最合适方法是什么？我见过几种可能的方法:

if (window.myVariable)

要么

if (typeof(myVariable) != "undefined")

要么

if (myVariable) //This throws an error if undefined. Should this be in Try/Catch?

Answer 1

如果您想知道变量是否已被声明而不管其值如何,那么使用in运算符是最安全的方法.考虑这个例子.

// global scope
var theFu; // theFu has been declared, but its value is undefined
typeof theFu; // "undefined"

但这可能不是某些情况下的预期结果,因为变量或属性已声明但尚未初始化.使用in运算符进行更稳健的检查.

"theFu" in window; // true
"theFoo" in window; // false

如果您有兴趣知道变量是否尚未声明或具有该值undefined,则使用typeof运算符.

if (typeof myVar !== 'undefined')

该typeof操作是保证返回一个字符串.直接比较undefined是undefined可以覆盖的麻烦.

window.undefined = "omg";
"omg" == undefined // true

正如@CMS指出的那样,这已在ECMAScript第5版中修补,并且undefined是不可写的.

if (window.myVar) 还将包括这些虚假值,因此它不是很强大:

false
0
""
NaN
null
undefined

感谢@CMS指出你的第三种情况 - if (myVariable)在两种情况下也会抛出错误.第一个是没有定义抛出a的变量ReferenceError.

// abc was never declared.
if (abc) {
    // ReferenceError: abc is not defined
} 

另一种情况是定义了变量,但是有一个getter函数,在调用时抛出一个错误.例如,

// or it's a property that can throw an error
Object.defineProperty(window, "myVariable", { 
    get: function() { throw new Error("W00t?"); }, 
    set: undefined 
});
if (myVariable) {
    // Error: W00t?
}

Answer 2

我个人用

myVar === undefined

警告:请注意,它已被===使用==并且myVar之前已声明(未定义).

我不喜欢typeof myVar === "undefined".我认为这是漫长的啰嗦和不必要的.(我可以用更少的代码完成相同的工作.)

现在有些人在阅读时会痛苦地说话,尖叫道:"等等!WAAITTT !!! undefined可以重新定义!"

凉.我知道这个.然后,Javascript中的大多数变量都可以重新定义.你永远不应该使用任何可以重新定义的内置标识符吗？

如果你遵循这条规则,对你有好处:你不是伪君子.

问题是,为了在JS中进行大量实际工作,开发人员需要依赖可重定义的标识符来实现它们.我没有听到有人告诉我我不应该使用,setTimeout因为有人可以

window.setTimeout = function () {
    alert("Got you now!");
};

最重要的是,"可以重新定义"的论点是不使用原始=== undefined是假的.

(如果您仍然害怕undefined被重新定义,为什么要盲目地将未经测试的库代码集成到您的代码库中？甚至更简单:一个linting工具.)

此外,与该typeof方法一样,此技术可以"检测"未声明的变量:

if (window.someVar === undefined) {
    doSomething();
}

但这两种技术都在其抽象中泄漏.我劝你不要使用这个甚至是

if (typeof myVar !== "undefined") {
    doSomething();
}

考虑:

var iAmUndefined;

要捕获是否声明了该变量,您可能需要求助于in运算符.(在许多情况下,您只需阅读代码O_o).

if ("myVar" in window) {
    doSomething();
}

可是等等!还有更多!如果发生一些原型链魔术怎么办？现在即使是优秀的in运营商也不够.(好吧,我在这里完成了这个部分,除了说99%的时间,=== undefined(和****咳嗽****typeof)工作得很好.如果你真的在乎,你可以阅读这个主题它自己的.)

Answer 3

使用typeof是我的偏好.当从未声明变量时它将起作用,这与使用==或===运算符或类型强制使用的任何比较不同if.(undefined不同的是null,也可能在ECMAScript 3环境中重新定义,使其不可靠进行比较,尽管现在几乎所有常见环境都符合ECMAScript 5或更高版本).

if (typeof someUndeclaredVariable == "undefined") {
    // Works
}

if (someUndeclaredVariable === undefined) { 
    // Throws an error
}

Answer 4

你需要使用typeof.

if (typeof something != "undefined") {
    // ...
}

Answer 5

更新2018-07-25

自这篇文章首次发布至今已近五年,JavaScript已经走过了漫长的道路.在重复原始帖子中的测试时,我发现以下测试方法之间没有一致的差异:

• abc === undefined
• abc === void 0
• typeof abc == 'undefined'
• typeof abc === 'undefined'

即使我修改测试以防止Chrome优化它们,差异也是微不足道的.因此,我现在建议abc === undefined清楚.

相关内容来自chrome://version:

• 谷歌浏览器:67.0.3396.99(官方构建)(64位)(群组:稳定)
• 修订:a337fbf3c2ab8ebc6b64b0bfdce73a20e2e2252b-refs/branch-heads/3396 @ {#790}
• 操作系统:Windows
• JavaScript:V8 6.7.288.46
• 用户代理:Mozilla/5.0(Windows NT 10.0; Win64; x64)AppleWebKit/537.36(KHTML,与Gecko一样)Chrome/67.0.3396.99 Safari/537.36

原帖2013-11-01

在谷歌浏览器中,以下内容比typeof测试快一点:

if (abc === void 0) {
    // Undefined
}

差异可以忽略不计.但是,这段代码更加简洁,一目了然,知道具体void 0意义的人更清楚.但请注意,abc仍必须声明.

双方typeof并void比对直接比较显著更快undefined.我在Chrome开发者控制台中使用了以下测试格式:

var abc;
start = +new Date();
for (var i = 0; i < 10000000; i++) {
    if (TEST) {
        void 1;
    }
}
end = +new Date();
end - start;

结果如下:

Test: | abc === undefined      abc === void 0      typeof abc == 'undefined'
------+---------------------------------------------------------------------
x10M  |     13678 ms               9854 ms                 9888 ms
  x1  |    1367.8 ns              985.4 ns                988.8 ns

请注意,第一行以毫秒为单位,而第二行以纳秒为单位.相差3.4纳秒是没有的.在随后的测试中,时间非常一致.

Answer 6

如果未定义,则它将不等于包含字符"undefined"的字符串,因为字符串未定义.

您可以检查变量的类型:

if (typeof(something) != "undefined") ...

有时您甚至不必检查类型.如果变量的值在设置时无法求值为false(例如,如果它是函数),那么您可以只评估变量.例:

if (something) {
  something(param);
}

Answer 7

if (typeof foo == 'undefined') {
 // Do something
};

请注意,!==在这种情况下不需要strict comparison(),因为它typeof总是返回一个字符串.

Answer 8

一些场景说明了各种答案的结果:http: //jsfiddle.net/drzaus/UVjM4/

(请注意,在作用域包装器中使用varfor in测试会有所不同)

代码:

(function(undefined) {
    var definedButNotInitialized;
    definedAndInitialized = 3;
    someObject = {
        firstProp: "1"
        , secondProp: false
        // , undefinedProp not defined
    }
    // var notDefined;

    var tests = [
        'definedButNotInitialized in window',
        'definedAndInitialized in window',
        'someObject.firstProp in window',
        'someObject.secondProp in window',
        'someObject.undefinedProp in window',
        'notDefined in window',

        '"definedButNotInitialized" in window',
        '"definedAndInitialized" in window',
        '"someObject.firstProp" in window',
        '"someObject.secondProp" in window',
        '"someObject.undefinedProp" in window',
        '"notDefined" in window',

        'typeof definedButNotInitialized == "undefined"',
        'typeof definedButNotInitialized === typeof undefined',
        'definedButNotInitialized === undefined',
        '! definedButNotInitialized',
        '!! definedButNotInitialized',

        'typeof definedAndInitialized == "undefined"',
        'typeof definedAndInitialized === typeof undefined',
        'definedAndInitialized === undefined',
        '! definedAndInitialized',
        '!! definedAndInitialized',

        'typeof someObject.firstProp == "undefined"',
        'typeof someObject.firstProp === typeof undefined',
        'someObject.firstProp === undefined',
        '! someObject.firstProp',
        '!! someObject.firstProp',

        'typeof someObject.secondProp == "undefined"',
        'typeof someObject.secondProp === typeof undefined',
        'someObject.secondProp === undefined',
        '! someObject.secondProp',
        '!! someObject.secondProp',

        'typeof someObject.undefinedProp == "undefined"',
        'typeof someObject.undefinedProp === typeof undefined',
        'someObject.undefinedProp === undefined',
        '! someObject.undefinedProp',
        '!! someObject.undefinedProp',

        'typeof notDefined == "undefined"',
        'typeof notDefined === typeof undefined',
        'notDefined === undefined',
        '! notDefined',
        '!! notDefined'
    ];

    var output = document.getElementById('results');
    var result = '';
    for(var t in tests) {
        if( !tests.hasOwnProperty(t) ) continue; // bleh

        try {
            result = eval(tests[t]);
        } catch(ex) {
            result = 'Exception--' + ex;
        }
        console.log(tests[t], result);
        output.innerHTML += "\n" + tests[t] + ": " + result;
    }
})();

结果:

definedButNotInitialized in window: true
definedAndInitialized in window: false
someObject.firstProp in window: false
someObject.secondProp in window: false
someObject.undefinedProp in window: true
notDefined in window: Exception--ReferenceError: notDefined is not defined
"definedButNotInitialized" in window: false
"definedAndInitialized" in window: true
"someObject.firstProp" in window: false
"someObject.secondProp" in window: false
"someObject.undefinedProp" in window: false
"notDefined" in window: false
typeof definedButNotInitialized == "undefined": true
typeof definedButNotInitialized === typeof undefined: true
definedButNotInitialized === undefined: true
! definedButNotInitialized: true
!! definedButNotInitialized: false
typeof definedAndInitialized == "undefined": false
typeof definedAndInitialized === typeof undefined: false
definedAndInitialized === undefined: false
! definedAndInitialized: false
!! definedAndInitialized: true
typeof someObject.firstProp == "undefined": false
typeof someObject.firstProp === typeof undefined: false
someObject.firstProp === undefined: false
! someObject.firstProp: false
!! someObject.firstProp: true
typeof someObject.secondProp == "undefined": false
typeof someObject.secondProp === typeof undefined: false
someObject.secondProp === undefined: false
! someObject.secondProp: true
!! someObject.secondProp: false
typeof someObject.undefinedProp == "undefined": true
typeof someObject.undefinedProp === typeof undefined: true
someObject.undefinedProp === undefined: true
! someObject.undefinedProp: true
!! someObject.undefinedProp: false
typeof notDefined == "undefined": true
typeof notDefined === typeof undefined: true
notDefined === undefined: Exception--ReferenceError: notDefined is not defined
! notDefined: Exception--ReferenceError: notDefined is not defined
!! notDefined: Exception--ReferenceError: notDefined is not defined

Answer 9

在本文中,我读到像Underscore.js这样的框架使用这个函数:

function isUndefined(obj){
    return obj === void 0;
}

Answer 10

就个人而言,我总是使用以下内容:

var x;
if( x === undefined) {
    //Do something here
}
else {
   //Do something else here
}

window.undefined属性在所有现代浏览器(JavaScript 1.8.5或更高版本)中都是不可写的.从Mozilla的文档:https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/undefined,我看到:使用typeof()的一个原因是它不会抛出错误变量尚未定义.

我更喜欢使用的方法

x === undefined 

因为如果之前没有声明x,它会失败并在我的脸上爆炸,而不是默默地传递/失败.这提醒我x未声明.我相信应该声明JavaScript中使用的所有变量.

Answer 11

我知道检查的最可靠的方法undefined是使用void 0.

这与较新的和较旧的浏览器兼容,window.undefined在某些情况下不能像can 一样被覆盖.

if( myVar === void 0){
    //yup it's undefined
}

Answer 12

// x has not been defined before
if (typeof x === 'undefined') { // Evaluates to true without errors.
   // These statements execute.
}

if (x === undefined) { // Throws a ReferenceError

}

Answer 13

由于没有其他答案对我有帮助，我建议您这样做。它在Internet Explorer 8中对我有用：

if (typeof variable_name.value === 'undefined') {
    // variable_name is undefined
}

Answer 14

与@Thomas Eding 的回答相反：

myVar如果我忘记在代码中声明，那么我会得到myVar is not defined.

让我们举一个真实的例子：

我有一个变量名，但我不确定它是否在某处声明。

那么@Anurag 的回答将会有所帮助：

var myVariableToCheck = 'myVar';
if (window[myVariableToCheck] === undefined)
    console.log("Not declared or declared, but undefined.");

// Or you can check it directly 
if (window['myVar'] === undefined) 
    console.log("Not declared or declared, but undefined.");