检测未定义的对象属性

StackOverflow https://stackoverflow.com/questions/27509

  •  09-06-2019
  •  | 
  •  

题

检查 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
}

其他提示

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

尽管这里有许多其他答案强烈推荐， 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 中的关键字。相反，它是全局对象上具有未定义值的属性。然而，从 ES5 开始，这个属性已经被 只读 和 不可配置. 。没有现代浏览器允许 undefined 财产要改变，截至2017年，这种情况已经持续很长时间了。缺少严格模式不影响 undefined的行为——它只是做出这样的陈述 undefined = 5 什么都不做而不是扔。不过，由于它不是关键字，因此您可以 宣布 带有名称的变量 undefined, ，并且这些变量可以改变，从而形成这种曾经常见的模式：

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

    更多的 比使用全局更危险 undefined. 。如果必须兼容 ES3，请替换 undefined 和 void 0 – 不要求助于 typeof. (void 始终是一个一元运算符，其计算结果为任何操作数的未定义值。）

了解了变量的工作方式后，是时候解决实际问题了：对象属性。没有理由使用 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 上的对象原型 了解更多！

1 示例变量名的选择不寻常？这是来自 Firefox NoScript 扩展的真正死代码。
² 不过，不要认为不知道范围内的内容通常是可以的。滥用动态范围导致的额外漏洞： 零号计划1225
³ 再次假设 ES5+ 环境 undefined 指的是 undefined 全局对象的属性。代替 void 0 否则。

在 JavaScript 中有 无效的 并且有 不明确的. 。它们有不同的含义。

  • 不明确的 表示变量值尚未定义；目前尚不清楚该值是多少。
  • 无效的 表示变量值已定义并设置为 null（没有值）。

Marijn Haverbeke 在他的免费在线书中指出“雄辩的 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

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

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

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.a === undefined 或这个 typeof x.a == 'undefined' 提高 ReferenceError: x is not defined 如果 x 没有定义。
  • 多变的 undefined 是一个全局变量（所以实际上它是 window.undefined 在浏览器中）。自 ECMAScript 第 1 版以来一直受支持，自 ECMAScript 5 起 只读. 。所以在现代浏览器中它不能 重新定义为 true 正如许多作者喜欢吓唬我们一样，但这对于旧浏览器来说仍然如此。

最后的战斗： obj.prop === undefined 与 typeof obj.prop == 'undefined'

优点 obj.prop === undefined:

  • 短了一点，看起来更漂亮了一点
  • 如果你拼写错误，JavaScript 引擎会给你一个错误 undefined

缺点 obj.prop === undefined:

  • undefined 可以在旧浏览器中被覆盖

优点 typeof obj.prop == 'undefined':

  • 真是万能啊！它适用于新旧浏览器。

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

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

更新（针对服务器端 JavaScript）：

Node.js 支持全局变量 undefined 作为 global.undefined （它也可以在没有“global”前缀的情况下使用）。我不知道服务器端 JavaScript 的其他实现。

这个问题归结为三种情况：

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

但正如已经提到的，这些并不完全相同（但足以满足我的需求）。 

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

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

我不确定使用的起源在哪里 === 和 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

交叉发布我的 回答 来自相关问题 如何在 JavaScript 中检查“未定义”？

具体到这个问题，请参阅测试用例 someObject.<whatever>.

一些场景说明了各种答案的结果：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

如果你这样做

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

当变量 myvar 不存在，因为myvar没有定义，所以脚本被破坏，测试没有效果。

由于窗口对象在函数外部具有全局作用域（默认对象），因此声明将“附加”到窗口对象。

例如：

var myvar = 'test';

全局变量 迈瓦尔 是相同的 窗口.myvar 或者 窗口['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)

我没有看到（希望我没有错过）有人在财产之前检查该物体。所以，这是最短且最有效的（尽管不一定是最清晰的）：

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

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

文章中 探索 JavaScript 中 Null 和未定义的深渊 我读到框架就像 下划线.js 使用这个功能：

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

'if (窗口.x) { }' 是错误安全的

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

例子：我想知道我的浏览器是否支持 History API

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

这是如何运作的：

窗户 是一个将所有全局变量作为其成员的对象，尝试访问不存在的成员是合法的。如果 X 那时尚未声明或尚未设置 window.x 回报 不明确的. 不明确的 导致 错误的 什么时候 如果（） 对其进行评价。

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

读完这篇文章，我很惊讶我没有看到这一点。我发现了多种适用于此的算法。

从未定义

如果对象的值从未定义过，这将阻止返回 true 如果它被定义为 null 或者 undefined. 。如果您希望设置为 true 的值返回 true，这会很有帮助 undefined

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

定义为未定义或从未定义

如果你希望它的结果为 true 对于使用以下值定义的值 undefined, ，或者从未定义，您可以简单地使用 === undefined

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

定义为假值、未定义、空或从未定义。

通常，人们要求我提供一种算法来判断一个值是否为假， undefined, ， 或者 null. 。以下作品。

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

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

 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 关联

简单来说，JavaScript 中没有定义任何内容， 不明确的, ，无论它是对象/数组内的属性还是只是一个简单的变量都没关系......

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

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

著名的函数就是这样的 isUndefined() AngularJs v.1x 中写道：

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) 的有用信息。

严格平等和未定义
您可以使用不确定的和严格的平等和不平等运算符来确定变量是否具有值。在以下代码中，未定义变量x，if语句评估为true。

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

笔记：必须在此处使用严格的平等运算符，而不是标准平等运算符，因为x ==不确定的还检查x是否为null，而严格的平等却没有。零不是不确定的。有关详细信息，请参阅比较运算符。

Typeof 运算符和未定义
或者，可以使用 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是一种静态范围的语言，因此可以通过查看是否在封闭的上下文中声明它来读取变量。唯一的例外是全局范围，但是全局范围与全局对象绑定，因此可以通过检查全局对象上的属性存在（使用在运算符中，在全局上下文中检查变量的存在，例如）。

空运算符和未定义

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`)
}

更多> 这里

与之比较 void 0, ，为了简洁。

if (foo !== void 0)

它并不像 if (typeof foo !== 'undefined')

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

null == undefined

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

if (something === undefined)

这是身份运算符...

这是我的情况：

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

有一个错误我需要辩护。如果剩余调用的参数不正确（用户指定的参数错误），则剩余调用基本上返回空。

在使用这篇文章来帮助我防御这一点时，我尝试了这个。

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

对于我的情况，如果restResult.data[0] ===“object”，那么我可以安全地开始检查其余成员。如果未定义，则抛出上述错误。

我想说的是，对于我的情况，这篇文章上面的所有建议都不起作用。我并不是说我是对的而每个人都是错的。我根本不是 JavaScript 大师，但希望这会对某人有所帮助。

有一种很好且优雅的方法可以将已定义的属性分配给已定义的新变量，或者如果未定义，则为其分配默认值作为后备。

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

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

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

浏览评论，对于那些想要检查两者是否未定义或其值为 null 的人：

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

如果您使用的是 jQuery 库，那么 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;

如果您使用的是角度： 

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

下划线.js：

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

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

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

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

它首先检测该变量 abc 未定义，初始化后定义。

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

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

然后使用：

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

同样的事情也可以写得更短：

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

或者 

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

我想向您展示我正在使用的一些东西，以保护 undefined 多变的：

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

这禁止任何人改变 window.undefined value 因此会破坏基于该变量的代码。如果使用 "use strict", ，任何试图改变其值的行为都会以错误结束，否则它将被默默地忽略。

来自 lodash.js。

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

它创建一个名为的 LOCAL 变量 undefined 它是用默认值初始化的——真实的 undefined, ，然后比较 value 与变量 undefined.

我在这里为那些期待奇怪答案的人提供三种方法：

function isUndefined1(val) {
    try {
        val.a;
    } catch (e) {
        return /undefined/.test(e.message);
    }
    return false;
}
function isUndefined2(val) {
    return !val && val+'' === 'undefined';
}
function isUndefined3(val) {
    const defaultVal={};
    return ((input=defaultVal)=>input===defaultVal)(val);
}
function test(func){
    console.group(`test start :`+func.name);
    console.log(func(undefined));
    console.log(func(null));
    console.log(func(1));
    console.log(func("1"));
    console.log(func(0));
    console.log(func({}));
    console.log(func(function () { }));
    console.groupEnd();
}
test(isUndefined1);
test(isUndefined2);
test(isUndefined3);

未定义1：

尝试获取输入值的属性，检查错误消息是否存在。如果输入值未定义，则错误消息将为 未捕获的类型错误：无法读取未定义的属性“b”

未定义2：

将输入值转换为字符串以进行比较 "undefined" 并确保其为负值。

未定义3：

在js中，当输入值恰好是可选参数时，可选参数起作用 undefined.

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top