检测未定义的对象属性

问：

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

答1:

huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

检查属性值是否为特殊值 undefined 的常用方法是：

if(o.myProperty === undefined) {
  alert("myProperty value is the special value `undefined`");
}

要检查一个对象是否实际上没有这样的属性，因此当您尝试访问它时默认返回 undefined：

if(!o.hasOwnProperty('myProperty')) {
  alert("myProperty does not exist");
}

要检查与标识符关联的值是否是特殊值 undefined、 或（如果该标识符尚未声明）：

if(typeof myVariable === 'undefined') {
  alert('myVariable is either the special value `undefined`, or it has not been declared');
}

注意：这最后一种方法是引用 未声明 标识符而没有早期错误的唯一方法，这与具有值 undefined 不同。

在 ECMAScript 5 之前的 JavaScript 版本中，全局对象上名为“undefined”的属性是可写的，因此如果不小心重新定义了一个简单的检查 foo === undefined，它可能会出现意外行为。在现代 JavaScript 中，该属性是只读的。

但是，在现代 JavaScript 中，“未定义”不是关键字，因此函数内部的变量可以命名为“未定义”并隐藏全局属性。

如果您担心这种（不太可能的）边缘情况，您可以使用 the void operator 来获取特殊的 undefined 值本身：

if(myVariable === void 0) {
  alert("myVariable is the special value `undefined`");
}

如果某物为空，则它被定义（为空），但您可以结合too检查。上面代码的烦人细节是你不能定义一个函数来检查它，你可以定义这个函数......但是尝试使用它。

@neu-rah 为什么你不能写一个函数？为什么这样的东西不起作用？它似乎对我有用。有没有我不考虑的情况？ jsfiddle.net/djH9N/6

@Zack 您对 isNullorUndefined 的测试没有考虑您调用 isNullOrUndefined(f) 并且 f 未声明的情况（即没有“var f”声明的情况）。

废话，现在有数千票。这是最糟糕的方法。我希望路人看到这条评论并决定检查……咳咳……其他答案。

您现在可以使用 obj !== undefined。 undefined 过去是可变的，例如 undefined = 1234 会导致有趣的结果。但是在 Ecmascript 5 之后，它不再可写了，所以我们可以使用更简单的版本。 codereadability.com/how-to-check-for-undefined-in-javascript

答2:

huntsbot.com精选全球7大洲远程工作机会，涵盖各领域，帮助想要远程工作的数字游民们能更精准、更高效的找到对方。

我相信这个话题有很多不正确的答案。与普遍看法相反，“未定义”不是 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 未声明的情况下引发错误。

除了 Marks 评论，我没有得到这个：“myVar === undefined 将在 myVar 未声明的情况下引发错误。” - 为什么这很糟糕？如果我引用未声明的变量，为什么我不想出现错误？

另请记住，您始终可以执行 void 0 来获取 undefined 指向的值。所以你可以做if (myVar === void 0)。 0 并不特殊，您可以在其中放置任何表达式。

在现代浏览器（FF4+、IE9+、Chrome 未知）中，无法再修改 undefined。 MDN: undefined

这个答案也是不正确的。问题是关于未定义的对象属性，而不是未定义的变量。有显着差异。例如，做 if (obj.field === undefined) 是完全合理的。我认为有人做var undefined = false;的风险被高估了。如果您想防止因糟糕的编程而导致的所有此类副作用，您将不得不进行不合理的防御性编程。

有趣的是，人们建议使用这些愚蠢且容易出错的 hack 来避免遮蔽 undefined（这只能由糟糕的开发人员完成），但他们却乐于使用其他可能也被遮蔽的全局标识符。奇怪。很奇怪。

答3:

保持自己快人一步,享受全网独家提供的一站式外包任务、远程工作、创意产品订阅服务–huntsbot.com

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

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）或参数（函数 bar(foo) { … }，称为 bar()）将失败。这根本不是真的——没有显式初始化的变量和没有给定值的参数总是变得未定义，并且总是在范围内。

那个未定义的可以被覆盖。确实 undefined 不是关键字，但它是只读且不可配置的。尽管有非关键字状态（Object、Math、NaN……），但您可能无法避免使用其他内置函数，而且实用代码通常不是在积极的恶意环境中编写的，因此这不是一个很好的理由担心未定义。 （但如果您正在编写代码生成器，请随意使用 void 0。）

了解变量的工作方式之后，是时候解决实际问题了：对象属性。没有理由将 typeof 用于对象属性。前面关于特征检测的例外在这里不适用——typeof 仅对变量有特殊行为，引用对象属性的表达式不是变量。

这个：

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

总是完全等价于 this³：

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

并考虑到上面的建议，以避免让读者对您使用 typeof 的原因感到困惑，因为使用 === 来检查相等性是最有意义的，因为以后可以将其重构为检查变量的值，并且因为它看起来更好，您也应该始终在此处使用 === undefined³。

当涉及到对象属性时，需要考虑的另一件事是您是否真的要检查 undefined。给定的属性名称可以在对象上不存在（读取时产生值 undefined），以值 undefined 出现在对象本身上，以值 undefined 出现在对象的原型上，或者出现在任何一个上具有非 undefined 值的那些。 ‘key’ in obj 将告诉您键是否位于对象原型链上的任何位置，Object.prototype.hasOwnProperty.call(obj, ‘key’) 将告诉您它是否直接在对象上。不过，我不会在这个答案中详细介绍原型和使用对象作为字符串键映射，因为它主要是为了反驳其他答案中的所有坏建议，而不管原始问题的可能解释如何。阅读object prototypes on MDN了解更多信息！

¹ 示例变量名的不寻常选择？这是来自 Firefox 的 NoScript 扩展的真正死代码。 ² 不要假设不知道范围内的内容通常是可以的。滥用动态范围导致的额外漏洞：Project Zero 1225 ³ 再次假设 ES5+ 环境并且 undefined 引用全局对象的 undefined 属性。

@BenjaminGruenbaum 是的，但完全具有误导性。任何非默认上下文都可以定义自己的 undefined，隐藏默认上下文。对于大多数实际目的而言，这与覆盖它具有相同的效果。

@blgt那是偏执的，与任何实际操作无关。每个上下文都可以覆盖 console.log，重新定义 Array 原型方法，甚至覆盖 Function.prototype.call 挂钩，并在每次调用 JavaScript 中的函数时进行更改。防止这种情况是非常偏执且相当愚蠢的。就像我（和 minitech）说的那样，您可以使用 void 0 与 undefined 进行比较，但又一次 - 这是愚蠢和矫枉过正的。`

我希望我有不止一张赞成票。这是最正确的答案。我真的不想在代码中看到 typeof something === "undefined") 。

这确实应该是公认的答案。这是最彻底和最新的。

任何非默认上下文也可以覆盖，例如 Math 或 Object 或 setTimeout，或者您希望在默认情况下在全局范围内找到的任何内容。

答4:

一个优秀的自由职业者，应该有对需求敏感和精准需求捕获的能力，而huntsbot.com提供了这个机会

在 JavaScript 中有 null 和 undefined。它们有不同的含义。

undefined 表示变量值没有被定义；不知道价值是什么。

null 表示已定义变量值并将其设置为 null（没有值）。

Marijn Haverbeke 在他的免费在线书籍“Eloquent JavaScript”（强调我的）中指出：

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

所以，我想检查某些东西是否未定义的最佳方法是：

if (something == undefined)

对象属性应该以相同的方式工作。

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

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

if (something == undefined) 最好写成 if (something === undefined)

应该指出的是，这并不完全安全。 undefined 只是一个可以由用户重新分配的变量：编写 undefined = 'a'; 将导致您的代码不再执行您认为的操作。使用 typeof 更好，也适用于尚未声明的变量（不仅仅是属性）。

如果某物是未定义的全局变量，（某物 == 未定义）会引发 javascript 错误。

这样做的问题是，如果 var a = null 则 a == undefined 的计算结果为真，即使 a 是最肯定定义的。

这种对“Eloquent Javascript”注释的解释是落后的。如果您真的只想检查未定义，建议的代码将不起作用（它还将检测已定义但尚未关联任何值的条件 [ienull]）。空值。建议的代码“if (something == undefined) ...”同时检查 undefined 和 null（未设置值），即它被解释为“if ((something is undefined) OR (something is null)) ...”作者所说的是，您真正想要的通常是检查未定义和空值。

答5:

与HuntsBot一起，探索全球自由职业机会–huntsbot.com

这是什么意思：“未定义的对象属性”？

实际上它可能意味着两个完全不同的东西！首先，它可能表示从未在对象中定义的属性，其次，它可能表示具有未定义值的属性。让我们看一下这段代码：

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

笔记：

您不能同时检查对象及其属性。例如，this xa === undefined 或 this typeof xa == ‘undefined’ 引发 ReferenceError: x is not defined if x is not defined。

变量 undefined 是一个全局变量（实际上它在浏览器中是 window.undefined）。从 ECMAScript 第一版开始就支持它，从 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 支持将全局变量 undefined 作为 global.undefined（它也可以在没有“全局”前缀的情况下使用）。我不知道服务器端 JavaScript 的其他实现。

@Bergi 感谢您的评论。我已经更正了我的答案。在我的辩护中，我可以说目前（从 v.0.10.18 开始）official Node.js documentation 没有提及 undefined 作为 global 的成员。此外，console.log(global); 和 for (var key in global) { ... } 都不会将 undefined 显示为 global 的成员。但是像 'undefined' in global 这样的测试显示相反。

自 it's in the EcmaScript spec 以来它不需要额外的文档，这也表明 [[Enumerable]] 是错误的 :-)

关于 Minuses of typeof obj.prop == 'undefined'，这可以通过写成 typeof obj.prop == typeof undefined 来避免。这也提供了非常好的对称性。

@hlovdal：与 obj.prop === undefined 相比，这完全没有意义。

当我们对问题标题 „Detecting an undefined property“ 真实时，对第一句中的（不同且更容易的）问题（“check if undefined. ..“)，您回答 if ('foo' in o)...您的答案确实是这里的第一个正确答案。几乎所有其他人都只是回答这句话。

答6:

HuntsBot周刊–不定时分享成功产品案例，学习他们如何成功建立自己的副业–huntsbot.com

问题归结为三种情况：

该对象具有属性并且其值不是未定义的。该对象具有该属性，其值未定义。该对象不具有该属性。

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

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

但不幸的是，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); }

但正如已经提到的，这些并不完全相同（但对于我的需求来说已经足够好了）。

嗨迈克尔。很好的建议，我认为它确实让事情变得更清洁。然而，我发现的一个问题是使用 !带有“in”的运算符。你必须说 if (!("x" in blob)) {} 用括号括起来，因为！运算符优先于“in”。希望对某人有所帮助。

抱歉，迈克尔，但鉴于最初的问题，这是不正确的，或者至少是误导性的。 'in' 不足以测试对象属性是否具有未定义的类型。为了证明，请看这个小提琴：jsfiddle.net/CsLKJ/4

这两个代码部分做不同的事情！ a = {b: undefined}给出的考虑和反对；然后是 typeof a.b === typeof a.c === 'undefined' 但 'b' in a 和 !('c' in a)。

+1。 OP 没有明确说明该属性是否存在并具有未定义的值，或者该属性本身是否未定义（即不存在）。

我建议将您的第一个表中的点 (2.) 更改为 { x : undefined }，或者至少将其添加为表中 (2.) 的另一种选择 - 我不得不考虑片刻才能意识到点 (2.) 的计算结果到 undefined（尽管您稍后会提到）。

答7:

huntsbot.com提供全网独家一站式外包任务、远程工作、创意产品分享与订阅服务!

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

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

括号是不必要的，因为 typeof 是一个运算符

但它们更清楚地说明了正在检查的内容。否则它可能会被读取为 typeof (something == "undefined")。

如果你需要括号，那么你应该学习 JS 中的运算符优先级：developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

括号之所以有用，正是因为你不需要学习 JS 中的运算符优先级，也不需要推测未来的维护程序员是否需要学习 JS 中的运算符优先级。

括号有助于澄清事情。但在这种情况下，它们只是让操作符看起来像一个函数。毫无疑问，这阐明了程序员的意图。但如果您不确定运算符优先级，您应该将其写为 (typeof something) === "undefined"。

答8:

打造属于自己的副业，开启自由职业之旅，从huntsbot.com开始!

我不确定将 === 与 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

伟大的埃里克。检查类型是否也会影响性能？

@Simon：恰恰相反-在“===”的情况下，避免强制执行可能会对性能造成轻微影响。快速而肮脏的测试表明 '===' 在 FF5.0.1 下比 '==' 快 5%

更彻底的测试表明，在 FF、IE 和 Chrome 下，'==' 或多或少比 '===' (5-10%) 快，而 Opera 根本没有任何区别：jsperf.com/triple-equals-vs-twice-equals/6

使用 == 仍然需要至少进行类型检查 - 解释器无法在不知道它们的类型之前比较两个操作数。

== 比 === 少一个字符 :)

答9:

huntsbot.com汇聚了国内外优秀的初创产品创意，可按收入、分类等筛选，希望这些产品与实践经验能给您带来灵感。

我没有看到（希望我没有错过）任何人在财产之前检查对象。所以，这是最短和最有效的（虽然不一定是最清楚的）：

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

如果 obj 或 obj.prop 为 undefined、null 或“falsy”，则 if 语句将不会执行代码块。这通常是大多数代码块语句（在 JavaScript 中）中所需的行为。

更新：（2021 年 7 月 2 日）

最新版本的 JavaScript 为可选链引入了一个新运算符：?.

这可能是检查对象属性是否存在的最明确和最有效的方法，向前推进。

参考：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining

如果您想知道为什么会这样：Javascript: Logical Operators and truthy / falsy

如果您想将属性分配给已定义的变量，不为空也不为假，否则使用一些默认值，您可以使用：var x = obj && obj.prop || 'default';

我相信问题是针对未定义的明确检查。您的条件检查 JS 的所有错误值。

不要这样做，如果 obj.prop 是 false、0、"" 和其他各种错误值，它会失败。这正是我们不应该做的，也适用于不应该以这种方式使用的可选链接。

答10:

huntsbot.com – 程序员副业首选，一站式外包任务、远程工作、创意产品分享订阅平台。

从相关问题交叉发布my answerHow can I check for “undefined” in JavaScript?。

具体到这个问题，请参阅 someObject. 的测试用例。

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

（请注意，在作用域包装器中使用 var 进行 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

答11:

huntsbot.com聚合了超过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 = false 或 myvar = 0 也是相同的。

当您期望特定类型时，请测试变量的类型。为了加快测试条件，您最好执行以下操作：

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

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

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

(y)

原文链接：https://www.huntsbot.com/qa/A8nv/detecting-an-undefined-object-property?lang=zh_CN&from=csdn

huntsbot.com聚合了超过10+全球外包任务平台的外包需求，寻找外包任务与机会变的简单与高效。