测试嵌套 JavaScript 对象键是不是存在
Posted
技术标签:
【中文标题】测试嵌套 JavaScript 对象键是不是存在【英文标题】：Test for existence of nested JavaScript object key测试嵌套 JavaScript 对象键是否存在 【发布时间】：2010-04-13 15:47:06 【问题描述】：如果我有一个对象的引用：
var test = ;
可能（但不是立即）具有嵌套对象，例如：
level1: level2: level3: "level3";
检查深度嵌套对象中是否存在属性的最佳方法是什么？
alert(test.level1); 产生 undefined，但 alert(test.level1.level2.level3); 失败。
我目前正在做这样的事情：
if(test.level1 && test.level1.level2 && test.level1.level2.level3)
alert(test.level1.level2.level3);
但我想知道是否有更好的方法。
【问题讨论】：
你可能想检查最近被问到的一个切线相关问题***.com/questions/2525943/… 另见***.com/questions/10918488/… 那里有几个命题：***.com/a/18381564/1636522 如果 level3 属性为 false，您当前的方法可能存在问题，在这种情况下，即使该属性存在也会返回 false，请查看此示例 jsfiddle.net/maz9bLjx 只是你也可以使用try catch 【参考方案1】：如果您不想要TypeError，则必须逐步执行此操作，因为如果其中一个成员是null 或undefined，并且您尝试访问某个成员，则会引发异常。
您可以简单地catch 异常，或者创建一个函数来测试多个级别的存在，如下所示：
function checkNested(obj /*, level1, level2, ... levelN*/)
var args = Array.prototype.slice.call(arguments, 1);
for (var i = 0; i < args.length; i++)
if (!obj || !obj.hasOwnProperty(args[i]))
return false;
obj = obj[args[i]];
return true;
var test = level1:level2:level3:'level3' ;
checkNested(test, 'level1', 'level2', 'level3'); // true
checkNested(test, 'level1', 'level2', 'foo'); // false
ES6 更新：
这里是原始函数的一个更短的版本，使用 ES6 特性和递归（它也是proper tail call 形式）：
function checkNested(obj, level, ...rest)
if (obj === undefined) return false
if (rest.length == 0 && obj.hasOwnProperty(level)) return true
return checkNested(obj[level], ...rest)
但是，如果你想获取嵌套属性的值而不只是检查它的存在，这里有一个简单的单行函数：
function getNested(obj, ...args)
return args.reduce((obj, level) => obj && obj[level], obj)
const test = level1: level2: level3:'level3' ;
console.log(getNested(test, 'level1', 'level2', 'level3')); // 'level3'
console.log(getNested(test, 'level1', 'level2', 'level3', 'length')); // 6
console.log(getNested(test, 'level1', 'level2', 'foo')); // undefined
console.log(getNested(test, 'a', 'b')); // undefined上面的函数可以让你获取嵌套属性的值，否则会返回undefined。
2019 年 10 月 17 日更新：
optional chaining proposal 在ECMAScript committee process 上达到了第 3 阶段，这将允许您使用令牌 ?. 安全地访问深度嵌套的属性，新的可选链运算符： p>
const value = obj?.level1?.level2?.level3
如果访问的任何级别是 null 或 undefined，则表达式将自行解析为 undefined。
该提案还允许您安全地处理方法调用：
obj?.level1?.method();
如果obj、obj.level1或obj.level1.method是null或undefined，上述表达式将产生undefined，否则将调用该函数。
您可以使用 optional chaining plugin 开始使用 Babel 使用此功能。
由于Babel 7.8.0，默认支持ES2020
在 Babel REPL 上检查 this example。
??更新：2019 年 12 月??
在 2019 年 12 月的 TC39 委员会会议上，可选链提案终于 reached Stage 4。这意味着此功能将成为 ECMAScript 2020 标准的一部分。
【讨论】：
arguments 实际上不是一个数组。 Array.prototype.slice.call(arguments) 将其转换为正式数组。 Learn
这将是 a lot more efficient 执行 var obj = arguments[0]; 并从 var i = 1 开始，而不是复制 arguments 对象
为了紧缩的缘故，我将一个带有 try/catch 的版本放在一起，这并不奇怪 - 性能很糟糕（出于某种原因在 Safari 中除外）。下面有一些非常高效的答案，以及 Claudiu 的修改，它也比选定的答案更高效。在此处查看 jsperf jsperf.com/check-if-deep-property-exists-with-willnotthrow
在 ES6 中，args 变量声明可以被删除，...args 可以用作checkNested 方法的第二个参数。 developer.mozilla.org/en/docs/Web/javascript/Reference/…
这是一个非常不可维护的。如果任何属性键更改（它们会更改），项目中的所有开发人员都必须“字符串搜索”整个代码库。这并不是问题的真正解决方案，因为它引入了一个更大的问题【参考方案2】：
这是我picked up from Oliver Steele的模式：
var level3 = (((test || ).level1 || ).level2 || ).level3;
alert( level3 );
事实上，整篇文章都是在讨论如何在 javascript 中做到这一点。他决定使用上述语法（一旦习惯了就不会那么难读）作为习语。
【讨论】：
@wared 我认为有趣的是它的简洁程度。链接帖子中详细讨论了性能特征。是的，它总是进行所有测试，但它避免创建临时变量，如果你想防止每次创建新的空对象的开销，你可以将 别名为 var。在 99% 的情况下，我认为速度无关紧要，而且在确实如此的情况下，分析是无可替代的。 @MuhammadUmer 不，(test || ) 的重点是，如果未定义测试，那么您正在执行(.level1 || )。当然，.level1 是未定义的，所以这意味着你正在做.level2，等等。
@JoshuaTaylor：我认为他的意思是如果test 没有声明，就会出现ReferenceError，但这不是问题，因为如果没有声明，就会出现一个要修复的错误，所以错误是一件好事。
你说“这不是那么难阅读一次你习惯” 。嗯，这些是你知道已经是一团糟的迹象。那为什么建议这个解决方案呢？它容易出现拼写错误，并且绝对没有可读性。看看吧！如果我不得不写出丑陋的一行，它也应该是可读的；所以我会坚持if(test.level1 && test.level1.level2 && test.level1.level2.level3)
除非我遗漏了什么，否则这不适用于可能是错误的布尔最终属性......遗憾的是。否则我喜欢这个成语。【参考方案3】：
更新
看起来像 lodash has added _.get 满足您所有嵌套属性的获取需求。
_.get(countries, 'greece.sparta.playwright')
https://lodash.com/docs#get
上一个答案
lodash 用户可能会喜欢lodash.contrib，它有一个couple methods that mitigate this problem。
获取路径
签名： _.getPath(obj:Object, ks:String|Array)
根据描述的路径获取嵌套对象中任意深度的值
给出的键。键可以作为数组或以点分隔的字符串给出。
如果无法到达路径，则返回 undefined。
var countries =
greece:
athens:
playwright: "Sophocles"
;
_.getPath(countries, "greece.athens.playwright");
// => "Sophocles"
_.getPath(countries, "greece.sparta.playwright");
// => undefined
_.getPath(countries, ["greece", "athens", "playwright"]);
// => "Sophocles"
_.getPath(countries, ["greece", "sparta", "playwright"]);
// => undefined
【讨论】：
Lodash 确实需要一个 _.isPathDefined(obj, pathString) 方法。 @MatthewPayne 也许会很好，但实际上没有必要。你可以很容易地自己做function isPathDefined(object, path) return typeof _.getPath(object, path) !== 'undefined';
Lodash 本身也有同样的功能：_.get(countries, 'greece.sparta.playwright', 'default'); // → 'default' _.has(countries, 'greece.spart.playwright') // → false
更好的是_.result
如果您需要确定多个不同的路径，请考虑：var url = _.get(e, 'currentTarget.myurl', null) || _.get(e, 'currentTarget.attributes.myurl.nodeValue', null) || null【参考方案4】：
我已经完成了performance tests（感谢cdMinix添加lodash）针对这个问题提出的一些建议，结果如下。
免责声明 #1 将字符串转换为引用是不必要的元编程，最好避免。不要一开始就忘记你的参考资料。 Read more from this answer to a similar question.
免责声明 #2 我们在这里谈论的是每毫秒数百万次操作。在大多数用例中，这些都不太可能产生很大的不同。在了解每个限制的情况下选择最有意义的那个。对我来说，出于方便，我会选择
reduce之类的东西。
Object Wrap (by Oliver Steele) – 34 % – 最快
var r1 = (((test || ).level1 || ).level2 || ).level3;
var r2 = (((test || ).level1 || ).level2 || ).foo;
Original solution (suggested in question) – 45%
var r1 = test.level1 && test.level1.level2 && test.level1.level2.level3;
var r2 = test.level1 && test.level1.level2 && test.level1.level2.foo;
checkNested – 50%
function checkNested(obj)
for (var i = 1; i < arguments.length; i++)
if (!obj.hasOwnProperty(arguments[i]))
return false;
obj = obj[arguments[i]];
return true;
get_if_exist – 52%
function get_if_exist(str)
try return eval(str)
catch(e) return undefined
validChain – 54%
function validChain( object, ...keys )
return keys.reduce( ( a, b ) => ( a || )[ b ], object ) !== undefined;
objHasKeys – 63%
function objHasKeys(obj, keys)
var next = keys.shift();
return obj[next] && (! keys.length || objHasKeys(obj[next], keys));
nestedPropertyExists – 69%
function nestedPropertyExists(obj, props)
var prop = props.shift();
return prop === undefined ? true : obj.hasOwnProperty(prop) ? nestedPropertyExists(obj[prop], props) : false;
_.get – 72%
deeptest – 86%
function deeptest(target, s)
s= s.split('.')
var obj= target[s.shift()];
while(obj && s.length) obj= obj[s.shift()];
return obj;
sad clowns – 100% – 最慢
var o = function(obj) return obj || ;
var r1 = o(o(o(o(test).level1).level2).level3);
var r2 = o(o(o(o(test).level1).level2).foo);
【讨论】：
应该注意的是，测试的百分比越多，它就越慢 lodash_.get() 怎么样？与这些答案相比，它的性能如何？
根据具体情况，其中每种方法都比其他方法慢或快。如果找到所有键，则“对象包装”可能最快，但如果未找到其中一个键，则“本机解决方案/原始解决方案”可能更快。
@evilReiko 如果没有找到密钥，任何方法都会变慢，但按彼此的比例，它仍然几乎相同。然而，你是对的——这比其他任何事情都更像是一种智力练习。我们在这里谈论的是每毫秒一百万次迭代。我看不到任何用例会产生很大的不同。就我个人而言，出于方便，我会选择reduce 或try/catch。
与try test.level1.level2.level3 catch (e) // some logger e 相比性能如何【参考方案5】：
如果您像处理字符串一样处理名称，则可以读取任意深度的对象属性：'t.level1.level2.level3'。
window.t=level1:level2:level3: 'level3';
function deeptest(s)
s= s.split('.')
var obj= window[s.shift()];
while(obj && s.length) obj= obj[s.shift()];
return obj;
alert(deeptest('t.level1.level2.level3') || 'Undefined');
如果任何段是undefined，则返回undefined。
【讨论】：
值得注意的是，这种方法非常高效，至少在 Chrome 中，在某些情况下优于所选答案的 @Claudiu 修改版本。在此处查看性能测试：jsperf.com/check-if-deep-property-exists-with-willnotthrow【参考方案6】：var a;
a =
b:
c: 'd'
;
function isset (fn)
var value;
try
value = fn();
catch (e)
value = undefined;
finally
return value !== undefined;
;
// ES5
console.log(
isset(function () return a.b.c; ),
isset(function () return a.b.c.d.e.f; )
);
如果您在 ES6 环境中编码（或使用 6to5），那么您可以利用 arrow function 语法：
// ES6 using the arrow function
console.log(
isset(() => a.b.c),
isset(() => a.b.c.d.e.f)
);
关于性能，如果设置了属性，则使用try..catch 块没有性能损失。如果未设置该属性，则会影响性能。
考虑简单地使用_.has：
var object = 'a': 'b': 'c': 3 ;
_.has(object, 'a');
// → true
_.has(object, 'a.b.c');
// → true
_.has(object, ['a', 'b', 'c']);
// → true
【讨论】：
我认为try-catch 方法是最好的答案。查询对象的类型与假设 API 存在并且如果不存在则相应地失败之间存在哲学差异。后者更适合松散类型的语言。见***.com/a/408305/2419669。 try-catch 方法也比if (foo && foo.bar && foo.bar.baz && foo.bar.baz.qux) ... 清晰得多。【参考方案7】：
怎么样
try
alert(test.level1.level2.level3)
catch(e)
...whatever
【讨论】：
我不认为 try/catch 是测试对象是否存在的好方法：try/catch 旨在处理异常，而不是正常情况，例如此处的测试。我认为 (typeof foo == "undefined") 在每一步都更好——一般来说，如果您使用如此深层次的嵌套属性，可能需要进行一些重构。此外，如果抛出异常，try/catch 将导致 Firebug 中断（以及在任何打开错误中断的浏览器中）。 我对此投票，因为如果您使用其他解决方案，浏览器会检查两次是否存在。假设您想调用“a.c.b = 2”。浏览器必须在修改值之前检查是否存在（否则会被操作系统捕获到内存错误）。 问题仍然存在：对于浏览器设置 try catch 或调用hasOwnProperty() n 次，女巫更快？
为什么又变坏了？这对我来说看起来最干净。
我想说：如果您期望该属性存在，那么可以将其包装到 try 块中。如果它不存在，那就是一个错误。但是，如果您只是懒惰并在属性不存在的情况下将常规代码放入 catch 块中，则 try/catch 被滥用。这里需要 if/else 或类似的东西。【参考方案8】：
您还可以将 tc39 可选链提议与 babel 7 - tc39-proposal-optional-chaining 一起使用
代码如下所示：
const test = test?.level1?.level2?.level3;
if (test) alert(test);
【讨论】：
请注意，这种语法几乎肯定会改变，因为一些 TC39 成员有异议。 可能，但它会及时以某种形式提供，这是唯一重要的事情..这是我在 JS 中最怀念的功能之一。【参考方案9】：ES6 答案，经过彻底测试:)
const propExists = (obj, path) =>
return !!path.split('.').reduce((obj, prop) =>
return obj && obj[prop] ? obj[prop] : undefined;
, obj)
→见Codepen with full test coverage
【讨论】：
我让你的测试失败，将 flat prop 的值设置为 0。你必须关心类型强制。 @germain this 是否适合您？ （我明确比较了=== 的不同 falsys，并添加了测试。如果您有更好的想法，请告诉我）。
我让你的测试再次失败，将 flat prop 的值设置为false。然后您可能希望将对象中的值设置为undefined（我知道这很奇怪，但它是 JS）。我将一个正假值设置为'Prop not Found':const hasTruthyProp = prop => prop === 'Prop not found' ? false : true const path = obj => path => path.reduce((obj, prop) => return obj && obj.hasOwnProperty(prop) ? obj[prop] : 'Prop not found' , obj) const myFunc = compose(hasTruthyProp, path(obj))
你能分叉我的代码笔（右上角，简单），更正和添加测试，并将你的 URL 发送给我吗？谢谢=)
逃到（巨大的）第 3 方图书馆……可能，但不是我的偏好。【参考方案10】：
我尝试了递归方法：
function objHasKeys(obj, keys)
var next = keys.shift();
return obj[next] && (! keys.length || objHasKeys(obj[next], keys));
! keys.length || 退出递归，因此它不会运行该函数，并且没有剩下要测试的键。测试：
obj =
path:
to:
the:
goodKey: "hello"
console.log(objHasKeys(obj, ['path', 'to', 'the', 'goodKey'])); // true
console.log(objHasKeys(obj, ['path', 'to', 'the', 'badKey'])); // undefined
我正在使用它来打印一堆具有未知键/值的对象的友好 html 视图，例如：
var biosName = objHasKeys(myObj, 'MachineInfo:BiosInfo:Name'.split(':'))
? myObj.MachineInfo.BiosInfo.Name
: 'unknown';
【讨论】：
【参考方案11】：我认为以下脚本提供了更具可读性的表示。
声明一个函数：
var o = function(obj) return obj || ;;
然后像这样使用它：
if (o(o(o(o(test).level1).level2).level3)
我称它为“悲伤的小丑技术”，因为它使用了符号 o(
编辑：
这里是 TypeScript 的版本
它在编译时提供类型检查（如果您使用 Visual Studio 之类的工具，还提供智能感知）
export function o<T>(someObject: T, defaultValue: T = as T) : T
if (typeof someObject === 'undefined' || someObject === null)
return defaultValue;
else
return someObject;
用法相同：
o(o(o(o(test).level1).level2).level3
但这一次智能感知有效！
另外，你可以设置一个默认值：
o(o(o(o(o(test).level1).level2).level3, "none")
【讨论】：
°0o <°(())))><
我喜欢这个，因为它很诚实，当你不知道你的Object 类型时，它会在你脸上抛出一个“未定义”。 +1。
只要你把声明放在括号里你也可以称之为快乐小丑技术（o
感谢 Sventies。我喜欢你的评论。这是一个非常好的视角——这样的条件主要用于“ifs”并且总是用外部括号括起来。所以，是的，它确实是一个快乐的小丑:)))
你真的需要爱上括号才能找到这个......【参考方案12】：
这个问题很老了。今天你可以使用可选链 (?.)
let value = test?.level1?.level2?.level3;
来源：
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Optional_chaining
【讨论】：
【参考方案13】：创建一个全局function 并在整个项目中使用
试试这个
function isExist(arg)
try
return arg();
catch(e)
return false;
let obj=a:5,b:c:5;
console.log(isExist(()=>obj.b.c))
console.log(isExist(()=>obj.b.foo))
console.log(isExist(()=>obj.test.foo))如果条件
if(isExist(()=>obj.test.foo))
....
【讨论】：
这会吞下可能发生的任何其他错误。【参考方案14】：我没有看到有人使用Proxies的例子
所以我想出了我自己的。
它的好处是您不必插入字符串。你实际上可以返回一个可链接的 object 函数并用它做一些神奇的事情。您甚至可以调用函数并获取数组索引来检查深层对象
function resolve(target)
var noop = () => // We us a noop function so we can call methods also
return new Proxy(noop,
get(noop, key)
// return end result if key is _result
return key === '_result'
? target
: resolve( // resolve with target value or undefined
target === undefined ? undefined : target[key]
)
,
// if we want to test a function then we can do so alos thanks to using noop
// instead of using target in our proxy
apply(noop, that, args)
return resolve(typeof target === 'function' ? target.apply(that, args) : undefined)
,
)
// some modified examples from the accepted answer
var test = level1: level2:() => (level3:'level3')
var test1 = key1: key2: ['item0']
// You need to get _result in the end to get the final result
console.log(resolve(test).level1.level2().level3._result)
console.log(resolve(test).level1.level2().level3.level4.level5._result)
console.log(resolve(test1).key1.key2[0]._result)
console.log(resolve(test1)[0].key._result) // don't exist上面的代码适用于同步的东西。但是你将如何测试像这个 ajax 调用这样的异步的东西呢？ 你如何测试它？
fetch('https://httpbin.org/get')
.then(function(response)
return response.json()
)
.then(function(json)
console.log(json.headers['User-Agent'])
)
确定您可以使用 async/await 来摆脱一些回调。但是，如果您可以更神奇地做到这一点呢？看起来像这样的东西：
fetch('https://httpbin.org/get').json().headers['User-Agent']
您可能想知道所有 promise 和 .then 链在哪里...这可能会阻塞您所知道的...但是使用与 promise 相同的代理技术，您实际上可以测试深度嵌套的复杂路径是否存在从来没有写过一个函数
function resolve(target)
return new Proxy(() => ,
get(noop, key)
return key === 'then' ? target.then.bind(target) : resolve(
Promise.resolve(target).then(target =>
if (typeof target[key] === 'function') return target[key].bind(target)
return target[key]
)
)
,
apply(noop, that, args)
return resolve(target.then(result =>
return result.apply(that, args)
))
,
)
// this feels very much synchronous but are still non blocking :)
resolve(window) // this will chain a noop function until you call then()
.fetch('https://httpbin.org/get')
.json()
.headers['User-Agent']
.then(console.log, console.warn) // you get a warning if it doesn't exist
// You could use this method also for the first test object
// also, but it would have to call .then() in the end
// Another example
resolve(window)
.fetch('https://httpbin.org/get?items=4&items=2')
.json()
.args
.items
// nice that you can map an array item without even having it ready
.map(n => ~~n * 4)
.then(console.log, console.warn) // you get a warning if it doesn't exist【讨论】：
如果有人感兴趣，我已经在npm发布了异步版本【参考方案15】：一个简单的方法是这样的：
try
alert(test.level1.level2.level3);
catch(e)
alert("undefined"); // this is optional to put any output here
try/catch 捕获未定义任何更高级别对象（例如 test、test.level1、test.level1.level2）的情况。
【讨论】：
【参考方案16】：基于this answer，我使用ES2015提出了这个通用函数，可以解决问题
function validChain( object, ...keys )
return keys.reduce( ( a, b ) => ( a || )[ b ], object ) !== undefined;
var test =
first:
second:
third: "This is not the key your are looking for"
if ( validChain( test, "first", "second", "third" ) )
console.log( test.first.second.third );
【讨论】：
这是我的最终方法function validChain (object, path) return path.split('.').reduce((a, b) => (a || )[b], object) !== undefined 【参考方案17】：
我创建了一个小函数来安全地获取嵌套对象属性。
function getValue(object, path, fallback, fallbackOnFalsy)
if (!object || !path)
return fallback;
// Reduces object properties to the deepest property in the path argument.
return path.split('.').reduce((object, property) =>
if (object && typeof object !== 'string' && object.hasOwnProperty(property))
// The property is found but it may be falsy.
// If fallback is active for falsy values, the fallback is returned, otherwise the property value.
return !object[property] && fallbackOnFalsy ? fallback : object[property];
else
// Returns the fallback if current chain link does not exist or it does not contain the property.
return fallback;
, object);
或者一个更简单但有点不可读的版本：
function getValue(o, path, fb, fbFalsy)
if(!o || !path) return fb;
return path.split('.').reduce((o, p) => o && typeof o !== 'string' && o.hasOwnProperty(p) ? !o[p] && fbFalsy ? fb : o[p] : fb, o);
甚至更短，但不使用 falsy 标志：
function getValue(o, path, fb)
if(!o || !path) return fb;
return path.split('.').reduce((o, p) => o && typeof o !== 'string' && o.hasOwnProperty(p) ? o[p] : fb, o);
我有测试：
const obj =
c:
a: 2,
b:
c: [1, 2, 3, a: 15, b: 10, 15]
,
c: undefined,
d: null
,
d: ''
这里有一些测试：
// null
console.log(getValue(obj, 'c.d', 'fallback'));
// array
console.log(getValue(obj, 'c.b.c', 'fallback'));
// array index 2
console.log(getValue(obj, 'c.b.c.2', 'fallback'));
// no index => fallback
console.log(getValue(obj, 'c.b.c.10', 'fallback'));
要查看包含文档的所有代码以及我尝试过的测试，您可以查看我的 github 要点： https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js
【讨论】：
【参考方案18】：@CMS 出色答案的更短的 ES5 版本：
// Check the obj has the keys in the order mentioned. Used for checking JSON results.
var checkObjHasKeys = function(obj, keys)
var success = true;
keys.forEach( function(key)
if ( ! obj.hasOwnProperty(key))
success = false;
obj = obj[key];
)
return success;
通过类似的测试：
var test = level1:level2:level3:'result';
utils.checkObjHasKeys(test, ['level1', 'level2', 'level3']); // true
utils.checkObjHasKeys(test, ['level1', 'level2', 'foo']); // false
【讨论】：
唯一的问题是如果有多个级别的未定义键，那么你会得到一个 TypeError，例如checkObjHasKeys(test, ['level1', 'level2', 'asdf', 'asdf']);
比较合适的方法是every，其值可以直接返回。
也许将success = false; 更改为return false。一旦你知道它坏了，你就应该退出，一旦它为空或未定义，就没有更深的存在了。这将防止更深嵌套项的错误，因为它们显然也不存在。【参考方案19】：
如果属性存在，我正在寻找要返回的值，所以我修改了上面 CMS 的答案。这是我想出的：
function getNestedProperty(obj, key)
// Get property array from key string
var properties = key.split(".");
// Iterate through properties, returning undefined if object is null or property doesn't exist
for (var i = 0; i < properties.length; i++)
if (!obj || !obj.hasOwnProperty(properties[i]))
return;
obj = obj[properties[i]];
// Nested property found, so return the value
return obj;
Usage:
getNestedProperty(test, "level1.level2.level3") // "level3"
getNestedProperty(test, "level1.level2.foo") // undefined【讨论】：
【参考方案20】：CMS 给出的答案也适用于空检查的以下修改
function checkNested(obj /*, level1, level2, ... levelN*/)
var args = Array.prototype.slice.call(arguments),
obj = args.shift();
for (var i = 0; i < args.length; i++)
if (obj == null || !obj.hasOwnProperty(args[i]) )
return false;
obj = obj[args[i]];
return true;
【讨论】：
【参考方案21】：从this answer 开始详细阐述了以下选项。两者都是同一棵树：
var o = a: b: c: 1 ;
未定义时停止搜索
var u = undefined;
o.a ? o.a.b ? o.a.b.c : u : u // 1
o.x ? o.x.y ? o.x.y.z : u : u // undefined
(o = o.a) ? (o = o.b) ? o.c : u : u // 1
一层一层保证每一层
var $ = function (empty)
return function (node)
return node || empty;
;
();
$($(o.a).b).c // 1
$($(o.x).y).z // undefined
【讨论】：
【参考方案22】：我知道这个问题很老，但我想通过将它添加到所有对象来提供扩展。我知道人们倾向于不赞成使用对象原型来扩展对象功能，但我没有发现比这样做更容易的事情了。另外，现在可以使用 Object.defineProperty 方法。
Object.defineProperty( Object.prototype, "has", value: function( needle )
var obj = this;
var needles = needle.split( "." );
for( var i = 0; i<needles.length; i++ )
if( !obj.hasOwnProperty(needles[i]))
return false;
obj = obj[needles[i]];
return true;
);
现在，为了测试任何对象中的任何属性，您只需执行以下操作：
if( obj.has("some.deep.nested.object.somewhere") )
Here's a jsfiddle 来测试它，特别是它包含一些 jQuery，如果你直接修改 Object.prototype 会因为属性变得可枚举而中断。这应该适用于 3rd 方库。
【讨论】：
【参考方案23】：我认为这是一个轻微的改进（成为 1-liner）：
alert( test.level1 && test.level1.level2 && test.level1.level2.level3 )
这是可行的，因为 && 运算符返回它评估的最终操作数（并且它会短路）。
【讨论】：
你从字面上复制了他们通常所说的内容，并想避免......【参考方案24】：这适用于所有对象和数组 :)
例如：
if( obj._has( "something.['deep']['under'][1][0].item" ) )
//do something
这是我对布赖恩回答的改进版
我使用 _has 作为属性名称，因为它可能与现有的 has 属性冲突（例如：地图）
Object.defineProperty( Object.prototype, "_has", value: function( needle )
var obj = this;
var needles = needle.split( "." );
var needles_full=[];
var needles_square;
for( var i = 0; i<needles.length; i++ )
needles_square = needles[i].split( "[" );
if(needles_square.length>1)
for( var j = 0; j<needles_square.length; j++ )
if(needles_square[j].length)
needles_full.push(needles_square[j]);
else
needles_full.push(needles[i]);
for( var i = 0; i<needles_full.length; i++ )
var res = needles_full[i].match(/^((\d+)|"(.+)"|'(.+)')\]$/);
if (res != null)
for (var j = 0; j < res.length; j++)
if (res[j] != undefined)
needles_full[i] = res[j];
if( typeof obj[needles_full[i]]=='undefined')
return false;
obj = obj[needles_full[i]];
return true;
);
这是fiddle
【讨论】：
【参考方案25】：这是我的看法 - 这些解决方案中的大多数都忽略了嵌套数组的情况，如下所示：
obj =
"l1":"something",
"l2":[k:0,k:1],
"l3":
"subL":"hello"
我可能想检查obj.l2[0].k
通过下面的函数，你可以做到deeptest('l2[0].k',obj)
如果对象存在则函数返回true，否则返回false
function deeptest(keyPath, testObj)
var obj;
keyPath = keyPath.split('.')
var cKey = keyPath.shift();
function get(pObj, pKey)
var bracketStart, bracketEnd, o;
bracketStart = pKey.indexOf("[");
if (bracketStart > -1) //check for nested arrays
bracketEnd = pKey.indexOf("]");
var arrIndex = pKey.substr(bracketStart + 1, bracketEnd - bracketStart - 1);
pKey = pKey.substr(0, bracketStart);
var n = pObj[pKey];
o = n? n[arrIndex] : undefined;
else
o = pObj[pKey];
return o;
obj = get(testObj, cKey);
while (obj && keyPath.length)
obj = get(obj, keyPath.shift());
return typeof(obj) !== 'undefined';
var obj =
"l1":"level1",
"arr1":[
"k":0,
"k":1,
"k":2
],
"sub":
"a":"letter A",
"b":"letter B"
;
console.log("l1: " + deeptest("l1",obj));
console.log("arr1[0]: " + deeptest("arr1[0]",obj));
console.log("arr1[1].k: " + deeptest("arr1[1].k",obj));
console.log("arr1[1].j: " + deeptest("arr1[1].j",obj));
console.log("arr1[3]: " + deeptest("arr1[3]",obj));
console.log("arr2: " + deeptest("arr2",obj));【讨论】：
【参考方案26】：现在我们还可以使用reduce 来循环嵌套键：
// @params o<object>
// @params path<string> expects 'obj.prop1.prop2.prop3'
// returns: obj[path] value or 'false' if prop doesn't exist
const objPropIfExists = o => path =>
const levels = path.split('.');
const res = (levels.length > 0)
? levels.reduce((a, c) => a[c] || 0, o)
: o[path];
return (!!res) ? res : false
const obj =
name: 'Name',
sys: country: 'AU' ,
main: temp: '34', temp_min: '13' ,
visibility: '35%'
const exists = objPropIfExists(obj)('main.temp')
const doesntExist = objPropIfExists(obj)('main.temp.foo.bar.baz')
console.log(exists, doesntExist)【讨论】：
【参考方案27】：您可以使用递归函数来做到这一点。即使您不知道所有嵌套的对象键名称，这也可以工作。
function FetchKeys(obj)
let objKeys = [];
let keyValues = Object.entries(obj);
for (let i in keyValues)
objKeys.push(keyValues[i][0]);
if (typeof keyValues[i][1] == "object")
var keys = FetchKeys(keyValues[i][1])
objKeys = objKeys.concat(keys);
return objKeys;
let test = level1: level2: level3: "level3" ;
let keyToCheck = "level2";
let keys = FetchKeys(test); //Will return an array of Keys
if (keys.indexOf(keyToCheck) != -1)
//Key Exists logic;
else
//Key Not Found logic;
【讨论】：
【参考方案28】：还有一个非常紧凑的：
function ifSet(object, path)
return path.split('.').reduce((obj, part) => obj && obj[part], object)
调用：
let a = b:c:d:e:'found!'
ifSet(a, 'b.c.d.e') == 'found!'
ifSet(a, 'a.a.a.a.a.a') == undefined
它的性能不会很好，因为它会拆分字符串（但会增加调用的可读性）并迭代所有内容，即使已经很明显找不到任何内容（但会增加函数本身的可读性）。
至少比_.gethttp://jsben.ch/aAtmc快
【讨论】：
【参考方案29】：我已经使用这个函数来访问深度嵌套对象的属性，它对我有用...
这是函数
/**
* get property of object
* @param obj object
* @param path e.g user.name
*/
getProperty(obj, path, defaultValue = '-')
const value = path.split('.').reduce((o, p) => o && o[p], obj);
return value ? value : defaultValue;
这就是我访问深度嵌套对象属性的方式
getProperty(object, 'passengerDetails.data.driverInfo.currentVehicle.vehicleType')
【讨论】：
【参考方案30】：有一个函数here on thecodeabode (safeRead) 可以安全地执行此操作...即
safeRead(test, 'level1', 'level2', 'level3');
如果任何属性为 null 或未定义，则返回一个空字符串
【讨论】：
我有点喜欢这种带有模板的方法，因为如果没有设置它会返回一个空字符串以上是关于测试嵌套 JavaScript 对象键是不是存在的主要内容，如果未能解决你的问题，请参考以下文章
javascript javascript测试是否存在嵌套对象键