它将返回 .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
}

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

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

检查未定义性不是测试键是否存在的准确方法。如果键存在但值实际存在怎么办？undefined

var obj = { key: undefined };
console.log(obj["key"] !== undefined); // false, but the key exists!

应改用运算符：in

var obj = { key: undefined };
console.log("key" in obj); // true, regardless of the actual value

如果要检查密钥是否不存在，请记住使用括号：

var obj = { not_key: undefined };
console.log(!("key" in obj)); // true if "key" doesn't exist in object
console.log(!"key" in obj);   // Do not do this! It is equivalent to "false in obj"

或者，如果要特别测试对象实例的属性（而不是继承的属性），请使用：hasOwnProperty

var obj = { key: undefined };
console.log(obj.hasOwnProperty("key")); // true

有关 和 key is 方法之间的性能比较，请参阅以下基准测试：inhasOwnPropertyundefined

"key" in obj

可能仅测试与数组键截然不同的对象属性值

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

1. ！！obj.theProperty
   将 value 转换为 bool。返回除 value 之外的所有值truefalse
2. obj
   中的 'theProperty' 如果属性存在，则返回 true，无论其值如何（甚至为空）
3. obj.hasOwnProperty（'theProperty'）
   不检查原型链。（由于所有对象都有该方法，因此 1 和 2 将在其上返回 true，而 3 可以在其上返回 false。toString

参考：

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

快速回答

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

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

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

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

 var bizzareObj = {valid_key:  undefined};

在这种情况下，您必须使用 hasOwnProperty 或 in 运算符来了解密钥是否真的存在。但是，但代价是什么？

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

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

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

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

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

基准

https://jsben.ch/HaHQt

.

在运算符中使用

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是表示故意缺少任何对象值的原始值，或者简而言之，表示确认缺少值。另一方面，是一个未知值（未定义）。如果某个属性稍后将以适当的值使用，请考虑使用引用，而不是因为在最初时刻确认该属性缺少值。undefinednullundefined

比较：

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[].

建议

避免使用具有值的对象。尽可能直接检查并用于初始化属性值。否则，请使用慢速运算符或方法。undefinednullinhasOwnProperty()

编辑： 12/04/2018 - 不再相关

正如人们所评论的那样，现代版本的 Javascript 引擎（firefox 除外）改变了访问属性的方法。在这种特殊情况下，当前的实现比以前的实现慢，但访问密钥和对象之间的差异可以忽略不计。

如果您使用的是下划线.js库，则对象/数组操作将变得简单。

在您的情况下，可以使用 _.has 方法。例：

yourArray = {age: "10"}

_.has(yourArray, "age")

返回 true

但

_.has(yourArray, "invalidKey")

返回 false

接受的答案是指 Object。请注意在 Array 上使用 in 运算符来查找数据而不是键：

("true" in ["true", "false"])
// -> false (Because the keys of the above Array are actually 0 and 1)

要测试数组中的现有元素：查找项目是否在 JavaScript 数组中的最佳方法？

这是一个我认为非常有用的辅助函数

这可用于在对象或数组中轻松查找键！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;
    }

// How to use it:
// Searching for keys in Arrays
console.log(keyExists('apple', ['apple', 'banana', 'orange'])); // true
console.log(keyExists('fruit', ['apple', 'banana', 'orange'])); // false

// Searching for keys in Objects
console.log(keyExists('age', {'name': 'Bill', 'age': 29 })); // true
console.log(keyExists('title', {'name': 'Jason', 'age': 29 })); // false

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

答：

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

解释：

操作员将检查对象中是否存在该键。如果检查值是否为 undefined： ，则可能会遇到问题，因为对象中可能存在具有该值的键。inif (myObj["key"] === 'undefined')undefined

因此，最好先使用运算符，然后在知道键内的值存在后再比较它。in

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

下划线.js方式 -

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

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

Vanila JS

yourObjName.hasOwnProperty(key) : true ? false;

如果要检查对象在 es2015 中是否至少有一个属性

Object.keys(yourObjName).length : true ? false

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

可选的链接运算符：

const invoice = {customer: {address: {city: "foo"}}}

console.log( invoice?.customer?.address?.city )
console.log( invoice?.customer?.address?.street )
console.log( invoice?.xyz?.address?.city )

查看支持的浏览器列表

对于那些包含在他们的项目中的人：
有一个 lodash _.get 方法，它试图获取“深度”键：lodash

获取对象路径处的值。如果解析的值未定义， 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>

这将有效地检查该键（无论深度如何）是否已定义，并且不会引发错误，如果未定义该键，则可能会损害程序的流程。

虽然这不一定检查键是否存在，但它确实会检查值的真实性。哪个和属于。undefinednull

Boolean(obj.foo)

这个解决方案最适合我，因为我使用打字稿，并且使用这样的字符串或检查键是否存在并不能为我提供智能感知。'foo' in objobj.hasOwnProperty('foo')

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

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

JavaScript 解构的新解决方案：

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

请检查 JavaScript 解构的其他用法

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

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

结果

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

最简单的检查方法是

"key" in object

例如：

var obj = {
  a: 1,
  b: 2,
}
"a" in obj // true
"c" in obj // false

返回值为 true 表示键存在于对象中。

yourArray.indexOf（您的数组键名） > -1

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple') > -1

真

fruit = ['apple', 'grapes', 'banana']

fruit.indexOf('apple1') > -1

假

对于严格的对象键检查：

const object1 = {};
object1.stackoverflow = 51; 
console.log(object1.hasOwnProperty('stackoverflow')); 



output: true 

const object1 = {
  a: 'something',
  b: 'something',
  c: 'something'
};

const key = 's';

// Object.keys(object1) will return array of the object keys ['a', 'b', 'c']

Object.keys(object1).indexOf(key) === -1 ? 'the key is not there' : 'yep the key is exist';

在“数组”世界中，我们可以将索引视为某种键。令人惊讶的是，运算符（这是对象的不错选择）也适用于数组。不存在的键的返回值为inundefined

let arr = ["a","b","c"]; // we have indexes: 0,1,2
delete arr[1];           // set 'empty' at index 1
arr.pop();               // remove last item

console.log(0 in arr,  arr[0]);
console.log(1 in arr,  arr[1]);
console.log(2 in arr,  arr[2]);

一个快速简便的解决方案是将您的对象转换为 json，然后您将能够完成这个简单的任务：

const allowed = {
    '/login' : '',
    '/register': '',
    '/resetpsw': ''
};
console.log('/login' in allowed); //returns true

如果您使用数组，则对象键将转换为整数，例如 0、1、2、3 等，因此，它将始终为 false

可选的 Chaining （） 运算符也可用于此目的?.

资料来源： MDN/Operators/Optional_chaining

const adventurer = {
  name: 'Alice',
  cat: {
    name: 'Dinah'
  }
}

console.log(adventurer.dog?.name) // undefined
console.log(adventurer.cat?.name) // Dinah

就我而言，我想检查 LUIS 返回的 NLP 元数据，这是一个对象。我想检查字符串“FinancialRiskIntent”的键是否作为该元数据对象中的键存在。

1. 我试图定位我需要检查的嵌套对象 ->（仅出于我自己的目的，您的对象可以是任何对象）data.meta.prediction.intents
2. 我使用以下代码来检查密钥是否存在：

const hasKey = 'FinancialRiskIntent' in data.meta.prediction.intents;

if(hasKey) {
  console.log('The key exists.');
}
else {
  console.log('The key does not exist.');
}

这是在检查我最初寻找的特定密钥。

希望这一点对某人有所帮助。

值得注意的是，自从 ES11 推出以来，您可以使用 nullish 合并运算符，这简化了很多：

const obj = {foo: 'one', bar: 'two'};

const result = obj.foo ?? "Not found";

上面的代码将返回 foo 中任何“虚假”值的“未找到”。否则将返回 obj.foo。

请参阅与 nullish 合并运算符组合

1. 检查对象的属性，包括继承的属性

可以使用运算符确定，如果指定的属性在指定的对象或其原型链中，则返回 true，否则返回 falsein

const person = { name: 'dan' };

console.log('name' in person); // true
console.log('age' in person); // false

2. 检查对象实例的属性（不包括继承的属性）

*2021 - 使用新方法 ***Object.hasOwn（） 替换 Object.hasOwnProperty（）

Object.hasOwn()旨在替代并且是一种可以使用的新方法（但仍未完全支持所有浏览器，如 Safari，但很快就会支持）Object.hasOwnProperty()

Object.hasOwn()是一个静态方法，如果指定的对象将指定的属性作为其自己的属性，则返回 true。如果该属性是继承的或不存在，则该方法返回 false。

const person = { name: 'dan' };

console.log(Object.hasOwn(person, 'name'));// true
console.log(Object.hasOwn(person, 'age'));// false

const person2 = Object.create({gender: 'male'});

console.log(Object.hasOwn(person2, 'gender'));// false

在 Object.prototype.hasOwnProperty 上使用它的动机是什么？- 建议使用此方法，因为它也适用于使用和重写继承方法创建的对象。虽然可以通过调用外部对象来解决这类问题，但要克服这些问题，因此是首选（参见下面的示例）Object.hasOwnProperty()Object.create(null)hasOwnProperty()Object.prototype.hasOwnProperty()Object.hasOwn()

let person = {
  hasOwnProperty: function() {
    return false;
  },
  age: 35
};

if (Object.hasOwn(person, 'age')) {
  console.log(person.age); // true - the remplementation of hasOwnProperty() did not affect the Object
}

let person = Object.create(null);
person.age = 35;
if (Object.hasOwn(person, 'age')) {
  console.log(person.age); // true - works regardless of how the object was created
}

更多信息可以在这里找到： https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwnObject.hasOwn

浏览器兼容性 - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/hasOwn#browser_compatibilityObject.hasOwn

使用“反射”的替代方法

根据 MDN

Reflect 是一个内置对象，它提供了可截获的方法 JavaScript 操作。

静态 Reflect.has（） 方法的工作方式类似于 in 运算符，作为 功能。

var obj = {
  a: undefined,
  b: 1,
  c: "hello world"
}
console.log(Reflect.has(obj, 'a'))
console.log(Reflect.has(obj, 'b'))
console.log(Reflect.has(obj, 'c'))
console.log(Reflect.has(obj, 'd'))

我应该使用它吗？

这要视情况而定。

Reflect.has()比接受的答案中提到的其他方法慢（根据我的基准测试）。但是，如果你在代码中只使用它几次，我认为这种方法没有太大问题。

JS 双感叹号 ！！ 在这种情况下，符号可能会有所帮助。

const cars = {
        petrol:{
            price: 5000
        },
        gas:{
            price:8000
        }
    }

假设我们有上面的对象，如果您尝试用汽油价格记录汽车。

=> console.log(cars.petrol.price);
=> 5000

你肯定会从中得到 5000 美元。但是，如果您尝试获得一个 不存在的电动汽车，那么你会得到undefine

=> console.log(cars.electric);
=> undefine

但是使用 which 是将变量转换为 布尔值（true 或 false）。!!

=> console.log(!!cars.electric);
=> false

要查找对象中是否存在键，请使用

Object.keys(obj).includes(key)

ES7 包含方法检查数组是否包含项，&是 的更简单的替代方法。indexOf

const rawObject = {};
rawObject.propertyKey = 'somethingValue';

console.log(rawObject.hasOwnProperty('somethingValue'));
// expected output: true

检查给定对象中存在的特定键，hasOwnProperty 将在此处工作。

如果您在项目中配置了 ESLint，请遵循 ESLint 规则 no-prototype-builtins。原因已在以下链接中描述：

// bad
console.log(object.hasOwnProperty(key));

// good
console.log(Object.prototype.hasOwnProperty.call(object, key));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(object, key));
/* or */
import has from 'has'; // https://www.npmjs.com/package/has
console.log(has(object, key));

我这样做如下

const obj = { a: 1, b: 2, c: 3 };

// Using the 'in' operator
console.log('a' in obj); // true
console.log('d' in obj); // false

// Using the 'hasOwnProperty' method
console.log(obj.hasOwnProperty('b')); // true
console.log(obj.hasOwnProperty('d')); // false

const person = {
  id: 1,
  name: 'askavy',
  age: 23
}

**Method 1**
console.log(person.hasOwnProperty('name'))

**Method 2**
console.log('name' in person)    

**Method 3**
const checkKey = (obj , keyNmae) => {
   return Object.keys(obj).some((key) => {
      return key === keyNmae
   })
}

console.log(checkKey(person , 'name'))