Si j'ai une référence à un objet:

var test = {};

qui auront potentiellement (mais pas immédiatement) des objets imbriqués, quelque chose comme:

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

Quelle est la meilleure façon de vérifier l'existence d'une propriété dans des objets profondément imbriqués?

alert(test.level1);cède undefined, mais alert(test.level1.level2.level3);échoue.

Je fais actuellement quelque chose comme ça:

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

mais je me demandais s'il y avait une meilleure façon.

Vous devez le faire étape par étape si vous ne voulez pas de TypeErrorcar si l'un des membres est nullou undefined, et que vous essayez d'accéder à un membre, une exception sera levée.

Vous pouvez soit simplement catchl'exception, soit créer une fonction pour tester l'existence de plusieurs niveaux, quelque chose comme ceci:

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

MISE À JOUR ES6:

Voici une version plus courte de la fonction d'origine, utilisant les fonctionnalités ES6 et la récursivité (elle est également sous la forme d'un appel d'appel approprié ):

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

Cependant, si vous souhaitez obtenir la valeur d'une propriété imbriquée et non seulement vérifier son existence, voici une fonction simple sur une ligne:

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 fonction ci-dessus vous permet d'obtenir la valeur des propriétés imbriquées, sinon elle reviendra undefined.

MISE À JOUR 2019-10-17:

La proposition de chaînage facultative a atteint l'étape 3 du processus du comité ECMAScript , cela vous permettra d'accéder en toute sécurité aux propriétés profondément imbriquées, en utilisant le jeton ?., le nouvel opérateur de chaînage facultatif :

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

Si l'un des niveaux accessibles est nullou undefinedl'expression se résoudra d' undefinedelle-même.

La proposition vous permet également de gérer les appels de méthode en toute sécurité:

obj?.level1?.method();

L'expression ci - dessus produira undefinedsi obj, obj.level1ou obj.level1.methodsont nullou undefined, sinon , il appellera la fonction.

Vous pouvez commencer à jouer avec cette fonctionnalité avec Babel en utilisant le plugin de chaînage en option .

Depuis Babel 7.8.0 , ES2020 est pris en charge par défaut

Consultez cet exemple sur le Babel REPL.

🎉🎉MISE À JOUR: décembre 2019 🎉🎉

La proposition de chaînage facultatif a finalement atteint l'étape 4 lors de la réunion de décembre 2019 du comité TC39. Cela signifie que cette fonctionnalité fera partie de la norme ECMAScript 2020 .

Voici un modèle que j'ai choisi d'Oliver Steele :

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

En fait, cet article est une discussion sur la façon dont vous pouvez le faire en javascript. Il décide d'utiliser la syntaxe ci-dessus (qui n'est pas si difficile à lire une fois que vous vous y êtes habitué) comme idiome.

Mise à jour

On dirait que lodash a ajouté _.get pour tous vos besoins immobiliers imbriqués.

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

https://lodash.com/docs#get

Réponse précédente

Les utilisateurs de lodash peuvent profiter de lodash.contrib qui dispose de quelques méthodes pour atténuer ce problème .

getPath

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

Obtient la valeur à n'importe quelle profondeur dans un objet imbriqué en fonction du chemin décrit par les clés données. Les clés peuvent être données sous forme de tableau ou de chaîne séparée par des points. Renvoie undefinedsi le chemin ne peut pas être atteint.

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

J'ai fait des tests de performance (merci cdMinix pour avoir ajouté lodash) sur certaines des suggestions proposées à cette question avec les résultats listés ci-dessous.

Avertissement # 1 Transformer des chaînes en références est une méta-programmation inutile et probablement mieux évitée. Ne perdez pas la trace de vos références pour commencer. En savoir plus sur cette réponse à une question similaire .

Disclaimer # 2 Nous parlons ici de millions d'opérations par milliseconde. Il est très peu probable que l'un de ces éléments fasse une grande différence dans la plupart des cas d'utilisation. Choisissez celui qui a le plus de sens en connaissant les limites de chacun. Pour moi, j'irais avec quelque chose comme reducepar commodité.

Object Wrap (par Oliver Steele) - 34% - le plus rapide

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

Solution originale (suggérée en question) - 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%

plus habile - 86%

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

clowns tristes - 100% - les plus lents

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

Vous pouvez lire une propriété d'objet à toute profondeur, si vous gérez le nom comme une chaîne: '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');

Il retourne undefinedsi l'un des segments l'est 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 vous codez dans un environnement ES6 (ou utilisez 6to5 ), vous pouvez profiter de la syntaxe de la fonction flèche :

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

En ce qui concerne les performances, il n'y a pas de pénalité de performances pour l'utilisation de try..catchblock si la propriété est définie. Il y a un impact sur les performances si la propriété n'est pas définie.

Pensez simplement à utiliser _.has:

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

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

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

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

que diriez-vous

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

}

Réponse ES6, minutieusement testée :)

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

→ voir Codepen avec une couverture complète des tests

Vous pouvez également utiliser la proposition de chaînage facultative tc39 avec babel 7 - chaînage-facultatif-tc39-proposition

Le code ressemblerait à ceci:

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

J'ai essayé une approche récursive:

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

Les ! keys.length ||coups de pied hors de la récursivité afin qu'il n'exécute pas la fonction avec aucune clé à gauche pour tester. 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

Je l'utilise pour imprimer une vue html conviviale d'un tas d'objets avec des clés / valeurs inconnues, par exemple:

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

Je pense que le script suivant donne une représentation plus lisible.

déclarer une fonction:

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

puis utilisez-le comme ceci:

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

}

Je l'appelle "technique du clown triste" car elle utilise le signe o (

ÉDITER:

voici une version pour TypeScript

il donne des vérifications de type au moment de la compilation (ainsi que l'intellisense si vous utilisez un outil comme 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'usage est le même:

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

mais cette fois l'intellisense fonctionne!

de plus, vous pouvez définir une valeur par défaut:

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

créer un global functionet utiliser dans tout le projet

essaye ça

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 condition

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

Une façon simple est la suivante:

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

Le try/catchcapture les cas où aucun des objets de niveau supérieur tels que test, test.level1, test.level1.level2 n'est défini.

Je n'ai vu aucun exemple de personne utilisant des proxys

J'ai donc créé le mien. La grande chose à ce sujet est que vous n'avez pas à interpoler les chaînes. Vous pouvez en fait retourner une fonction d' objet chaînable et faire des choses magiques avec. Vous pouvez même appeler des fonctions et obtenir des index de tableau pour rechercher des objets profonds

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

Le code ci-dessus fonctionne bien pour les choses synchrones. Mais comment testeriez-vous quelque chose d'asynchrone comme cet appel ajax? Comment testez-vous cela? que faire si la réponse n'est pas json lorsqu'elle renvoie une erreur http 500?

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

vous pouvez utiliser async / wait pour vous débarrasser de certains rappels. Et si vous pouviez le faire encore plus par magie? quelque chose qui ressemble à ceci:

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

Vous vous demandez probablement où se trouvent toutes les promesses et .thenchaînes ... cela pourrait bloquer pour tout ce que vous savez ... mais en utilisant la même technique de proxy avec promesse, vous pouvez réellement tester un chemin complexe profondément imbriqué pour son existence sans jamais écrire une seule fonction

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

Sur la base de cette réponse , j'ai trouvé cette fonction générique ES2015qui résoudrait le problème

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

J'ai créé une petite fonction pour obtenir les propriétés des objets imbriqués en toute sécurité.

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

Ou une version plus simple mais légèrement illisible:

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

Ou encore plus court mais sans repli sur le drapeau falsifié:

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

J'ai testé avec:

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

Et voici quelques 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'));

Pour voir tout le code avec la documentation et les tests que j'ai essayés, vous pouvez vérifier mon github gistub: https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js

Une version ES5 plus courte de l'excellente réponse 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;
}

Avec un test similaire:

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

Je pense que c'est une légère amélioration (devient une doublure):

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

Cela fonctionne car l'opérateur && renvoie l'opérande final qu'il a évalué (et court-circuite).

Je cherchais la valeur à renvoyer si la propriété existe, j'ai donc modifié la réponse par CMS ci-dessus. Voici ce que j'ai trouvé:

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 réponse donnée par CMS fonctionne bien avec la modification suivante pour les contrôles nuls également

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

Les options suivantes ont été élaborées à partir de cette réponse . Même arbre pour les deux:

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

Arrêtez la recherche lorsque vous n'êtes pas défini

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

Assurez chaque niveau un par un

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

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

Je sais que cette question est ancienne, mais je voulais proposer une extension en l'ajoutant à tous les objets. Je sais que les gens ont tendance à froncer les sourcils en utilisant le prototype Object pour une fonctionnalité d'objet étendue, mais je ne trouve rien de plus simple que de faire cela. De plus, il est désormais autorisé avec la méthode 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;
}});

Maintenant, pour tester n'importe quelle propriété dans n'importe quel objet, vous pouvez simplement faire:

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

Voici un jsfiddle pour le tester, et en particulier il inclut un jQuery qui se casse si vous modifiez le Object.prototype directement à cause de la propriété devenant énumérable. Cela devrait fonctionner correctement avec les bibliothèques tierces.

Cela fonctionne avec tous les objets et tableaux :)

ex:

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

c'est ma version améliorée de la réponse de Brian

J'ai utilisé _has comme nom de propriété car il peut entrer en conflit avec une propriété existante (ex: 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;
}});

Voici le violon

Voici mon point de vue à ce sujet - la plupart de ces solutions ignorent le cas d'un tableau imbriqué comme dans:

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

Je veux peut-être vérifier obj.l2[0].k

Avec la fonction ci-dessous, vous pouvez faire deeptest('l2[0].k',obj)

La fonction retournera true si l'objet existe, false sinon

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

Maintenant, nous pouvons également utiliser reducepour parcourir les clés imbriquées:

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

Vous pouvez le faire en utilisant la fonction récursive. Cela fonctionnera même si vous ne connaissez pas le nom de toutes les clés d'objets imbriquées.

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

theres une fonction ici sur le codeabode (safeRead) qui le fera de manière sûre ... ie

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

si une propriété est nulle ou non définie, une chaîne vide est retournée

Sur la base d' un commentaire précédent , voici une autre version où l'objet principal ne pouvait pas non plus être défini:

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

J'ai écrit ma propre fonction qui prend le chemin souhaité et a une bonne et une mauvaise fonction de rappel.

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

Usage:

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