Se ho un riferimento a un oggetto:

var test = {};

che potenzialmente (ma non immediatamente) avranno oggetti nidificati, qualcosa del tipo:

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

Qual è il modo migliore per verificare l'esistenza di proprietà in oggetti profondamente annidati?

alert(test.level1);cede undefined, ma alert(test.level1.level2.level3);fallisce.

Attualmente sto facendo qualcosa del genere:

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

ma mi chiedevo se c'è un modo migliore.

Devi farlo passo dopo passo se non vuoi un TypeErrorperché se uno dei membri lo è nullo undefined, e provi ad accedere a un membro, verrà generata un'eccezione.

Puoi semplicemente fare catchun'eccezione o creare una funzione per testare l'esistenza di più livelli, qualcosa del genere:

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

AGGIORNAMENTO ES6:

Ecco una versione più breve della funzione originale, che utilizza le funzionalità ES6 e la ricorsione (è anche nel modulo di chiamata di coda appropriato ):

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

Tuttavia, se si desidera ottenere il valore di una proprietà nidificata e non solo verificarne l'esistenza, ecco una semplice funzione a una riga:

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 funzione precedente consente di ottenere il valore delle proprietà nidificate, altrimenti verrà restituito undefined.

AGGIORNAMENTO 17-10-2019:

La proposta di concatenamento opzionale ha raggiunto la Fase 3 del processo del comitato ECMAScript , questo ti consentirà di accedere in sicurezza alle proprietà profondamente annidate, utilizzando il token ?., il nuovo operatore di concatenamento opzionale :

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

Se uno dei livelli a cui si accede è nullo undefinedl'espressione si risolverà undefinedda sola.

La proposta consente inoltre di gestire in modo sicuro le chiamate di metodo:

obj?.level1?.method();

L'espressione precedente produrrà undefinedse obj, obj.level1o obj.level1.methodsono nullo undefined, altrimenti si chiama la funzione.

Puoi iniziare a giocare con questa funzione con Babel usando il plug-in di concatenamento opzionale .

Da Babel 7.8.0 , ES2020 è supportato per impostazione predefinita

Controlla questo esempio sulla REPL di Babel.

🎉🎉 AGGIORNAMENTO: dicembre 2019 🎉🎉

La proposta di concatenamento opzionale è finalmente arrivata alla fase 4 nella riunione del comitato TC39 del dicembre 2019. Ciò significa che questa funzione farà parte dello standard ECMAScript 2020 .

Ecco uno schema che ho raccolto da Oliver Steele :

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

In effetti l'intero articolo è una discussione su come è possibile farlo in javascript. Si accinge a usare la sintassi sopra (che non è così difficile da leggere una volta che ti ci abitui) come un linguaggio.

Aggiornare

Sembra che lodash sia stato aggiunto _.get per tutte le esigenze di proprietà annidate.

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

https://lodash.com/docs#get

Risposta precedente

Gli utenti di lodash possono apprezzare lodash.contrib che ha un paio di metodi per mitigare questo problema .

getPath

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

Ottiene il valore a qualsiasi profondità in un oggetto nidificato in base al percorso descritto dalle chiavi fornite. Le chiavi possono essere fornite come un array o come una stringa separata da punti. Restituisce undefinedse non è possibile raggiungere il percorso.

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

Ho eseguito dei test delle prestazioni (grazie cdMinix per l'aggiunta di lodash) su alcuni dei suggerimenti proposti a questa domanda con i risultati elencati di seguito.

Disclaimer # 1 Trasformare le stringhe in riferimenti è una meta-programmazione non necessaria e probabilmente è meglio evitarla. Non perdere traccia dei tuoi riferimenti per cominciare. Leggi di più da questa risposta a una domanda simile .

Disclaimer n. 2 Stiamo parlando di milioni di operazioni per millisecondo qui. È molto improbabile che uno di questi possa fare molta differenza nella maggior parte dei casi d'uso. Scegli quello che ha più senso conoscendo i limiti di ciascuno. Per me andrei con qualcosa di simile reduceper comodità.

Object Wrap (di Oliver Steele) - 34% - il più veloce

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

Soluzione originale (suggerita in questione) - 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%

più profondo - 86%

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

pagliacci tristi - 100% - più lenti

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

Si può leggere una proprietà oggetto a qualsiasi profondità, se si gestisce il nome come una stringa: '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');

Restituisce undefinedse uno dei segmenti è 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; })
);

Se stai codificando in ambiente ES6 (o usando 6to5 ), puoi sfruttare la sintassi della funzione freccia :

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

Per quanto riguarda le prestazioni, non è prevista alcuna penalità per l'uso del try..catchblocco se la proprietà è impostata. Vi è un impatto sulle prestazioni se la proprietà non è impostata.

Prendi semplicemente in considerazione l'uso di _.has:

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

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

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

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

che ne dite di

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

}

Risposta ES6, accuratamente testata :)

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

→ vedi Codepen con copertura test completa

Puoi anche usare la proposta di concatenamento opzionale tc39 insieme a babel 7 - tc39-proposta-optional-concatenamento

Il codice sarebbe simile al seguente:

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

Ho provato un approccio ricorsivo:

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

I ! keys.length ||calci fuori della ricorsione quindi non viene eseguito la funzione con nessun tasto lasciati alla prova. test:

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 sto usando per stampare una visualizzazione html amichevole di un gruppo di oggetti con chiave / valori sconosciuti, ad esempio:

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

Penso che il seguente script offra una rappresentazione più leggibile.

dichiarare una funzione:

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

quindi usalo in questo modo:

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

}

La chiamo "tecnica del pagliaccio triste" perché usa il segno o (

MODIFICARE:

ecco una versione per TypeScript

fornisce controlli del tipo in fase di compilazione (nonché intellisense se si utilizza uno strumento come Visual Studio)

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

l'utilizzo è lo stesso:

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

ma questa volta intellisense funziona!

inoltre, puoi impostare un valore predefinito:

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

creare un globale functione utilizzarlo nell'intero progetto

prova questo

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

se condizione

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

Un modo semplice è questo:

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

La try/catchcattura i casi per cui qualsiasi livello superiore oggetti come prova, test.level1, test.level1.level2 non sono definiti.

Non ho visto alcun esempio di qualcuno che utilizza proxy

Quindi mi è venuta in mente la mia. La cosa grandiosa è che non devi interpolare le stringhe. Puoi effettivamente restituire una funzione di oggetto a catena e fare alcune cose magiche con essa. È anche possibile chiamare funzioni e ottenere indici di array per verificare la presenza di oggetti profondi

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

Il codice sopra funziona bene per cose sincrone. Ma come testeresti qualcosa di asincrono come questa chiamata Ajax? Come lo testate? cosa succede se la risposta non è json quando restituisce un errore 500 http?

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

sicuro che potresti usare async / wait per sbarazzarti di alcuni callback. E se potessi farlo ancora più magicamente? qualcosa che assomiglia a questo:

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

Probabilmente ti chiedi dove siano tutte le promesse e le .thencatene ... questo potrebbe essere un blocco per tutto ciò che conosci ... ma usando la stessa tecnica Proxy con promessa puoi effettivamente testare un percorso complesso profondamente annidato per la sua esistenza senza mai scrivere una singola funzione

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

Sulla base di questa risposta , ho ideato questa funzione generica ES2015che avrebbe risolto il 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 );
}

Ho creato una piccola funzione per ottenere in sicurezza le proprietà degli oggetti nidificati.

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 versione più semplice ma leggermente illeggibile:

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 ancora più breve ma senza fallback sulla falsy flag:

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

Ho un test con:

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

E qui ci sono alcuni test:

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

Per vedere tutto il codice con la documentazione e i test che ho provato puoi controllare il mio github gist: https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js

Una versione ES5 più breve dell'eccellente risposta di @ 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 un test simile:

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

Stavo cercando il valore da restituire se la proprietà esiste, quindi ho modificato la risposta dal CMS sopra. Ecco cosa mi è venuto in mente:

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 risposta fornita da CMS funziona bene anche con la seguente modifica per i controlli null

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

Le seguenti opzioni sono state elaborate a partire da questa risposta . Lo stesso albero per entrambi:

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

Interrompere la ricerca quando non definito

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

Garantire ogni livello uno per uno

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

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

So che questa domanda è vecchia, ma volevo offrire un'estensione aggiungendola a tutti gli oggetti. So che le persone tendono ad aggrottare le sopracciglia sull'uso del prototipo Object per la funzionalità estesa degli oggetti, ma non trovo niente di più facile di così. Inoltre, ora è consentito con il metodo 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;
}});

Ora, per testare qualsiasi proprietà in qualsiasi oggetto puoi semplicemente fare:

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

Ecco un jsfiddle per provarlo, e in particolare include alcuni jQuery che si interrompono se si modifica direttamente il Object.prototype a causa della proprietà che diventa enumerabile. Questo dovrebbe funzionare bene con librerie di terze parti.

Penso che questo sia un leggero miglioramento (diventa un 1-liner):

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

Questo funziona perché l'operatore && restituisce l'operando finale che ha valutato (e cortocircuito).

Funziona con tutti gli oggetti e le matrici :)

ex:

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

questa è la mia versione migliorata della risposta di Brian

Ho usato _ha come nome della proprietà perché può entrare in conflitto con la proprietà has esistente (es: maps)

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

Ecco il violino

Ecco la mia opinione su di esso: la maggior parte di queste soluzioni ignora il caso di un array nidificato come in:

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

Potrei voler verificare obj.l2[0].k

Con la funzione di seguito, puoi farlo deeptest('l2[0].k',obj)

La funzione restituirà true se l'oggetto esiste, false in caso 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));

Ora possiamo anche usare reduceper scorrere le chiavi nidificate:

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

Puoi farlo usando la funzione ricorsiva. Funzionerà anche se non conosci tutti i nomi delle chiavi degli oggetti nidificati.

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

c'è una funzione qui sul codice di codice (safeRead) che lo farà in modo sicuro ... cioè

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

se una proprietà è nulla o non definita, viene restituita una stringa vuota

Sulla base di un commento precedente , ecco un'altra versione in cui non è stato possibile definire l'oggetto principale:

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

Ho scritto la mia funzione che prende il percorso desiderato e ha una funzione di richiamata buona e cattiva.

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