Si tengo una referencia a un objeto:

var test = {};

que potencialmente (pero no inmediatamente) tendrá objetos anidados, algo como:

{level1: {level2: {level3: "level3"}}};

¿Cuál es la mejor manera de verificar la existencia de propiedades en objetos profundamente anidados?

alert(test.level1);cede undefined, pero alert(test.level1.level2.level3);falla.

Actualmente estoy haciendo algo como esto:

if(test.level1 && test.level1.level2 && test.level1.level2.level3) {
    alert(test.level1.level2.level3);
}

pero me preguntaba si hay una mejor manera.

Tienes que hacerlo paso a paso si no quieres un TypeErrorporque si uno de los miembros es nullo undefined, e intentas acceder a un miembro, se lanzará una excepción.

Puede simplemente catchla excepción, o hacer una función para probar la existencia de múltiples niveles, algo como esto:

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

ACTUALIZACIÓN ES6:

Aquí hay una versión más corta de la función original, que usa las funciones y la recursión de ES6 (también está en forma de cola ):

function checkNested(obj, level,  ...rest) {
  if (obj === undefined) return false
  if (rest.length == 0 && obj.hasOwnProperty(level)) return true
  return checkNested(obj[level], ...rest)
}

Sin embargo, si desea obtener el valor de una propiedad anidada y no solo verificar su existencia, aquí hay una función simple de una línea:

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

La función anterior le permite obtener el valor de las propiedades anidadas, de lo contrario volverá undefined.

ACTUALIZACIÓN 2019-10-17:

La propuesta de encadenamiento opcional alcanzó la Etapa 3 en el proceso del comité ECMAScript , esto le permitirá acceder de manera segura a propiedades profundamente anidadas, utilizando el token ?., el nuevo operador de encadenamiento opcional :

const value = obj?.level1?.level2?.level3 

Si alguno de los niveles accedidos es nullo undefinedla expresión se resolverá undefinedpor sí misma.

La propuesta también le permite manejar llamadas a métodos de manera segura:

obj?.level1?.method();

La expresión anterior producirá undefinedif obj, obj.level1or obj.level1.methodare nullo undefined, de lo contrario, llamará a la función.

Puedes comenzar a jugar con esta función con Babel usando el complemento de encadenamiento opcional .

Desde Babel 7.8.0 , ES2020 es compatible por defecto

Verifique este ejemplo en el REPL de Babel.

🎉🎉 ACTUALIZACIÓN: diciembre de 2019 🎉🎉

La propuesta de encadenamiento opcional finalmente alcanzó la Etapa 4 en la reunión de diciembre de 2019 del comité TC39. Esto significa que esta característica será parte del Estándar ECMAScript 2020 .

Aquí hay un patrón que tomé de Oliver Steele :

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

De hecho, todo el artículo es una discusión sobre cómo puede hacer esto en javascript. Él decide usar la sintaxis anterior (que no es tan difícil de leer una vez que te acostumbras) como idioma.

Actualizar

Parece que lodash ha agregado _.get todas sus necesidades de obtención de propiedades anidadas.

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

https://lodash.com/docs#get

Respuesta anterior

Los usuarios de lodash pueden disfrutar de lodash.contrib que tiene un par de métodos que mitigan este problema .

getPath

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

Obtiene el valor a cualquier profundidad en un objeto anidado en función de la ruta descrita por las claves proporcionadas. Las claves se pueden dar como una matriz o como una cadena separada por puntos. Devuelve undefinedsi no se puede llegar a la ruta.

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

He realizado pruebas de rendimiento (gracias cdMinix por agregar lodash) en algunas de las sugerencias propuestas para esta pregunta con los resultados que se enumeran a continuación.

Descargo de responsabilidad # 1 Convertir cadenas en referencias es una metaprogramación innecesaria y probablemente sea mejor evitarla. Para empezar, no pierdas de vista tus referencias. Lea más de esta respuesta a una pregunta similar .

Descargo de responsabilidad # 2 Estamos hablando de millones de operaciones por milisegundo aquí. Es muy poco probable que alguno de estos haga mucha diferencia en la mayoría de los casos de uso. Elija lo que tenga más sentido conociendo las limitaciones de cada uno. Para mí iría con algo como reducepor conveniencia.

Envoltura de objetos (por Oliver Steele) - 34% - más rápido

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

Solución original (sugerida en la pregunta) - 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 }
}

Cadena válida - 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%

más profundo - 86%

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

payasos tristes - 100% - más lento

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

Usted puede leer una propiedad de objeto a cualquier profundidad, si se maneja el nombre como una cadena: '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');

Regresa undefinedsi alguno de los segmentos es 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 a.b.c; }),
    isset(function () { return a.b.c.d.e.f; })
);

Si está codificando en el entorno ES6 (o utilizando 6to5 ), puede aprovechar la sintaxis de la función de flecha :

// ES6 using the arrow function
console.log(
    isset(() => a.b.c),
    isset(() => a.b.c.d.e.f)
);

Con respecto al rendimiento, no hay penalización de rendimiento por usar el try..catchbloque si se establece la propiedad. Hay un impacto en el rendimiento si la propiedad no está configurada.

Considere simplemente usar _.has:

var object = { 'a': { 'b': { 'c': 3 } } };

_.has(object, 'a');
// → true

_.has(object, 'a.b.c');
// → true

_.has(object, ['a', 'b', 'c']);
// → true

qué tal si

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

}

Respuesta ES6, probada a fondo :)

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

→ ver Codepen con cobertura de prueba completa

También puede usar la propuesta de encadenamiento opcional tc39 junto con babel 7 - tc39-request-optional-chaining

El código se vería así:

  const test = test?.level1?.level2?.level3;
  if (test) alert(test);

Intenté un enfoque recursivo:

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

Se ! keys.length ||inicia la recursión para que no ejecute la función sin teclas para probar. Pruebas:

obj = {
  path: {
    to: {
      the: {
        goodKey: "hello"
      }
    }
  }
}

console.log(objHasKeys(obj, ['path', 'to', 'the', 'goodKey'])); // true
console.log(objHasKeys(obj, ['path', 'to', 'the', 'badKey']));  // undefined

Lo estoy usando para imprimir una vista html amigable de un grupo de objetos con clave / valores desconocidos, por ejemplo:

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

Creo que el siguiente script ofrece una representación más legible.

declarar una función:

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

luego úsalo así:

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

}

Lo llamo "técnica de payaso triste" porque está usando el signo o (

EDITAR:

Aquí hay una versión para TypeScript

da verificaciones de tipo en tiempo de compilación (así como el intellisense si usa una herramienta como Visual Studio)

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

El uso es el mismo:

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

pero esta vez intellisense funciona!

Además, puede establecer un valor predeterminado:

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

crear un proyecto global functiony utilizarlo en todo

prueba esto

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

si condición

if(isExist(()=>obj.test.foo)){
   ....
}

Una forma simple es esta:

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

El try/catchatrapa los casos de cuando cualquiera de la mayor nivel objetos tales como prueba, test.level1, test.level1.level2 no están definidas.

No vi ningún ejemplo de alguien usando Proxies

Entonces se me ocurrió el mío. Lo bueno de esto es que no tienes que interpolar cadenas. En realidad, puede devolver una función de objeto en cadena y hacer algunas cosas mágicas con ella. Incluso puede llamar a funciones y obtener índices de matriz para buscar objetos 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

El código anterior funciona bien para cosas sincrónicas. Pero, ¿cómo probarías algo que es asíncrono como esta llamada ajax? ¿Cómo se prueba eso? ¿Qué pasa si la respuesta no es json cuando devuelve un error 500 http?

window.fetch('https://httpbin.org/get')
.then(function(response) {
  return response.json()
})
.then(function(json) {
  console.log(json.headers['User-Agent'])
})

Asegúrese de que puede usar async / wait para deshacerse de algunas devoluciones de llamada. Pero, ¿y si pudieras hacerlo aún más mágicamente? algo que se parece a esto:

fetch('https://httpbin.org/get').json().headers['User-Agent']

Probablemente se pregunte dónde están todas las promesas y .thencadenas ... esto podría estar bloqueando todo lo que sabe ... pero usando la misma técnica de Proxy con promesa, puede probar la existencia de una ruta compleja profundamente anidada sin escribir una sola función

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

En base a esta respuesta , se me ocurrió esta función genérica usando la ES2015cual resolvería el 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 );
}

He creado una pequeña función para obtener propiedades de objetos anidados de forma segura.

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

O una versión más simple pero ligeramente ilegible:

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

O incluso más corto pero sin recurrir a la bandera falsa:

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

Tengo prueba con:

const obj = {
    c: {
        a: 2,
        b: {
            c: [1, 2, 3, {a: 15, b: 10}, 15]
        },
        c: undefined,
        d: null
    },
    d: ''
}

Y aquí hay algunas pruebas:

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

Para ver todo el código con la documentación y las pruebas que he probado, puede consultar mi github gist: https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js

Una versión ES5 más corta de la excelente respuesta de @ 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;
}

Con una prueba similar:

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

Creo que esta es una ligera mejora (se convierte en 1 línea):

   alert( test.level1 && test.level1.level2 && test.level1.level2.level3 )

Esto funciona porque el operador && devuelve el operando final que evaluó (y cortocircuita).

Estaba buscando el valor que se devolvería si la propiedad existe, así que modifiqué la respuesta de CMS anterior. Esto es lo que se me ocurrió:

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

La respuesta dada por CMS funciona bien con la siguiente modificación para cheques nulos también

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

Las siguientes opciones se elaboraron a partir de esta respuesta . Mismo árbol para ambos:

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

Dejar de buscar cuando no esté definido

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

Asegure cada nivel uno por uno

var $ = function (empty) {
    return function (node) {
        return node || empty;
    };
}({});

$($(o.a).b).c // 1
$($(o.x).y).z // undefined

Sé que esta pregunta es antigua, pero quería ofrecer una extensión agregando esto a todos los objetos. Sé que las personas tienden a fruncir el ceño al usar el prototipo de Objeto para la funcionalidad de objetos extendidos, pero no encuentro nada más fácil que hacerlo. Además, ahora está permitido con el método 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;
}});

Ahora, para probar cualquier propiedad en cualquier objeto, simplemente puede hacer:

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

Aquí hay un jsfiddle para probarlo, y en particular incluye algo de jQuery que se rompe si modifica el Object.prototype directamente debido a que la propiedad se vuelve enumerable. Esto debería funcionar bien con bibliotecas de terceros.

Esto funciona con todos los objetos y matrices :)

ex:

if( obj._has( "something.['deep']['under'][1][0].item" ) ) {
    //do something
}

esta es mi versión mejorada de la respuesta de Brian

Utilicé _has como el nombre de la propiedad porque puede entrar en conflicto con la propiedad has existente (ej .: mapas)

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

Aquí está el violín

Aquí está mi opinión: la mayoría de estas soluciones ignoran el caso de una matriz anidada como en:

    obj = {
        "l1":"something",
        "l2":[{k:0},{k:1}],
        "l3":{
            "subL":"hello"
        }
    }

Es posible que desee verificar obj.l2[0].k

Con la función a continuación, puedes hacer deeptest('l2[0].k',obj)

La función devolverá verdadero si el objeto existe, falso de lo contrario

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

Ahora también podemos usar reducepara recorrer las claves anidadas:

// @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)

Puede hacer esto usando la función recursiva. Esto funcionará incluso si no conoce el nombre de todas las claves de objeto anidadas.

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

Hay una función aquí en thecodeabode (safeRead) que hará esto de manera segura ... es decir

safeRead(test, 'level1', 'level2', 'level3');

si alguna propiedad es nula o indefinida, se devuelve una cadena vacía

Según un comentario anterior , aquí hay otra versión en la que tampoco se pudo definir el objeto principal:

// Supposing that our property is at first.second.third.property:
var property = (((typeof first !== 'undefined' ? first : {}).second || {}).third || {}).property;

Escribí mi propia función que toma la ruta deseada y tiene una función de devolución de llamada buena y mala.

function checkForPathInObject(object, path, callbackGood, callbackBad){
    var pathParts = path.split(".");
    var currentObjectPath = object;

    // Test every step to see if it exists in object
    for(var i=0; i<(pathParts.length); i++){
        var currentPathPart = pathParts[i];
        if(!currentObjectPath.hasOwnProperty(pathParts[i])){
            if(callbackBad){
                callbackBad();
            }
            return false;
        } else {
            currentObjectPath = currentObjectPath[pathParts[i]];
        }
    }

    // call full path in callback
    callbackGood();
}

Uso:

var testObject = {
    level1:{
        level2:{
            level3:{
            }
        }
    }
};


checkForPathInObject(testObject, "level1.level2.level3", function(){alert("good!")}, function(){alert("bad!")}); // good

checkForPathInObject(testObject, "level1.level2.level3.levelNotThere", function(){alert("good!")}, function(){alert("bad!")}); //bad

//Just in case is not supported or not included by your framework
//***************************************************
Array.prototype.some = function(fn, thisObj) {
  var scope = thisObj || window;
  for ( var i=0, j=this.length; i < j; ++i ) {
    if ( fn.call(scope, this[i], i, this) ) {
      return true;
    }
  }
  return false;
};
//****************************************************

function isSet (object, string) {
  if (!object) return false;
  var childs = string.split('.');
  if (childs.length > 0 ) {
    return !childs.some(function (item) {
      if (item in object) {
        object = object[item]; 
        return false;
      } else return true;
    });
  } else if (string in object) { 
    return true;
  } else return false;
}

var object = {
  data: {
    item: {
      sub_item: {
        bla: {
          here : {
            iam: true
          }
        }
      }
    }
  }
};

console.log(isSet(object,'data.item')); // true
console.log(isSet(object,'x')); // false
console.log(isSet(object,'data.sub_item')); // false
console.log(isSet(object,'data.item')); // true
console.log(isSet(object,'data.item.sub_item.bla.here.iam')); // true