javascript - length - js object




检查JavaScript对象中是否存在密钥? (13)

如何检查JavaScript对象或数组中是否存在特定键?

如果某个密钥不存在,并且我尝试访问它,它会返回false吗? 或者抛出错误?


ES6解决方案

使用Array#someObject.keys 。 如果对象中存在给定键,则返回true ,否则返回false

var obj = {foo: 'one', bar: 'two'};
    
function isKeyInObject(obj, key) {
    var res = Object.keys(obj).some(v => v == key);
    console.log(res);
}

isKeyInObject(obj, 'foo');
isKeyInObject(obj, 'something');

单行示例。

console.log(Object.keys({foo: 'one', bar: 'two'}).some(v => v == 'foo'));


快速回答

如何检查JavaScript对象或数组中是否存在特定键? 如果某个密钥不存在而我尝试访问它,它会返回false吗? 或者抛出错误?

使用(关联)数组样式或对象样式直接访问缺少的属性将返回未定义的常量。

运算符和hasOwnProperty方法中的缓慢可靠

正如人们在这里已经提到的那样,你可以拥有一个具有与“未定义”常量相关联的属性的对象。

 var bizzareObj = {valid_key:  undefined};

在这种情况下,您将必须使用hasOwnProperty运算符中知道密钥是否确实存在。 但是, 但是以什么价格?

所以,我告诉你......

operator和hasOwnProperty中是在Javascript中使用属性描述符机制的“方法”(类似于Java语言中的Java反射)。

http://www.ecma-international.org/ecma-262/5.1/#sec-8.10

属性描述符类型用于解释命名属性属性的操作和具体化。 属性描述符类型的值是由命名字段组成的记录,其中每个字段的名称是属性名称,其值是8.6.1中指定的对应属性值。 此外,可以存在或不存在任何字段。

另一方面,调用对象方法或键将使用Javascript [[Get]]机制。 那要快得多!

基准

http://jsperf.com/checking-if-a-key-exists-in-a-javascript-array

运营商中使用
var result = "Impression" in array;

结果是

12,931,832 ±0.21% ops/sec      92% slower 
使用hasOwnProperty
var result = array.hasOwnProperty("Impression")

结果是

16,021,758 ±0.45% ops/sec     91% slower
直接访问元素(括号样式)
var result = array["Impression"] === undefined

结果是

168,270,439 ±0.13 ops/sec     0.02% slower 
直接访问元素(对象样式)
var result = array.Impression  === undefined;

结果是

168,303,172 ±0.20%     fastest

编辑:为属性分配undefined值的原因是什么?

那个问题困扰着我。 在Javascript中,缺少对象的至少两个引用可以避免这样的问题: nullundefined

null是原始值,表示故意缺少任何对象值,或者简称为确认的缺乏值。 另一方面, undefined是未知值(未定义)。 如果稍后将使用具有适当值的属性,请考虑使用null引用而不是undefined因为在最初时刻,属性被确认为缺少值。

相比:

var a = {1: null}; 
console.log(a[1] === undefined); // output: false. I know the value at position 1 of a[] is absent and this was by design, i.e.:  the value is defined. 
console.log(a[0] === undefined); // output: true. I cannot say anything about a[0] value. In this case, the key 0 was not in a[].

劝告

避免使用undefined值的对象。 尽可能直接检查并使用null初始化属性值。 否则,使用slow in运算符或hasOwnProperty()方法。

编辑:12/04/2018 - 不相关任何人

正如人们所评论的那样,现代版本的Javascript引擎(使用firefox异常)改变了访问属性的方法。 对于这种特定情况,当前实现比前一个实现慢,但是访问密钥和对象之间的差异是可忽略的。


对于那些在项目中包含lodash
有一个lodash _.get方法试图获得“深”键:

获取object对象的值。 如果未定义已解析的值,则返回defaultValue。

var object = { 'a': [{ 'b': { 'c': 3 } }] };

console.log(
  _.get(object, 'a[0].b.c'),           // => 3
  _.get(object, ['a', '0', 'b', 'c']), // => 3
  _.get(object, 'a.b.c'),              // => undefined 
  _.get(object, 'a.b.c', 'default')    // => 'default'
)
<script src="https://cdnjs.cloudflare.com/ajax/libs/lodash.js/4.17.4/lodash.min.js"></script>

这将有效地检查是否定义了该密钥(无论多么深) ,并且如果未定义该密钥,则不会抛出可能损害程序流的错误。


我们可以使用 - hasOwnProperty.call(obj, key);

underscore.js方式 -

if(_.has(this.options, 'login')){
  //key 'login' exists in this.options 
}

_.has = function(obj, key) {
  return hasOwnProperty.call(obj, key);
};

JavaScript解构的新解决方案:

var obj = {
    test: "",
    locals: {
        test: "",
        test2: false,
        test3: NaN,
        test4: 0,
        test5: undefined,
        auth: {
            user: "hw"
        }
    }
}

keyExistsOn(obj, "")
> false
keyExistsOn(obj, "locals.test")
> true
keyExistsOn(obj, "locals.test2")
> true
keyExistsOn(obj, "locals.test3")
> true
keyExistsOn(obj, "locals.test4")
> true
keyExistsOn(obj, "locals.test5")
> true
keyExistsOn(obj, "sdsdf")
false
keyExistsOn(obj, "sdsdf.rtsd")
false
keyExistsOn(obj, "sdsdf.234d")
false
keyExistsOn(obj, "2134.sdsdf.234d")
false
keyExistsOn(obj, "locals")
true
keyExistsOn(obj, "locals.")
false
keyExistsOn(obj, "locals.auth")
true
keyExistsOn(obj, "locals.autht")
false
keyExistsOn(obj, "locals.auth.")
false
keyExistsOn(obj, "locals.auth.user")
true
keyExistsOn(obj, "locals.auth.userr")
false
keyExistsOn(obj, "locals.auth.user.")
false
keyExistsOn(obj, "locals.auth.user")
true

请检查JavaScript Destructuring的其他用法


回答:

if ("key" in myObj)
{
    console.log("key exists!");
}
else
{
    console.log("key doesn't exist!");
}

说明:

in运算符将检查对象中是否存在键。 如果检查了值是否未定义: if (myObj["key"] === 'undefined') ,则可能会遇到问题,因为对象可能存在undefined值的对象。

因此,最好先使用in运算符,然后在知道密钥存在后比较密钥内的值。



它将返回undefined

var aa = {hello: "world"};
alert( aa["hello"] );      // popup box with "world"
alert( aa["goodbye"] );    // popup box with "undefined"

undefined是一个特殊的常量值。 所以你可以说,例如

// note the three equal signs so that null won't be equal to undefined
if( aa["goodbye"] === undefined ) {
    // do something
}

这可能是检查丢失密钥的最佳方法。 但是,正如下面的评论所指出的那样,理论上你可能希望将实际值undefinedundefined 。 我从来不需要这样做,也无法想出为什么我想要的原因,但为了完整起见,你可以使用in运算符

// this works even if you have {"goodbye": undefined}
if( "goodbye" in aa ) {
    // do something
}

最简单的检查方法是

let obj = {
    "key1": "value1",
    "key2": "value2",
    "key3": "value3",
};

let {key1, key2, key3, key4} = obj;

// key1 = "value1"
// key2 = "value2"
// key3 = "value3"
// key4 = undefined

// Can easily use `if` here on key4
if(!key4) { console.log("key not present"); } // Key not present

例如:

var keyExistsOn = (o, k) => k.split(".").reduce((a, c) => a.hasOwnProperty(c) ? a[c] || 1 : false, Object.assign({}, o)) === false ? false : true;

返回值为true意味着该键存在于对象中。


检查javascript对象中是否存在属性的三种方法:

  1. !obj.theProperty
    将值转换为bool。 除“false”值之外的所有值都返回TRUE
  2. obj中的'theProperty'
    如果属性存在,则返回true,无论其值如何(甚至为空)
  3. obj.hasOwnProperty( '利人')
    不检查原型链。 (因为所有对象都有'toString'方法,1和2将在其上返回true,而3可以在其上返回false。)

参考:

http://book.mixu.net/node/ch5.html


虽然这必然检查密钥是否存在,但它会检查值的真实性。 哪个undefinednull属于。

Boolean(obj.foo)

这个解决方案最适合我,因为我使用typescript,并'foo' in objobj.hasOwnProperty('foo')使用类似'foo' in obj字符串来检查密钥是否存在并不能为我提供智能感知。


这些例子可以证明不同方式之间的差异。 希望它能帮助您选择适合您需求的产品:

// Lets create object `a` using create function `A`
function A(){};
A.prototype.onProtDef=2;
A.prototype.onProtUndef=undefined;
var a=new A();
a.ownProp = 3;
a.ownPropUndef = undefined;

// Let's try different methods:

a.onProtDef; // 2
a.onProtUndef; // undefined
a.ownProp; // 3
a.ownPropUndef; // undefined
a.whatEver; // undefined
a.valueOf; // ƒ valueOf() { [native code] }

a.hasOwnProperty('onProtDef'); // false
a.hasOwnProperty('onProtUndef'); // false
a.hasOwnProperty('ownProp'); // true
a.hasOwnProperty('ownPropUndef'); // true
a.hasOwnProperty('whatEver'); // false
a.hasOwnProperty('valueOf'); // false

'onProtDef' in a; // true
'onProtUndef' in a; // true
'ownProp' in a; // true
'ownPropUndef' in a; // true
'whatEver' in a; // false
'valueOf' in a; // true (on the prototype chain - Object.valueOf)

Object.keys(a); // ["ownProp", "ownPropUndef"]

"key" in obj

可能只测试与数组键非常不同的对象属性值







object