检测未定义的对象属性

2020/09/14 07:01 · javascript ·  · 0评论

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

检查属性值是否为特殊值的通常方法undefined是:

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

要检查对象是否实际上没有这样的属性,并因此undefined在尝试访问它时默认情况下将返回

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

检查与标识符关联的值是否为特殊值undefined或者尚未声明该标识符。注意:此方法是引用未声明(但值不同于undefined)标识符的唯一方法,且不会出现早期错误:

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

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

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

如果您担心这种(不太可能)边缘情况,则可以使用void运算符获取特殊undefined值本身:

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

我相信对此主题有许多不正确的答案。与通常的看法相反,“未定义” 不是 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不是关键字,但是它只读的且不可配置。尽管有一些非关键字状态(Object,,…),但您可能还是无法避免使用其他内置程序MathNaN并且实用代码通常不是在主动恶意的环境中编写的,因此,这不是担心的充分理由undefined(但是,如果您正在编写代码生成器,请随时使用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')告诉您密钥是否直接在对象上。不过,我不会在有关原型和将对象用作字符串键映射的答案中进行详细介绍,因为它的主要目的是与其他答案中的所有不良建议相抵触,而与对原始问题的可能解释无关。继续阅读MDN上的对象原型更多!

¹示例变量名称的异常选择?这是来自Firefox的NoScript扩展的真正的死代码。
²不过,不要以为总体上不知道范围是什么。由于滥用动态范围而导致的额外漏洞:零项目1225³
再次假设使用ES5 +环境,并且undefined引用undefined了全局对象属性。

在JavaScript中,为null,没有定义它们具有不同的含义。

  • 未定义表示尚未定义变量值;目前尚不清楚该值是多少。
  • 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

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

实际上,这可能意味着两个截然不同的事情!首先,它可以表示从未在对象中定义的属性,其次,它可以表示具有未定义值属性让我们看一下这段代码:

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它是只读的因此,在现代浏览器中,不能像许多作者喜欢的那样将其重新定义为true,但是对于较旧的浏览器仍然如此。

最终决战:obj.prop === undefinedvstypeof 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支持的全局变量undefinedglobal.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") 

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

我不确定用===with 的来源是哪里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/

(请注意,在有作用域的包装器中使用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

如果你这样做

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

当变量myvar不存在时,它将失败,因为未定义myvar,因此脚本已损坏,测试无效。

因为窗口对象在函数外部具有全局作用域(默认对象),所以声明将“附加”到窗口对象。

例如:

var myvar = 'test';

全局变量myvarwindow.myvarwindow ['myvar']相同

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

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

变量是否确实存在的问题并不重要,其值不正确。否则,使用undefined初始化变量是愚蠢的,最好使用false值进行初始化。当您知道声明的所有变量都用false初始化时,您可以简单地检查其类型或依靠!window.myvar其是否具有正确/有效的值。因此,即使未定义变量!window.myvar,也可以使用myvar = undefinedor myvar = false或or myvar = 0

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

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

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

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

(y)

我没有看到(希望我没有错过它)有人在属性之前检查对象。因此,这是最短和最有效的(尽管不一定最清晰):

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

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

在《探索JavaScript中的Null和Undefined的深渊》一文中,我读到像Underscore.js之类的框架使用此函数:

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

简而言之,任何未在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中定义的...

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,而严格相等则不。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运算符,例如)。


无效运算符和未定义

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

更多> 这里

' 如果(window.x){} '是错误安全的

您最有可能想要if (window.x)即使未声明x(var x;),此检查也是安全的-浏览器不会引发错误。

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

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

工作原理:

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

读完这个,我很惊讶我没看到这个。我发现有多种算法可以解决此问题。

从未定义

如果从未定义对象的值,true则将其定义为null或时,这将防止返回undefined如果您希望为设置为的值返回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");
}
"propertyName" in obj //-> true | false

与相比void 0,简洁。

if (foo !== void 0)

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

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

null == undefined

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

if (something === 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链接

如果定义了新变量,则可以使用一种很好的方式优雅地将已定义的属性分配给新变量,如果未定义,则可以为其分配默认值作为后备。

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

这是我的情况:

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

我需要捍卫一个错误。如果REST调用的参数不正确,而用户指定的参数错误,则REST调用基本上返回为空。

在使用这篇文章帮助我进行防御时,我尝试了以下方法:

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

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

我的意思是,就我的情况而言,本文中以前的所有建议均无效。我并不是说我是对的,每个人都是错误的。我根本不是JavaScript大师,但希望这会对某人有所帮助。

通过注释,对于那些想同时检查这两个注释的对象,它是未定义的还是其值为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:

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

Underscore.js:

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

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

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

ECMAScript 10引入了一项新功能- 可选链接,仅当这样定义对象时,才可以使用它来使用对象的属性:

const userPhone = user?.contactDetails?.phone;

仅当定义了user和contactDetails时,它才会引用phone属性。

参考 https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Operators/Optional_chaining

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

它首先检测到变量abc未定义,并且在初始化后定义。

对于那些期望得到怪异答案的人,我在这里提供了三种方法:

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

isUndefined1:

尝试获取输入值的属性,并检查错误消息(如果存在)。如果输入值未定义,则错误消息将为Uncaught TypeError:无法读取undefined的属性'b'

isUndefined2:

将输入值转换为要比较的字符串,"undefined"并确保它是负值。

isUndefined3:

在JavaScript中,当输入值恰好为时,可选参数起作用undefined

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

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

然后使用:

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

我想向您展示一些我用来保护undefined变量的东西:

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

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

来自lodash.js。

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

它创建一个名为局部变量undefined局部变量使用默认值real undefined进行初始化,然后value与该变量进行比较undefined


更新9/9/2019

我发现Lodash更新了其实现。请参阅我的问题代码

要防弹,只需使用:

function isUndefined(value) {
  return value === void 0;
}
本文地址:http://javascript.askforanswer.com/jianceweidingyideduixiangshuxing.html
文章标签: ,   ,   ,  
版权声明:本文为原创文章,版权归 javascript 所有,欢迎分享本文,转载请保留出处!

文件下载

老薛主机终身7折优惠码boke112

上一篇:
下一篇:

评论已关闭!