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

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

19 回答

使用 JavaScript Destructuring 的新功能：

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

请检查other use of JavaScript Destructuring

回复于 2024-04-20T18:24:26+08:00

3241
检查undefined-ness不是测试密钥是否存在的准确方法 . 如果密钥存在但值实际上是 undefined 怎么办？
```
var obj = { key: undefined };
obj["key"] != undefined // false, but the key exists!
```
您应该使用 in 运算符：
```
"key" in obj // true, regardless of the actual value
```
如果要检查密钥是否不存在，请记住使用括号：
```
!("key" in obj) // true if "key" doesn't exist in object
!"key" in obj   // ERROR!  Equivalent to "false in obj"
```
或者，如果要特别测试对象实例的属性（而不是继承的属性），请使用 hasOwnProperty ：
```
obj.hasOwnProperty("key") // true
```
对于 in ， hasOwnProperty 和key为 undefined 的方法之间的性能比较，请参见benchmark
回复于 2024-04-20T18:24:26+08:00

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

获取对象路径的值 . 如果未定义已解析的值，则返回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>

这将有效地检查是否定义了该键，但是 deep ，如果未定义该键，则不会抛出可能损害程序流的错误 .

回复于 2024-04-20T18:24:26+08:00

20
vanila js
```
yourObjName.hasOwnProperty(key) : true ? false;
```
如果要检查对象在es2015中是否至少有一个属性
```
Object.keys(yourObjName).length : true ? false
```
回复于 2024-04-20T18:24:26+08:00
1
快速回答

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

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

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

正如人们在这里已经提到的那样，你可以拥有一个具有与“未定义”常量相关联的属性的对象 .
```
var bizzareObj = {valid_key:  undefined};
```
在这种情况下，您将必须使用hasOwnProperty或在运算符中知道密钥是否确实存在 . 但是，但是以什么价格？

所以，我告诉你......

在operator和hasOwnProperty中是"methods"，它们使用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
```
编辑：为属性分配未定义值的原因是什么？

那个问题困扰着我 . 在Javascript中，缺少对象的至少两个引用可以避免这样的问题： null 和 undefined .

null 是原始值，表示故意缺少任何对象值，或者简称为 confirmed 缺乏 Value . 另一方面， undefined 是未知值（未定义） . 如果稍后将使用具有适当值的属性，请考虑使用 null reference而不是 undefined ，因为在最初时刻该属性为 confirmed 缺少值 .

相比：
```
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异常）改变了访问属性的方法 . 对于这种特定情况，当前实现比前一个实现慢，但是访问密钥和对象之间的差异是可忽略的 .
回复于 2024-04-20T18:24:26+08:00
13
```
"key" in obj
```
可能只测试与数组键非常不同的对象属性值
回复于 2024-04-20T18:24:26+08:00

236

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

// 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"]

回复于 2024-04-20T18:24:26+08:00

3

虽然这必然检查密钥是否存在，但它会检查值的真实性 . 哪个 undefined 和 null 属于 .

Boolean(obj.foo)

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

回复于 2024-04-20T18:24:26+08:00

这是一个我发现非常有用的辅助函数

这 keyExists(key, search) 可用于轻松查找对象或数组中的键！

只需将要查找的密钥传递给它，然后搜索obj（要在其中找到的对象或数组） .

function keyExists(key, search) {
    if (!search || (search.constructor !== Array && search.constructor !== Object)) {
        return false;
    }
    for (var i = 0; i < search.length; i++) {
        if (search[i] === key) {
            return true;
        }
    }
    return key in search;
}

如何使用它：

在数组中搜索键

keyExists('apple', ['apple', 'banana', 'orange']); // true
keyExists('fruit', ['apple', 'banana', 'orange']); // false

在对象中搜索键

keyExists('age', {'name': 'Bill', 'age': 29 }); // true
keyExists('title', {'name': 'Jason', 'age': 29 }); // false

它非常可靠，并且跨浏览器运行良好 .

回复于 2024-04-20T18:24:26+08:00

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

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

因此，最好先使用 in 运算符，然后在知道密钥存在后比较密钥内部的值 .
回复于 2024-04-20T18:24:26+08:00
118
accepted answer指的是Object . 注意使用in operator Array来查找数据而不是键：
```
("true" in ["true", "false"])
// -> false (Because the keys of the above Array are actually 0 and 1)
```
测试数组中的现有元素：Best way to find if an item is in a JavaScript array?
回复于 2024-04-20T18:24:26+08:00
5
检查javascript对象中是否存在属性的三种方法：
- !!obj.theProperty
  将值转换为bool . 除了'false'值之外的所有值都返回TRUE
- 'theProperty' in obj
  如果属性存在，则返回true，无论其值如何（甚至为空）
- obj.hasOwnProperty('theProperty')
  不检查原型链 . （因为所有对象都有'toString'方法，1和2将在其上返回true，而3可以在其上返回false . ）
参考：

http://book.mixu.net/node/ch5.html
回复于 2024-04-20T18:24:26+08:00

ES6解决方案

使用 Array#some 和 Object.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'));

回复于 2024-04-20T18:24:26+08:00

20
最简单的检查方法是
```
"key" in object
```
例如：
```
var obj = {
  a: 1,
  b: 2,
}
"a" in obj // true
"c" in obj // false
```
返回值 true 表示该对象中存在该键 .
回复于 2024-04-20T18:24:26+08:00

如果要检查对象上任何深度的任何键并考虑falsey值，请将此行视为实用程序函数：

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

Results

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

另请参阅此NPM包：https://www.npmjs.com/package/has-deep-value

回复于 2024-04-20T18:24:26+08:00

0
如果您使用underscore.js库，则对象/数组操作变得简单 .

在你的情况下，可以使用_.has方法 . 例：
```
yourArray = {age: "10"}

_.has(yourArray, "age")
```
返回 true

但，
```
_.has(yourArray, "invalidKey")
```
返回 false
回复于 2024-04-20T18:24:26+08:00

这是一个老问题，但我想永远不会迟到给出答案 .

想象一下，你有一个对象“产品”和两个项目 . 如果要查看此对象中是否已存在id，可以使用find（）

products = [
    {
        "id": 1,
        "name": "Name 1"
    },
    {
        "id": 2,
        "name": "Name 2"
    },
  ]

  item1 = 
    {
        "id": 3,
        "name": "Name 3",
    }



  item2 = 
    {
        "id": 1,
        "name": "Name 1",
    }



  if(products.find(x => x.id === item1.id)){
    console.log('id is in products');
  }else {
    console.log('id is not in products');
  }
  if(products.find(x => x.id === item2.id)){
    console.log('id is in products');
  }else {
    console.log('id is not in products');
  }

日志：

id is not in products
id is in products

回复于 2024-04-20T18:24:26+08:00

我们可以使用 - 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);
};

回复于 2024-04-20T18:24:26+08:00

2
它将返回 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
}
```
这可能是检查丢失密钥的最佳方法 . 但是，正如下面的评论所指出的那样，'s theoretically possible that you' d希望实际值为 undefined . 我想到了为什么我想要的原因，但为了完整起见，你可以使用 in 运算符
```
// this works even if you have {"goodbye": undefined}
if( "goodbye" in aa ) {
    // do something
}
```
回复于 2024-04-20T18:24:26+08:00

检查JavaScript对象中是否存在密钥？

19 回答

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

快速回答

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

基准

编辑：为属性分配未定义值的原因是什么？

建议

编辑：12/04/2018 - 不相关任何情况

这是一个我发现非常有用的辅助函数

如何使用它：

在数组中搜索键

ES6解决方案

我们可以使用 - hasOwnProperty.call（obj，key）;

相关问题