Jeśli mam odwołanie do obiektu:

var test = {};

które potencjalnie (ale nie natychmiast) zagnieżdżą obiekty, takie jak:

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

Jaki jest najlepszy sposób sprawdzenia istnienia własności w głęboko zagnieżdżonych obiektach?

alert(test.level1);daje undefined, ale alert(test.level1.level2.level3);zawodzi.

Obecnie robię coś takiego:

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

ale zastanawiałem się, czy jest lepszy sposób.

Musisz to zrobić krok po kroku, jeśli nie chcesz, TypeErrorponieważ jeśli jeden z członków jest nulllub undefinedi próbujesz uzyskać dostęp do członka, zostanie zgłoszony wyjątek.

Możesz albo po prostu catchwyjątek, albo utworzyć funkcję testującą istnienie wielu poziomów, coś w tym rodzaju:

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

AKTUALIZACJA ES6:

Oto krótsza wersja oryginalnej funkcji, wykorzystująca funkcje i rekurencję ES6 (ma również odpowiednią formę wywołania ogona ):

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

Jeśli jednak chcesz uzyskać wartość zagnieżdżonej właściwości i nie tylko sprawdzić jej istnienie, oto prosta funkcja jednowierszowa:

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

Powyższa funkcja pozwala uzyskać wartość zagnieżdżonych właściwości, w przeciwnym razie zwróci undefined.

AKTUALIZACJA 17.10.2019:

Opcjonalnie propozycja łańcuchowym osiągnęła etap 3 na proces komisji ECMAScript , pozwoli to na bezpieczne dostępu właściwości głęboko zagnieżdżonych, za pomocą tokena ?., nowa opcja operator łańcuchowym :

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

Jeśli którykolwiek z dostępnych poziomów jest nulllub undefinedwyrażenie zostanie rozwiązane undefinedsamodzielnie.

Ta propozycja pozwala również bezpiecznie obsługiwać wywołania metod:

obj?.level1?.method();

Powyższe wyrażenie wygeneruje undefinedif obj, obj.level1lub obj.level1.methodare nullor undefined, w przeciwnym razie wywoła funkcję.

Możesz zacząć grać z tą funkcją w Babel za pomocą opcjonalnej wtyczki łańcuchowej .

Od wersji Babel 7.8.0 ES2020 jest domyślnie obsługiwany

Sprawdź ten przykład na Babel REPL.

🎉🎉 AKTUALIZACJA: grudzień 2019 🎉🎉

Opcjonalna propozycja łączenia ostatecznie osiągnęła etap 4 na posiedzeniu komitetu TC39 w grudniu 2019 r. Oznacza to, że ta funkcja będzie częścią standardu ECMAScript 2020 .

Oto wzór, który wybrałem od Olivera Steele :

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

W rzeczywistości cały artykuł jest dyskusją na temat tego, jak to zrobić w javascript. Postanawia używać powyższej składni (co nie jest trudne do odczytania, gdy się przyzwyczaisz) jako idiomu.

Aktualizacja

Wygląda na to, że lodash został dodany _.get do wszystkich potrzeb związanych z zagnieżdżaniem nieruchomości.

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

https://lodash.com/docs#get

Poprzednia odpowiedź

Użytkownicy lodash mogą korzystać z lodash.contrib, który ma kilka metod łagodzących ten problem .

getPath

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

Pobiera wartość na dowolnej głębokości w zagnieżdżonym obiekcie na podstawie ścieżki opisanej przez podane klucze. Klucze mogą być podawane jako tablica lub jako ciąg rozdzielany kropkami. Zwraca, undefinedjeśli ścieżka nie może zostać osiągnięta.

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

Przeprowadziłem testy wydajności (dziękuję cdMinix za dodanie lodash) dla niektórych sugestii zaproponowanych do tego pytania z wynikami wymienionymi poniżej.

Zastrzeżenie nr 1 Przekształcanie ciągów w odwołania jest niepotrzebnym metaprogramowaniem i prawdopodobnie najlepiej go unikać. Nie trać na początku swoich referencji. Przeczytaj więcej z tej odpowiedzi na podobne pytanie .

Zastrzeżenie nr 2 Mówimy tutaj o milionach operacji na milisekundę. Jest bardzo mało prawdopodobne, aby którykolwiek z nich zrobiłby dużą różnicę w większości przypadków użycia. Wybierz, który z nich jest najbardziej sensowny, znając ograniczenia każdego z nich. Dla mnie wybrałbym coś reducez wygody.

Object Wrap (autor: Oliver Steele) - 34% - najszybciej

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

Oryginalne rozwiązanie (sugerowane w pytaniu) - 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%

najgłębsze - 86%

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

smutni klauni - 100% - najwolniej

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

Można odczytać właściwość obiektu na każdej głębokości, jeśli uchwyt nazwę jak struna: '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');

Zwraca, undefinedjeśli którykolwiek z segmentów jest 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; })
);

Jeśli kodujesz w środowisku ES6 (lub używasz 6to5 ), możesz skorzystać ze składni funkcji strzałek :

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

Jeśli chodzi o wydajność, nie ma ograniczenia wydajności za korzystanie try..catch bloku, jeśli właściwość jest ustawiona. Jeśli właściwość jest rozbrojona, ma to wpływ na wydajność.

Rozważ użycie _.has:

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

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

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

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

Co powiesz na

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

}

Odpowiedź ES6, dokładnie przetestowana :)

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

→ patrz Codepen z pełnym pokryciem testowym

Możesz również użyć opcjonalnej kombinacji łańcuchowej tc39 wraz z babel 7 - tc39-propozycja-opcjonalna łączenie łańcuchów

Kod wyglądałby tak:

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

Wypróbowałem podejście rekurencyjne:

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

W ! keys.length ||wyrzuca z rekursji więc nie uruchomić funkcję bez pozostawionych do testu kluczy. Testy:

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

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

Używam go do drukowania przyjaznego widoku html wiązki obiektów o nieznanych kluczach / wartościach, np .:

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

Myślę, że poniższy skrypt daje bardziej czytelną reprezentację.

zadeklaruj funkcję:

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

użyj tego w następujący sposób:

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

}

Nazywam to „techniką smutnego klauna”, ponieważ używa znaku o (

EDYTOWAĆ:

tutaj jest wersja dla TypeScript

daje kontrolę typu w czasie kompilacji (a także inteligencję, jeśli używasz narzędzia takiego jak Visual Studio)

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

użycie jest takie samo:

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

ale tym razem intellisense działa!

ponadto możesz ustawić wartość domyślną:

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

stworzyć globalny function i wykorzystaj w całym projekcie

Spróbuj tego

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

jeśli warunek

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

Jednym prostym sposobem jest:

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

try/catchPołowy przypadków, w przypadku każdego z wyższego poziomu obiektów, takich jak badania, test.level1, test.level1.level2 nie są określone.

Nie widziałem żadnego przykładu osoby używającej proxy

Więc wymyśliłem własne. Wspaniałą rzeczą jest to, że nie trzeba interpolować ciągów. Możesz faktycznie zwrócić funkcję obiektu zdolną do tworzenia łańcuchów i robić z nią magiczne rzeczy. Możesz nawet wywoływać funkcje i uzyskiwać indeksy tablic w celu sprawdzenia głębokich obiektów

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

Powyższy kod działa dobrze dla rzeczy synchronicznych. Ale jak przetestowałbyś coś tak asynchronicznego, jak to wywołanie ajax? Jak to testujesz? co jeśli odpowiedź nie jest json, gdy zwraca błąd 500 HTTP?

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

upewnij się, że możesz użyć asynchronizacji / oczekiwania na pozbycie się niektórych wywołań zwrotnych. A gdybyś mógł to zrobić jeszcze bardziej magicznie? coś, co wygląda tak:

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

Prawdopodobnie zastanawiasz się, gdzie są wszystkie obietnice i .thenłańcuchy ... to może blokować wszystko, co wiesz ... ale używając tej samej techniki proxy z obietnicą możesz faktycznie przetestować głęboko zagnieżdżoną złożoną ścieżkę pod kątem jej istnienia bez pisania żadnej funkcji

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

Na podstawie tej odpowiedzi wymyśliłem tę ogólną funkcję, ES2015która rozwiązałaby problem

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

Stworzyłem małą funkcję, aby bezpiecznie uzyskać właściwości zagnieżdżonego obiektu.

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

Lub prostsza, ale nieco nieczytelna wersja:

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

Lub nawet krócej, ale bez rezerwy na fladze falsy:

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

Mam test z:

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

A oto kilka testów:

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

Aby zobaczyć cały kod z dokumentacją i próbami, które wypróbowałem, możesz sprawdzić moją listę github: https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js

Krótsza wersja doskonałej odpowiedzi @ CMS na ES5:

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

Z podobnym testem:

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

Szukałem wartości, która ma zostać zwrócona, jeśli właściwość istnieje, więc zmodyfikowałem odpowiedź przez CMS powyżej. Oto, co wymyśliłem:

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

Odpowiedź podana przez CMS działa dobrze z następującą modyfikacją również dla kontroli zerowych

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

Na podstawie tej odpowiedzi opracowano następujące opcje . To samo drzewo dla obu:

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

Zatrzymaj wyszukiwanie, gdy nie jest zdefiniowane

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

Zapewniaj każdy poziom jeden po drugim

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

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

Wiem, że to pytanie jest stare, ale chciałem zaoferować rozszerzenie, dodając je do wszystkich obiektów. Wiem, że ludzie nie lubią używać prototypu Object do rozszerzonej funkcjonalności obiektu, ale nie znajduję nic łatwiejszego niż robienie tego. Ponadto jest to teraz dozwolone w przypadku metody 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;
}});

Teraz, aby przetestować dowolną właściwość w dowolnym obiekcie, możesz po prostu zrobić:

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

Oto jsfiddle do przetestowania go, aw szczególności zawiera on jQuery, który psuje się, jeśli zmodyfikujesz Object.prototype bezpośrednio z powodu wyliczenia właściwości. Powinno to działać poprawnie z bibliotekami stron trzecich.

Myślę, że to niewielka poprawa (zmienia się w 1-liniowy):

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

Działa to, ponieważ operator && zwraca końcowy operand, który ocenił (i powoduje zwarcie).

Działa to ze wszystkimi obiektami i tablicami :)

dawny:

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

to jest moja ulepszona wersja odpowiedzi Briana

Użyłem _has jako nazwy właściwości, ponieważ może powodować konflikt z istniejącą ma właściwość (np. Mapy)

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

Oto skrzypce

Oto moje zdanie na ten temat - większość z tych rozwiązań ignoruje przypadek zagnieżdżonej tablicy jak w:

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

Mogę chcieć sprawdzić obj.l2[0].k

Dzięki funkcji poniżej możesz to zrobić deeptest('l2[0].k',obj)

Funkcja zwróci true, jeśli obiekt istnieje, w przeciwnym razie 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));

Teraz możemy także używać reducedo przechodzenia przez zagnieżdżone klucze:

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

Możesz to zrobić za pomocą funkcji rekurencyjnej. Działa to nawet wtedy, gdy nie znasz wszystkich nazw zagnieżdżonych kluczy Object.

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

jest tu funkcja na codecode (safeRead), która zrobi to w bezpieczny sposób ... tj

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

jeśli jakakolwiek właściwość jest pusta lub niezdefiniowana, zwracany jest pusty ciąg

W oparciu o poprzedni komentarz , oto kolejna wersja, w której główny obiekt nie mógł zostać zdefiniowany:

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

Napisałem własną funkcję, która podąża pożądaną ścieżkę i ma dobrą i złą funkcję wywołania zwrotnego.

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

Stosowanie:

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