我尝试了递归方法：

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

function propsExists(arg) {
  try {
    const result = arg()
  
    if (typeof result !== 'undefined') {
      return true
    }

    return false
  } catch (e) {
    return false;
  }
}

此函数还将测试0，null。如果他们在场，它也将返回真实。

例子：

函数propsExists（arg）{尝试{常量结果=arg（）if（结果类型！==“undefined”）{返回true}return false}捕获（e）{return false；}}让obj={测试：{a： 空，b： 0，c： 未定义，d： 4中，e： “嘿”，f： （）=>{}，g： 5.4中，h： 假，i： 真的，j： {}，k： []，我：{a： 1中，}}};console.log（'obj.test.a'，propsExists（（）=>obj.test/a））console.log（'obj.test.b'，propsExists（（）=>obj.test.b））console.log（'obj.test.c'，propsExists（（）=>obj.test.c））console.log（'obj.test.d'，propsExists（（）=>obj.test-d））console.log（'obj.test.e'，propsExists（（）=>obj.test.ex））console.log（'obj.test.f'，propsExists（（）=>obj.test-f））console.log（'obj.test.g'，propsExists（（）=>obj.test/g））console.log（'obj.test.h'，propsExists（（）=>obj.test.h））console.log（'obj.test.i'，propsExists（（）=>obj.test-i））console.log（'obj.test.j'，propsExists（（）=>obj.test.j））console.log（'obj.test.k'，propsExists（（）=>obj.test.k））console.log（'obj.test.l'，propsExists（（）=>obj.test/l））

我在寻找属性存在时返回的值，所以我通过上面的CMS修改了答案。下面是我想到的：

函数getNestedProperty（obj，key）{//从键字符串获取属性数组var财产=key.split（“.”）；//遍历财产，如果对象为空或属性不存在，则返回未定义的对于（var i=0；i<属性.length；i++）{if（！obj||！obj.hasOwnProperty（财产[i]））{回来}obj=obj[财产[i]]；}//找到嵌套属性，因此返回值返回obj；}用法：getNestedProperty（测试，“level.level2.level3”）//“level3”getNestedProperty（测试，“level.level2.foo”）//未定义

一个简单的方法是：

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）时的情况。

我认为下面的脚本提供了更可读的表示。

声明函数：

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

但这次intelligense奏效了！

此外，您可以设置默认值：

o(o(o(o(o(test).level1).level2).level3, "none")

我已经对这个问题提出的一些建议进行了性能测试（感谢cdMinix添加了lodash），结果如下。

免责声明#1将字符串转换为引用是不必要的元编程，可能最好避免。首先不要忘记你的推荐人。阅读类似问题的答案。免责声明#2我们在这里谈论的是每毫秒数百万次的操作。在大多数用例中，这些都不太可能产生很大的差异。了解每种方法的局限性，选择最有意义的方法。对我来说，我会采取一些类似于出于方便而减少的措施。

物体包裹（Oliver Steele）–34%–最快

var r1 = (((test || {}).level1 || {}).level2 || {}).level3;
var r2 = (((test || {}).level1 || {}).level2 || {}).foo;

原始解决方案（有疑问的建议）–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 }
}

有效链–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;
}

_.获得–72%

深度测试–86%

function deeptest(target, s){
    s= s.split('.')
    var obj= target[s.shift()];
    while(obj && s.length) obj= obj[s.shift()];
    return obj;
}

悲伤的小丑–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);