Fatal编程技术网
  • javascript/
  • 我怎样才能查到；“未定义”；用JavaScript？

我怎样才能查到；“未定义”；用JavaScript？

javascript

我怎样才能查到；“未定义”；用JavaScript？,javascript,undefined,Javascript,Undefined,如果JavaScript中未定义变量，最合适的测试方法是什么 我已经看到了几种可能的方法： if (window.myVariable) 或 或 您可以使用typeof，如下所示： if (typeof something != "undefined") { // ... } 如果未定义，它将不等于包含字符“未定义”的字符串，因为该字符串未定义 您可以检查变量的类型： if (typeof(something) != "undefined") ... 有时你甚至不需要检查类型。如果

如果JavaScript中未定义变量，最合适的测试方法是什么

我已经看到了几种可能的方法：

if (window.myVariable)
或

或

您可以使用
typeof
，如下所示：

if (typeof something != "undefined") {
    // ...
}
如果未定义，它将不等于包含字符“未定义”的字符串，因为该字符串未定义

您可以检查变量的类型：

if (typeof(something) != "undefined") ...
有时你甚至不需要检查类型。如果变量的值在设置时不能计算为false（例如，如果它是一个函数），那么您可以只计算变量的值。例如：

if (something) {
  something(param);
}
请注意，在这种情况下，不需要进行严格比较（
！==
），因为
typeof
将始终返回字符串。

如果您有兴趣了解变量是否已声明，而不管其值如何，那么使用
中的
运算符是最安全的方法。考虑这个例子：


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


但在某些情况下，这可能不是预期的结果，因为变量或属性已声明但尚未初始化。使用
中的
操作符进行更稳健的检查


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


如果您想知道变量是否尚未声明或是否具有值
未定义
，请使用
typeof
运算符，该运算符保证返回字符串：


if (typeof myVar !== 'undefined')


与
未定义的
直接比较很麻烦，因为
未定义的
可能会被覆盖


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


正如@CMS指出的，这已经在ECMAScript第5版中进行了修补，
undefined
是不可写的


if（window.myVar）
也将包含这些falsy值，因此它不是很健壮：

false
0
""
NaN
null
undefined
另一种情况是定义了变量，但有一个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?
}



我使用它作为函数参数，并在函数执行时排除它，这样我就得到了未定义的“实”值。尽管它确实要求您将代码放入函数中。我在阅读jQuery源代码时发现了这一点


undefined = 2;

(function (undefined) {
   console.log(undefined); // prints out undefined
   // and for comparison:
   if (undeclaredvar === undefined) console.log("it works!")
})()



当然，您可以只使用
typeof
。但我的所有代码通常都在一个包含函数中，因此使用此方法可能会在这里或那里为我节省一些字节。
2020更新

我之所以选择
类型的
检查（即
未定义的
可以重新定义）与ECMAScript 5的大量采用无关。另一个，您可以使用
typeof
来检查未声明变量的类型，始终是利基。因此，我现在建议在大多数情况下使用直接比较：


myVariable === undefined


2010年的原始答案

使用
typeof
是我的首选。与使用
=
或
==
运算符进行比较或使用
if
进行类型强制不同，当变量从未声明时，它将工作。（
undefined
，与
null
不同，也可能在ECMAScript 3环境中重新定义，这使得比较不可靠，尽管现在几乎所有常见环境都符合ECMAScript 5或更高版本）

我个人使用


myVar === undefined


警告：请注意，
==
在
=
上使用，
myVar
先前已声明（未定义）



我不喜欢myVar的
类型==“未定义”
。我认为这是长篇大论，没有必要的。（我可以用更少的代码完成同样的工作。）

现在，一些人读到这篇文章时会痛苦得晕头转向，尖叫着：“等等！WAAITTT！！！
未定义
可以重新定义！”

酷。我知道这一点。同样，Javascript中的大多数变量都可以重新定义。是否永远不要使用任何可以重新定义的内置标识符

如果你遵守这条规则，对你有好处：你不是一个伪君子

问题是，为了在JS中完成大量的实际工作，开发人员需要依赖可重新定义的标识符。我没有听到有人告诉我不应该使用
setTimeout
，因为有人可以


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


底线是，“它可以被重新定义”参数不使用原始的
===未定义的
是假的

（如果您仍然害怕
未定义的
被重新定义，为什么要盲目地将未经测试的库代码集成到代码库中？或者更简单：一个linting工具。）



此外，与
typeof
方法一样，该技术可以“检测”未声明的变量：


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


但这两种技术都在抽象中泄漏。我劝你不要用这个，甚至


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


考虑：


var iAmUndefined;


要捕获该变量是否已声明，您可能需要求助于
中的
。（在许多情况下，您可以简单地阅读代码O_O）


但是等等！还有更多！如果某个原型链魔法正在发生呢…？现在，即使是
操作符中的上级
也不能满足要求。（好的，关于这一部分我已经讲完了，除了说99%的时间，
==undefined
（和****cough****
typeof
）都很好。如果你真的在意，你可以自己阅读这个主题。）
既然没有其他答案对我有帮助，我建议这样做。它在InternetExplorer8中对我起了作用：


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



说明各种答案结果的一些场景：


（请注意，在
测试中对
使用
var
在作用域包装中会产生不同）

参考代码：


(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



与@Thomas的回答相反：

如果我忘记在我的代码中声明
myVar
，那么我将得到
myVar未定义

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

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

那么@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.");


更新2018-07-25
这篇文章发表已经将近五年了，JavaScript已经取得了长足的进步。在重复原始帖子中的测试时，我发现没有一致的dif

var iAmUndefined;



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



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



(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



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



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



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



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



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



x === undefined 



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



    var x;
    if (x === undefined) {
        alert ("I am declared, but not defined.")
    };
    if (typeof y === "undefined") {
        alert ("I am not even declared.")
    };

    /* One more thing to understand: typeof ==='undefined' also checks 
       for if a variable is declared, but no value is assigned. In other 
       words, the variable is declared, but not defined. */

    // Will repeat above logic of x for typeof === 'undefined'
    if (x === undefined) {
        alert ("I am declared, but not defined.")
    };
    /* So typeof === 'undefined' works for both, but x === undefined 
       only works for a variable which is at least declared. */

    /* Say if I try using typeof === undefined (not in quotes) for 
       a variable which is not even declared, we will get run a 
       time error. */

    if (z === undefined) {
        alert ("I am neither declared nor defined.")
    };
    // I got this error for z ReferenceError: z is not defined 



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

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

}