Wenn ich einen Verweis auf ein Objekt habe:

var test = {};

das wird möglicherweise (aber nicht sofort) verschachtelte Objekte haben, so etwas wie:

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

Was ist der beste Weg, um das Vorhandensein von Eigentum in tief verschachtelten Objekten zu überprüfen?

alert(test.level1);ergibt undefined, aberalert(test.level1.level2.level3); scheitert .

Ich mache gerade so etwas:

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

aber ich habe mich gefragt, ob es einen besseren Weg gibt.

Sie müssen es Schritt für Schritt tun, wenn Sie keine möchten, TypeErrordenn wenn eines der Mitglieder nulloder istundefined eine Ausnahme ausgelöst wird, ist und Sie versuchen, auf ein Mitglied zuzugreifen.

Sie können entweder einfach catchdie Ausnahme oder eine Funktion zum Testen der Existenz mehrerer Ebenen erstellen:

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 UPDATE:

Hier ist eine kürzere Version der ursprünglichen Funktion, die ES6-Funktionen und Rekursion verwendet (auch in richtigen Tail-Call- Form):

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

Wenn Sie jedoch den Wert einer verschachtelten Eigenschaft abrufen und nicht nur ihre Existenz überprüfen möchten, finden Sie hier eine einfache einzeilige Funktion:

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

Mit der obigen Funktion können Sie den Wert verschachtelter Eigenschaften abrufen, andernfalls wird zurückgegeben undefined.

UPDATE 2019-10-17:

Der optionale Verkettungsvorschlag hat Stufe 3 des ECMAScript-Ausschussprozesses erreicht. Auf diese Weise können Sie mithilfe des Tokens ?., des neuen optionalen Verkettungsoperators , sicher auf tief verschachtelte Eigenschaften zugreifen :

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

Wenn eine der Ebenen ist, auf die zugegriffen wird, nulloder undefinedder Ausdruck sich undefinedvon selbst auflöst .

Mit dem Vorschlag können Sie auch Methodenaufrufe sicher verarbeiten:

obj?.level1?.method();

Der obige Ausdruck erzeugt, undefinedwenn obj, obj.level1oder obj.level1.methodsind nulloder undefined, sonst ruft er die Funktion auf.

Sie können mit dieser Funktion mit Babel über das optionale Verkettungs-Plugin spielen .

Seit Babel 7.8.0 wird ES2020 standardmäßig unterstützt

Überprüfen Sie dieses Beispiel auf der Babel REPL.

🎉🎉UPDATE: Dezember 2019 🎉🎉

Der optionale Verkettungsvorschlag erreichte schließlich Stufe 4 in der Sitzung des TC39-Ausschusses im Dezember 2019. Dies bedeutet, dass diese Funktion Teil des ECMAScript 2020- Standards sein wird.

Hier ist ein Muster, das ich von Oliver Steele aufgenommen habe :

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

In der Tat ist dieser ganze Artikel eine Diskussion darüber, wie Sie dies in Javascript tun können. Er beschließt, die obige Syntax (die nicht so schwer zu lesen ist, wenn man sich erst einmal daran gewöhnt hat) als Redewendung zu verwenden.

Aktualisieren

Sieht so aus, als hätte lodash für alle Ihre Bedürfnisse nach verschachtelten Immobilien hinzugefügt _.get .

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

https://lodash.com/docs#get

Vorherige Antwort

Benutzer von lodash können sich an lodash.contrib erfreuen, das über einige Methoden verfügt, mit denen dieses Problem behoben werden kann .

getPath

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

Ruft den Wert in einer beliebigen Tiefe in einem verschachtelten Objekt basierend auf dem Pfad ab, der durch die angegebenen Schlüssel beschrieben wird. Schlüssel können als Array oder als durch Punkte getrennte Zeichenfolge angegeben werden. Gibt zurück, undefinedwenn der Pfad nicht erreicht werden kann.

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

Ich habe Leistungstests (danke cdMinix für das Hinzufügen von lodash) für einige der zu dieser Frage vorgeschlagenen Vorschläge mit den unten aufgeführten Ergebnissen durchgeführt.

Haftungsausschluss Nr. 1 Das Verwandeln von Zeichenfolgen in Referenzen ist eine unnötige Metaprogrammierung und wird wahrscheinlich am besten vermieden. Verlieren Sie zunächst nicht den Überblick über Ihre Referenzen. Lesen Sie mehr aus dieser Antwort auf eine ähnliche Frage .

Haftungsausschluss Nr. 2 Wir sprechen hier von Millionen von Vorgängen pro Millisekunde. Es ist sehr unwahrscheinlich, dass einer dieser Punkte in den meisten Anwendungsfällen einen großen Unterschied macht. Wählen Sie, was am sinnvollsten ist, wenn Sie die jeweiligen Einschränkungen kennen. Für mich würde ich mit so etwas wie reduceaus Bequemlichkeit gehen.

Objektverpackung (von Oliver Steele) - 34% - am schnellsten

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

Ursprüngliche Lösung (in Frage vorgeschlagen) - 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;
}

traurige Clowns - 100% - am langsamsten

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

Sie können eine Objekteigenschaft in jeder Tiefe lesen, wenn Sie den Namen wie eine Zeichenfolge behandeln : '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');

Es wird zurückgegeben, undefinedwenn eines der Segmente ist 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; })
);

Wenn Sie in ES6 Umgebung Codierung (oder mit 6to5 ) , dann können Sie die Vorteile der nehmen Pfeil Funktion Syntax:

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

In Bezug auf die Leistung gibt es keine Leistungseinbußen für die Verwendung von try..catchBlock, wenn die Eigenschaft festgelegt ist. Wenn die Eigenschaft nicht festgelegt ist, wirkt sich dies auf die Leistung aus.

Betrachten Sie einfach _.has:

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

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

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

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

wie wäre es mit

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

}

ES6 Antwort, gründlich getestet :)

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

→ siehe Codepen mit vollständiger Testabdeckung

Sie können auch den optionalen Verkettungsvorschlag tc39 zusammen mit babel 7 - verwenden. tc39-Vorschlag verwenden

Code würde so aussehen:

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

Ich habe einen rekursiven Ansatz versucht:

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

Die ! keys.length ||Rekursion wird beendet, sodass die Funktion nicht ausgeführt wird, ohne dass noch Tasten zum Testen übrig sind. Tests:

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

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

Ich verwende es, um eine benutzerfreundliche HTML-Ansicht einer Reihe von Objekten mit unbekannten Schlüsseln / Werten zu drucken, z.

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

Ich denke, das folgende Skript bietet eine besser lesbare Darstellung.

deklariere eine Funktion:

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

dann benutze es so:

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

}

Ich nenne es "traurige Clown-Technik", weil sie das Zeichen o (

BEARBEITEN:

Hier ist eine Version für TypeScript

Es gibt Typprüfungen zur Kompilierungszeit (sowie die Intellisense, wenn Sie ein Tool wie Visual Studio verwenden).

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

Die Verwendung ist die gleiche:

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

aber diesmal funktioniert Intellisense!

Außerdem können Sie einen Standardwert festlegen:

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

Erstellen Sie ein globales functionund verwenden Sie es im gesamten Projekt

Versuche dies

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

wenn Bedingung

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

Ein einfacher Weg ist folgender:

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

Das try/catchfängt die Fälle ab, in denen eines der übergeordneten Objekte wie test, test.level1, test.level1.level2 nicht definiert ist.

Ich habe kein Beispiel für jemanden gesehen, der Proxies verwendet

Also habe ich mir meine eigene ausgedacht. Das Tolle daran ist, dass Sie keine Zeichenfolgen interpolieren müssen. Sie können tatsächlich eine kettenfähige Objektfunktion zurückgeben und einige magische Dinge damit tun. Sie können sogar Funktionen aufrufen und Array-Indizes abrufen, um nach tiefen Objekten zu suchen

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

Der obige Code funktioniert gut für synchrone Inhalte. Aber wie würden Sie etwas Asynchrones wie diesen Ajax-Aufruf testen? Wie testest du das? Was ist, wenn die Antwort nicht json ist, wenn ein 500-http-Fehler zurückgegeben wird?

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

Sicher, Sie könnten async / await verwenden, um einige Rückrufe zu entfernen. Aber was wäre, wenn Sie es noch magischer machen könnten? etwas, das so aussieht:

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

Sie fragen sich wahrscheinlich, wo sich alle Versprechen und .thenKetten befinden ... dies könnte für alles, was Sie wissen, blockieren ... aber mit der gleichen Proxy-Technik mit Versprechen können Sie tatsächlich tief verschachtelte komplexe Pfade auf ihre Existenz testen, ohne jemals eine einzige Funktion zu schreiben

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

Basierend auf dieser Antwort habe ich diese generische Funktion entwickelt, mit ES2015der das Problem gelöst werden kann

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

Ich habe eine kleine Funktion erstellt, um verschachtelte Objekteigenschaften sicher abzurufen.

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

Oder eine einfachere, aber etwas unlesbare Version:

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

Oder noch kürzer, aber ohne Rückfall auf die falsche Flagge:

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

Ich habe Test mit:

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

Und hier sind einige Tests:

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

Um den gesamten Code mit der Dokumentation und den Tests zu sehen, die ich ausprobiert habe, können Sie meinen Github-Inhalt überprüfen: https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js

Eine kürzere ES5-Version der hervorragenden Antwort von @ 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;
}

Mit einem ähnlichen Test:

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

Ich denke, das ist eine leichte Verbesserung (wird ein 1-Liner):

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

Dies funktioniert, weil der Operator && den endgültigen Operanden zurückgibt, den er ausgewertet hat (und der kurzgeschlossen wird).

Ich habe nach dem Wert gesucht, der zurückgegeben werden soll, wenn die Eigenschaft vorhanden ist, daher habe ich die Antwort von CMS oben geändert. Folgendes habe ich mir ausgedacht:

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

Die von CMS gegebene Antwort funktioniert auch mit der folgenden Änderung für Nullprüfungen einwandfrei

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

Ausgehend von dieser Antwort wurden folgende Optionen ausgearbeitet . Gleicher Baum für beide:

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

Stoppen Sie die Suche, wenn Sie nicht definiert sind

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

Stellen Sie sicher, dass jede Ebene einzeln ist

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

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

Ich weiß, dass diese Frage alt ist, aber ich wollte eine Erweiterung anbieten, indem ich sie allen Objekten hinzufüge. Ich weiß, dass die Leute dazu neigen, den Objektprototyp für erweiterte Objektfunktionen zu verwenden, aber ich finde nichts einfacher als dies. Außerdem ist dies jetzt mit der Object.defineProperty- Methode zulässig .

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

Um nun auf eine Eigenschaft in einem Objekt zu testen, können Sie einfach Folgendes tun:

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

Hier ist eine jsfiddle zum Testen, und insbesondere enthält sie eine jQuery, die unterbrochen wird, wenn Sie den Object.prototype direkt ändern, weil die Eigenschaft aufzählbar wird. Dies sollte mit Bibliotheken von Drittanbietern gut funktionieren.

Dies funktioniert mit allen Objekten und Arrays :)

Ex:

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

Dies ist meine verbesserte Version von Brians Antwort

Ich habe _has als Eigenschaftsnamen verwendet, da dies zu Konflikten mit vorhandenen has-Eigenschaften führen kann ( z. B. 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;
}});

Hier ist die Geige

Hier ist meine Meinung dazu - die meisten dieser Lösungen ignorieren den Fall eines verschachtelten Arrays wie in:

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

Ich möchte vielleicht nachsehen obj.l2[0].k

Mit der folgenden Funktion können Sie dies tun deeptest('l2[0].k',obj)

Die Funktion gibt true zurück, wenn das Objekt vorhanden ist, andernfalls 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));

Jetzt können wir auch reduceverschachtelte Schlüssel durchlaufen:

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

Sie können dies mit der rekursiven Funktion tun. Dies funktioniert auch dann, wenn Sie nicht alle Namen der verschachtelten Objektschlüssel kennen.

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

Hier auf der Codeabode (safeRead) gibt es eine Funktion , die dies auf sichere Weise erledigt ... dh

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

Wenn eine Eigenschaft null oder undefiniert ist, wird eine leere Zeichenfolge zurückgegeben

Basierend auf einem vorherigen Kommentar ist hier eine andere Version, in der das Hauptobjekt ebenfalls nicht definiert werden konnte:

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

Ich habe meine eigene Funktion geschrieben, die den gewünschten Pfad einnimmt und eine gute und eine schlechte Rückruffunktion hat.

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

Verwendungszweck:

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