提问



检查JavaScript中的对象属性是否未定义的最佳方法是什么?

最佳参考


使用:


if (typeof something === "undefined") {
    alert("something is undefined");
}


如果具有某些属性的对象变量可以使用如下所示的相同内容:


if (typeof my_obj.someproperties === "undefined"){
    console.log('the property is not available...'); // print into console
}





由于ECMAScript 5,undefined不能被覆盖,所以my_obj === undefined也可以,但只有my_obj存在。这可能是也可能不需要,因为如果你需要这个语义,你可以使用null(请参阅JavaScript中的null和undefined之间有什么区别?)。但是对于对象属性,无论属性是否存在,它都可以工作。​​]]

其它参考1


我相信这个话题有很多不正确的答案。与普遍看法相反,未定义在JavaScript中是关键字,实际上可以为其分配值。


正确代码



执行此测试的最强大方法是:


if (typeof myVar === "undefined")


这将始终返回正确的结果,甚至可以处理未声明myVar的情况。


退化代码。不要使用。



var undefined = false;  // Shockingly, this is completely legal!
if (myVar === undefined) {
    alert("You have been misled. Run away!");
}


另外,myVar === undefined会在myVar未声明的情况下引发错误。

其它参考2


在JavaScript中有 null ,并且未定义。它们有不同的含义。



  • undefined 表示尚未定义变量值;不知道它的价值是什么。

  • null 表示定义变量值并设置为null(没有值)。



Marijn Haverbeke在他的免费在线书Eloquent JavaScript(强调我的)中说:[184]



  还有一个类似的值null,其含义是此值已定义,但它没有值。 undefined和null之间的意义差异主要是学术性的,通常不是很有趣。 在实际程序中,通常需要检查某些东西是否有价值。在这些情况下,可以使用表达式== undefined,因为即使它们不是完全相同的值,null == undefined也会生成true。



所以,我想检查某些内容是否未定义的最佳方法是:


if (something == undefined)


希望这可以帮助!


 为了响应您的编辑,对象属性应该以相同的方式工作。


var person = {
    name: "John",
    age: 28,
    sex: "male"
};

alert(person.name); // "John"
alert(person.fakeVariable); // undefined

其它参考3


尽管这里的许多其他答案都强烈推荐,typeof 是一个糟糕的选择。它永远不应该用于检查变量是否具有值undefined,因为它作为值undefined的组合检查以及变量是否存在。在绝大多数情况下,你知道变量何时存在,而typeof只会在变量名或字符串文字'undefined'中输入错误时引入静默失败的可能性。


var snapshot = …;

if (typeof snaposhot === 'undefined') {
    //         ^
    // misspelled¹ – this will never run, but it won’t throw an error!
}




var foo = …;

if (typeof foo === 'undefned') {
    //                   ^
    // misspelled – this will never run, but it won’t throw an error!
}


因此,除非您正在进行特征检测²,否则给定名称是否在范围内(例如将typeof module !== 'undefined'作为特定于CommonJS环境的代码中的步骤进行检查存在不确定性),typeof是一个有害的选择。用于变量,正确的选项是直接比较值:


var foo = …;

if (foo === undefined) {
    ⋮
}


一些常见的误解包括:



  • 读取未初始化变量(var foo)或参数(function bar(foo) { … },称为bar())将失败。这根本不是真的 - 没有显式初始化的变量和未给定值的参数总是变为undefined,并且始终在范围内。

  • 可以覆盖undefined。这还有很多。 undefined不是JavaScript中的关键字。相反,它是具有Undefined值的全局对象上的属性。但是,自ES5以来,此属性一直是只读和不可配置。没有现代浏览器允许更改undefined属性,并且截至2017年,这已经是很长时间了。缺乏严格模式也不会影响undefined的行为 - 它只会使undefined = 5这样的语句不做任何事情而不是抛出。但是,由于它不是关键字,您可以使用名称undefined 声明变量,并且可以更改这些变量,从而产生这种曾经常见的模式:


    (function (undefined) {
        // …
    })()
    


    更多比使用全局undefined更危险。如果必须与ES3兼容,请将undefined替换为void 0 - 不要诉诸typeof。 (void一直是一元运算符,它计算任何操作数的Undefined值。)



通过变量如何解决问题,是时候解决实际问题了:对象属性。没有理由将typeof用于对象属性。关于特征检测的早期例外在这里不适用 - typeof仅对变量有特殊行为,而引用对象属性的表达式不是变量。


这个:


if (typeof foo.bar === 'undefined') {
    ⋮
}


是总是完全等同到这个³:


if (foo.bar === undefined) {
    ⋮
}


并考虑上面的建议,以避免让读者混淆你为什么使用typeof,因为使用===检查相等性是最有意义的,因为它可以重构为检查一个变量的值稍后,因为它只是看起来更好,你应该总是使用=== undefined³


在涉及对象属性时要考虑的其他事项是你是否真的想要检查undefined。一个给定的属性名称可以在一个对象上不存在(在读取时产生值undefined,在对象本身上以值undefined存在,在对象的原型上以值undefined出现,或出现在任何具有非undefined值的人中。 'key' in obj会告诉你一个键是否在对象原型链的任何地方,并且Object.prototype.hasOwnProperty.call(obj, 'key')会告诉你它是否直接在对象上。我不会在这个关于原型和使用对象作为字符串键映射的答案中详细说明,因为它主要是为了对抗其他答案中的所有不良建议,而不管原始问题的可能解释如何。在MDN上阅读对象原型以获取更多信息![185]


¹异常选择示例变量名称?这是来自Firefox的NoScript扩展的真正死代码。

不过,²并不认为不知道范围内的内容是否正常。滥用动态范围引起的奖金漏洞:Project Zero 1225

³再次假设一个ES5 +环境,undefined引用全局对象的undefined属性。替代void 0否则。 [186]

其它参考4


这是什么意思:未定义的对象属性?


实际上它可能意味着两件完全不同的东西!首先,它可能意味着对象中从未定义过的属性,其次,它可能意味着具有未定义值的属性。我们来看看这段代码:


var o = { a: undefined }


o.a未定义?是!它的价值是不确定的。是o.b未定义?当然!根本没有属性b!好的,现在看看两种情况下不同方法的表现如何:


typeof o.a == 'undefined' // true
typeof o.b == 'undefined' // true
o.a === undefined // true
o.b === undefined // true
'a' in o // true
'b' in o // false


我们可以清楚地看到typeof obj.prop == 'undefined'obj.prop === undefined是等价的,它们并没有区分这些不同的情况。并且'prop' in obj可以检测到某个属性根本没有定义并且没有注意可能未定义的属性值时的情况。


那该怎么办?



1)您想知道属性是否由第一个或第二个含义(最典型的情况)定义。


obj.prop === undefined // IMHO, see "final fight" below


2)你想知道对象是否有某些属性而不关心它的价值。


'prop' in obj


说明:




  • 您无法同时检查对象及其属性。例如,如果未定义x,此x.a === undefined或此typeof x.a == 'undefined'会引发ReferenceError: x is not defined

  • 变量undefined是一个全局变量(实际上它在浏览器中是window.undefined)。它自ECMAScript第1版以来一直受到支持,自ECMAScript 5以来它只有只读。因此,在现代浏览器中,它不能被重新定义为真正的,因为许多作者都喜欢吓唬我们,但对于旧浏览器来说,这仍然是正确的。



最后的战斗:obj.prop === undefined vs typeof obj.prop == 'undefined'



obj.prop === undefined:



  • 它有点短,看起来更漂亮

  • 如果拼写错误undefined
  • ,JavaScript引擎会给您一个错误


obj.prop === undefined的缺点:



  • undefined可以在旧浏览器中重写



typeof obj.prop == 'undefined':



  • 真的很普遍!它适用于新旧浏览器。



typeof obj.prop == 'undefined'的缺点:



  • 'undefned'(拼写错误)这里只是一个字符串常量,所以如果你像我刚才那样拼错了它,JavaScript引擎就无法帮助你。



更新(对于服务器端JavaScript):



Node.js支持全局变量undefinedglobal.undefined(它也可以在没有全局前缀的情况下使用)。我不知道服务器端JavaScript的其他实现。

其它参考5


问题可归结为三种情况:



  1. 该对象具有该属性,其值不是undefined

  2. 对象具有属性,其值为undefined

  3. 该对象没有该属性。



这告诉我们一些我认为重要的事情:


未定义的成员与具有未定义值的已定义成员之间存在差异。


但不幸的是typeof obj.foo没有告诉我们我们有三种情况中的哪一种。但是我们可以将它与"foo" in obj结合起来区分这些情况。


                               |  typeof obj.x === 'undefined' | !("x" in obj)
1.                     { x:1 } |  false                        | false
2.    { x : (function(){})() } |  true                         | false
3.                          {} |  true                         | true


值得注意的是,null条目的这些测试也是相同的


                               |  typeof obj.x === 'undefined' | !("x" in obj)
                    { x:null } |  false                        | false


我认为在某些情况下检查属性是否存在更有意义(并且更清楚),而不是检查它是否未定义,并且唯一的情况是这种检查将是不同的是案例2,罕见的情况是具有未定义值的对象中的实际条目。


例如:我刚刚重构了一堆代码,这些代码检查了对象是否具有给定属性。


if( typeof blob.x != 'undefined' ) {  fn(blob.x); }


在没有检查未定义的情况下编写时更清楚。


if( "x" in blob ) { fn(blob.x); }


但正如已经提到的,这些并不完全相同(但对我的需求来说已经足够好了)。

其它参考6


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


这对我有用,而其他人没有。

其它参考7


我不确定在typeof中使用===的起源来自哪里,作为一种惯例,我看到它在许多库中使用,但是typeof运算符返回一个字符串文字,我们知道了前面,那你为什么还要打字检查呢?


typeof x;                      // some string literal "string", "object", "undefined"
if (typeof x === "string") {   // === is redundant because we already know typeof returns a string literal
if (typeof x == "string") {    // sufficient

其它参考8


从相关问题中删除我的答案如何在JavaScript中检查未定义?


特定于此问题,请参阅someObject.<whatever>。的测试用例





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


(请注意,在in测试中使用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

其它参考9


我没有看到(希望我没有错过)任何人在房产前检查对象。所以,这是最短和最有效的(虽然不一定是最清楚的):


if (obj && obj.prop) {
  // Do something;
}


如果obj或obj.prop未定义,null或falsy,则if语句将不执行代码块。这通常是在大多数代码块语句中(在JavaScript中)所需的行为。

其它参考10


如果你这样做


if (myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}


当变量myvar不存在时它会失败,因为没有定义myvar,所以脚本被破坏而且测试没有效果。


由于窗口对象在函数外部具有全局范围(默认对象),因此声明将附加到窗口对象。


例如:


var myvar = 'test';


全局变量 myvar 与 window.myvar 或 window [[myvar]] 相同


为避免在存在全局变量时测试错误,最好使用:


if(window.myvar == undefined )
{ 
    alert('var does not exists or is not initialized');
}


变量确实存在的问题并不重要,它的值是不正确的。否则,使用undefined初始化变量是愚蠢的,最好使用值false来初始化。当你知道你声明的所有变量都被初始化时如果是false,你可以简单地检查它的类型或依靠!window.myvar来检查它是否具有正确/有效的值。所以即使没有定义变量,!window.myvar也是相同的myvar = undefined]]或myvar = falsemyvar = 0


当您需要特定类型时,请测试变量的类型。为了加快测试条件,您最好:


if( !window.myvar || typeof window.myvar != 'string' )
{
    alert('var does not exists or is not type of string');
}


当第一个和简单条件为真时,解释器会跳过下一个测试。


最好使用变量的实例/对象来检查它是否具有有效值。它更稳定,是一种更好的编程方式。


(y)的

其它参考11


在文章探索JavaScript中的Null和Undefined的深渊中我读到像Underscore.js这样的框架使用这个函数:[190] [191]


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

其它参考12


if(window.x){} 是错误安全的



你很可能想要if (window.x)。即使x未被声明(var x;),此检查也是安全的 - 浏览器不会抛出错误。


示例:我想知道我的浏览器是否支持History API



if (window.history) {
    history.call_some_function();
}


如何运作:



window 是一个将所有全局变量保存为其成员的对象,尝试访问不存在的成员是合法的。如果 x 尚未声明或未设置,则window.x将返回未定义。当 if()对其进行评估时, undefined 会导致 false

其它参考13


读到这一点,我很惊讶我没有看到这个。我发现了多种适用于此的算法。


从未定义



如果从未定义对象的值,则如果定义为nullundefined,则将阻止返回true。如果您希望为设置为undefined的值返回true,这将非常有用


if(obj.prop === void 0) console.log("The value has never been defined");


定义为未定义或永不定义



如果您希望它以undefined的结果为undefined的值定义,或者从未定义的值,您只需使用=== undefined


if(obj.prop === undefined) console.log("The value is defined as undefined, or never defined");


定义为假值,未定义,空或永不定义。



通常,人们要求我提供一种算法,以确定某个值是否为假,undefinednull。以下作品。


if(obj.prop == false || obj.prop === null || obj.prop === undefined) {
    console.log("The value is falsy, null, or undefined");
}

其它参考14


"propertyName" in obj //-> true | false

其它参考15


您可以使用以下代码获取一个未定义路径的数组。


 function getAllUndefined(object) {

        function convertPath(arr, key) {
            var path = "";
            for (var i = 1; i < arr.length; i++) {

                path += arr[i] + "->";
            }
            path += key;
            return path;
        }


        var stack = [];
        var saveUndefined= [];
        function getUndefiend(obj, key) {

            var t = typeof obj;
            switch (t) {
                case "object":
                    if (t === null) {
                        return false;
                    }
                    break;
                case "string":
                case "number":
                case "boolean":
                case "null":
                    return false;
                default:
                    return true;
            }
            stack.push(key);
            for (k in obj) {
                if (obj.hasOwnProperty(k)) {
                    v = getUndefiend(obj[k], k);
                    if (v) {
                        saveUndefined.push(convertPath(stack, k));
                    }
                }
            }
            stack.pop();

        }

        getUndefiend({
            "": object
        }, "");
        return saveUndefined;
    }


jsFiddle链接[192]

其它参考16


void 0比较,简洁。


if (foo !== void 0)


它不像if (typeof foo !== 'undefined')那么冗长

其它参考17


解决方案不正确。在JavaScript中,


null == undefined


将返回true,因为它们都被转换为布尔值并且为false。正确的方法是检查


if (something === undefined)


这是身份运营商......

其它参考18


这是我的情况:


我正在使用REST调用的结果。
结果应该从JSON解析为JavaScript对象。


我需要保护一个错误。
如果用户指定args错误,其余调用的args是不正确的,则其余的调用基本上是空的。


虽然使用这篇文章来帮助我防范这个,但我尝试了这个。


if( typeof restResult.data[0] === "undefined" ) { throw  "Some error"; }


对于我的情况,如果restResult.data

其它参考19

===对象,那么我可以安全地开始检查其余的成员。如果未定义,则抛出上述错误。


我所说的是,就我的情况而言,本文上面的所有建议都没有用。我不是说我是对的,每个人都错了。我根本不是JavaScript大师,但希望这会对某人有所帮助。

其它参考20


有一个很好的&如果已定义属性,则将已定义属性分配给新变量,或者如果未定义,则将默认值指定为后备。


var a = obj.prop || defaultValue;


如果你有一个函数,它接收一个额外的配置属性是合适的:


var yourFunction = function(config){

   this.config = config || {};
   this.yourConfigValue = config.yourConfigValue || 1;
   console.log(this.yourConfigValue);

}


正在执行


yourFunction({yourConfigValue:2});
//=> 2

yourFunction();
//=> 1

yourFunction({otherProperty:5});
//=> 1

其它参考21


function isUnset(inp) {
  return (typeof inp === 'undefined')
}


如果设置了变量,则返回false;如果未定义,则返回true。


然后使用:


if (isUnset(var)) {
  // initialize variable here
}

其它参考22


所有答案都不完整。这是知道存在定义为未定义的属性的正确方法:


var hasUndefinedProperty = function hasUndefinedProperty(obj, prop){
  return ((prop in obj) && (typeof obj[prop] == 'undefined')) ;
} ;


例:


var a = { b : 1, e : null } ;
a.c = a.d ;

hasUndefinedProperty(a, 'b') ; // false : b is defined as 1
hasUndefinedProperty(a, 'c') ; // true : c is defined as undefined
hasUndefinedProperty(a, 'd') ; // false : d is undefined
hasUndefinedProperty(a, 'e') ; // false : e is defined as null

// And now...
delete a.c ;
hasUndefinedProperty(a, 'c') ; // false : c is undefined


太糟糕了,这是正确的答案被埋没在错误的答案中> _<


所以,对于任何经过的人,我都会免费给你undefined!


var undefined ; undefined ; // undefined
({}).a ;                    // undefined
[].a ;                      // undefined
''.a ;                      // undefined
(function(){}()) ;          // undefined
void(0) ;                   // undefined
eval() ;                    // undefined
1..a ;                      // undefined
/a/.a ;                     // undefined
(true).a ;                  // undefined

其它参考23


通过注释,对于那些想要检查它们的人来说,它是未定义的或其值为null:


//Just in JavaScript
var s; // Undefined
if (typeof s == "undefined" || s === null){
    alert('either it is undefined or value is null')
}


如果您使用的是jQuery Library,那么jQuery.isEmptyObject()就足以满足这两种情况,


var s; // Undefined
jQuery.isEmptyObject(s); // Will return true;

s = null; // Defined as null
jQuery.isEmptyObject(s); // Will return true;

//Usage
if (jQuery.isEmptyObject(s)) {
    alert('Either variable:s is undefined or its value is null');
} else {
     alert('variable:s has value ' + s);
}

s = 'something'; // Defined with some value
jQuery.isEmptyObject(s); // Will return false;

其它参考24


如果您使用的是Angular:


angular.isUndefined(obj)
angular.isUndefined(obj.prop)


Underscore.js:


_.isUndefined(obj) 
_.isUndefined(obj.prop) 

其它参考25


我使用if (this.variable)来测试它是否已定义。上面推荐的简单if (variable)对我来说失败了。事实证明,它仅在变量是某个对象的字段时起作用,obj.someField检查它是否在字典中定义。但我们可以使用thiswindow作为字典对象,因为任何变量都是当前窗口中的字段,据我所知。因此这是一个测试




if (this.abc) alert("defined"); else alert("undefined");

abc = "abc";
if (this.abc) alert("defined"); else alert("undefined");



只是在JavaScript中没有定义任何东西,未定义,如果它是Object/Array中的属性或仅仅是一个简单的变量并不重要......


JavaScript typeof使得检测未定义的变量非常容易。


只需检查typeof whatever === 'undefined'是否会返回布尔值。


这就是AngularJs v.1x中着名函数isUndefined()的写法:


function isUndefined(value) {return typeof value === 'undefined';} 


因此,当您看到函数接收到一个值时,如果定义了该值,它将返回false,否则对于未定义的值,返回true


因此,让我们看看当我们传递值时会产生什么结果,包括下面的对象属性,这是我们拥有的变量列表:


var stackoverflow = {};
stackoverflow.javascipt = 'javascript';
var today;
var self = this;
var num = 8;
var list = [1, 2, 3, 4, 5];
var y = null;


我们检查它们如下,你可以看到它们前面的结果作为评论:


isUndefined(stackoverflow); //false
isUndefined(stackoverflow.javascipt); //false
isUndefined(today); //true
isUndefined(self); //false
isUndefined(num); //false
isUndefined(list); //false
isUndefined(y); //false
isUndefined(stackoverflow.java); //true
isUndefined(stackoverflow.php); //true
isUndefined(stackoverflow && stackoverflow.css); //true


如你所见,我们可以在我们的代码中使用类似的东西来检查任何内容,如上所述,您可以在代码中使用typeof,但如果您反复使用它,请创建一个类似我分享的角度样本的函数并继续重用如下面的DRY代码模式。


还有一件事,为了检查实际应用程序中的对象的属性,你甚至不确定对象是否存在,检查对象是否存在。


如果检查对象上的属性并且该对象不存在,将抛出错误并停止整个应用程序运行。


isUndefined(x.css);
VM808:2 Uncaught ReferenceError: x is not defined(…)


如此简单,你可以在if语句中包装如下:


if(typeof x !== 'undefined') {
  //do something
}


这也等于Angular 1.x中的isDefined ...


function isDefined(value) {return typeof value !== 'undefined';}


另外其他javascript框架如下划线也有类似的定义检查,但我建议你使用typeof如果你还没有使用任何框架。


我还从MDN添加了这一部分,其中包含有关typeof,undefined和void(0)的有用信息。



  严格的相等和未定义
您可以使用undefined和严格的相等和不等式运算符来确定变量是否具有
  一个值。在下面的代码中,未定义变量x和
  if语句的计算结果为true。



var x;
if (x === undefined) {
   // these statements execute
}
else {
   // these statements do not execute
}



  注意:严格的相等运算符而不是标准的相等
  必须在这里使用运算符,因为x == undefined也会检查是否
  x为null,而严格相等不是t。null不等于
  未定义。请参阅比较运算符了解详细







   Typeof运算符和undefined

  或者,可以使用typeof:



var x;
if (typeof x === 'undefined') {
   // these statements execute
}



  使用typeof的一个原因是它不会抛出错误
  变量尚未声明。



// x has not been declared before
if (typeof x === 'undefined') { // evaluates to true without errors
   // these statements execute
}

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

}



  但是,应该避免这种技术。 JavaScript是一个
  静态范围的语言,因此知道是否声明了变量
  通过查看它是否在封闭的上下文中声明来阅读。该
  唯一的例外是全局范围,但全局范围是必然的
  全局对象,所以检查变量的存在
  全局上下文可以通过检查属性的存在来完成
  全局对象(例如,使用in运算符)。







  的沃伊d运算符和未定义

  
  void操作符是第三种选择。



var x;
if (x === void 0) {
   // these statements execute
}

// y has not been declared before
if (y === void 0) {
   // throws a ReferenceError (in contrast to `typeof`)
}


更多>这里[194]

其它参考26


同样的事情可以写得更短:


if (!variable){
    //do it if variable is Undefined
}


要么


if (variable){
    //do it if variable is Defined
}

其它参考27


我想向您展示我为了保护undefined变量而使用的东西:


Object.defineProperty(window, 'undefined', {});


这禁止任何人更改window.undefined值,因此会根据该变量销毁代码。如果使用"use strict",任何试图更改其值的内容都将以错误结束,否则将被忽略。

其它参考28


使用:


检查属性是否未定义:


if (typeof something === "undefined") {
    alert("undefined");
}


检查属性是否未定义:


if (typeof something !== "undefined") {
    alert("not undefined");
}

其它参考29


来自lodash.js。


var undefined;
function isUndefined(value) {
  return value === undefined;
}


它创建一个名为undefined的变量,用默认值初始化 - 真实undefined,然后将value与变量undefined进行比较。