Você tem que fazer isso passo a passo se você não quer um TypeError , porque se um dos membros é null ou undefined , e você tentar acessar um membro, uma exceção será lançada.

Você pode simplesmente catch a exceção ou fazer uma function para testar a existência de vários níveis, algo assim:

 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 

Aqui está um padrão que eu peguei de Oliver Steele :

 var level3 = (((test || {}).level1 || {}).level2 || {}).level3; alert( level3 ); 

Na verdade, esse artigo inteiro é uma discussão de como você pode fazer isso em javascript. Ele decide usar a syntax acima (que não é tão difícil de ler depois de se acostumar com isso) como uma expressão idiomática.

Atualizar

Parece que o lodash adicionou _.get para todas as suas necessidades aninhadas.

 _.get(countries, 'greece.sparta.playwright') 

https://lodash.com/docs#get

Resposta anterior

Os usuários do lodash podem desfrutar do lodash.contrib, que possui alguns methods que atenuam esse problema .

getPath

Assinatura: _.getPath(obj:Object, ks:String|Array)

Obtém o valor em qualquer profundidade em um object nested com base no caminho descrito pelas chaves fornecidas. As chaves podem ser dadas como um array ou como uma string separada por pontos. Retorna undefined se o caminho não puder ser alcançado.

 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 

Eu fiz testes de desempenho (obrigado cdMinix para adicionar lodash) em algumas das sugestões propostas para esta pergunta com os resultados listados abaixo.

Disclaimer # 1 Transformar strings em referências é meta-programação desnecessária e, provavelmente, é melhor evitar. Não perca de vista suas referências para começar. Leia mais desta resposta para uma pergunta semelhante .

Disclaimer # 2 Estamos falando de milhões de operações por milissegundo aqui. É muito improvável que qualquer um deles faça muita diferença na maioria dos casos de uso. Escolha o que fizer mais sentido, conhecendo as limitações de cada um. Para mim eu iria com algo como reduce por conveniência.

Object Wrap (por Oliver Steele) – 34% – mais rápido

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

Solução original (sugerida em questão) – 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; } 

Palhaços tristes - 100% - mais lentos

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

Você pode ler uma propriedade de object a qualquer profundidade, se você manipular o nome como uma string: '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'); 

Ele retorna undefined se qualquer um dos segmentos for undefined .

 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 abc; }), isset(function () { return abcdef; }) ); 

Se você estiver codificando no ambiente ES6 (ou usando 6to5 ), pode aproveitar a syntax da function de seta :

 // ES6 using the arrow function console.log( isset(() => abc), isset(() => abcdef) ); 

Em relação ao desempenho, não há penalidade de desempenho para usar o bloco try..catch se a propriedade estiver configurada. Há um impacto no desempenho se a propriedade não for definida.

Considere simplesmente usando _.has :

 var object = { 'a': { 'b': { 'c': 3 } } }; _.has(object, 'a'); // → true _.has(object, 'abc'); // → true _.has(object, ['a', 'b', 'c']); // → true 

e quanto a

 try { alert(test.level1.level2.level3) } catch(e) { ...whatever } 

Eu tentei uma abordagem recursiva:

 function objHasKeys(obj, keys) { var next = keys.shift(); return obj[next] && (! keys.length || objHasKeys(obj[next], keys)); } 

O ! keys.length || ! keys.length || sai da recursion para não executar a function sem nenhuma tecla para testar. Testes:

 obj = { path: { to: { the: { goodKey: "hello" } } } } console.log(objHasKeys(obj, ['path', 'to', 'the', 'goodKey'])); // true console.log(objHasKeys(obj, ['path', 'to', 'the', 'badKey'])); // undefined 

Eu estou usando para imprimir uma visão amigável em HTML de um monte de objects com valores / chaves desconhecidos, por exemplo:

 var biosName = objHasKeys(myObj, 'MachineInfo:BiosInfo:Name'.split(':')) ? myObj.MachineInfo.BiosInfo.Name : 'unknown'; 

Resposta ES6, exaustivamente testada 🙂

 const propExists = (obj, path) => { return !!path.split('.').reduce((obj, prop) => { return obj && obj[prop] ? obj[prop] : undefined; }, obj) } 

→ veja Codepen com cobertura de teste completa

Uma maneira simples é esta:

 try { alert(test.level1.level2.level3); } catch(e) { alert("undefined"); // this is optional to put any output here } 

O try/catch captura os casos para quando qualquer um dos objects de nível mais alto, como test, test.level1, test.level1.level2, não estiver definido.

Eu acho que o script a seguir dá uma representação mais legível.

declarar uma function:

 var o = function(obj) { return obj || {};}; 

então use-o assim:

 if (o(o(o(o(test).level1).level2).level3) { } 

Eu chamo de “técnica do palhaço triste” porque está usando o sinal o (

EDITAR:

aqui está uma versão para o TypeScript

ele dá verificações de tipo no tempo de compilation (assim como o intellisense se você usar uma ferramenta como o Visual Studio)

 export function o(someObject: T, defaultValue: T = {} as T) : T { if (typeof someObject === 'undefined' || someObject === null) return defaultValue; else return someObject; } 

o uso é o mesmo:

 o(o(o(o(test).level1).level2).level3 

mas desta vez intellisense funciona!

Além disso, você pode definir um valor padrão:

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

Eu não vi nenhum exemplo de alguém usando Proxies

Então eu criei o meu próprio. O melhor de tudo é que você não precisa interpolar strings. Você pode, na verdade, retornar uma function de object com capacidade de cadeia e fazer algumas coisas mágicas com ela. Você pode até chamar funções e obter índices de array para verificar objects profundos

 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 

Uma versão mais curta do ES5 da excelente resposta do @ CMS:

 // 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; } 

Com um teste similar:

 var test = { level1:{level2:{level3:'result'}}}; utils.checkObjHasKeys(test, ['level1', 'level2', 'level3']); // true utils.checkObjHasKeys(test, ['level1', 'level2', 'foo']); // false 

Com base nessa resposta , desenvolvi essa function genérica usando o ES2015 que resolveria o problema

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

A resposta dada pelo CMS funciona bem com a seguinte modificação para verificações nulas

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

As seguintes opções foram elaboradas a partir desta resposta . Mesma tree para ambos:

 var o = { a: { b: { c: 1 } } }; 

Parar de pesquisar quando estiver indefinido

 var u = undefined; oa ? oab ? oabc : u : u // 1 ox ? oxy ? oxyz : u : u // undefined (o = oa) ? (o = ob) ? oc : u : u // 1 

Assegure cada nível um por um

 var $ = function (empty) { return function (node) { return node || empty; }; }({}); $($(oa).b).c // 1 $($(ox).y).z // undefined 

Eu sei que esta pergunta é antiga, mas eu queria oferecer uma extensão adicionando isso a todos os objects. Eu sei que as pessoas tendem a frown usando o protótipo de object para a funcionalidade de object estendido, mas eu não acho nada mais fácil do que fazer isso. Além disso, agora é permitido com o método Object.defineProperty .

 Object.defineProperty( Object.prototype, "has", { value: function( needle ) { var obj = this; var needles = needle.split( "." ); for( var i = 0; i 

 if( obj.has("some.deep.nested.object.somewhere") )