Jika saya memiliki referensi ke suatu objek:

var test = {};

yang berpotensi (tetapi tidak segera) memiliki objek bersarang, seperti:

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

Apa cara terbaik untuk memeriksa keberadaan properti di objek bersarang mendalam?

alert(test.level1);hasil undefined, tetapi alert(test.level1.level2.level3);gagal.

Saya sedang melakukan sesuatu seperti ini:

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

tapi saya bertanya-tanya apakah ada cara yang lebih baik.

Anda harus melakukannya langkah demi langkah jika Anda tidak menginginkannya TypeErrorkarena jika salah satu anggota adalah nullatauundefined , dan Anda mencoba mengakses anggota, pengecualian akan dilemparkan.

Anda bisa hanya catchpengecualian, atau membuat fungsi untuk menguji keberadaan beberapa level, seperti ini:

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

Ini adalah versi yang lebih pendek dari fungsi aslinya, menggunakan fitur ES6 dan rekursi (ini juga dalam bentuk panggilan ekor yang tepat ):

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

Namun, jika Anda ingin mendapatkan nilai properti bersarang dan tidak hanya memeriksa keberadaannya, berikut ini adalah fungsi satu-baris yang sederhana:

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

Fungsi di atas memungkinkan Anda untuk mendapatkan nilai properti bersarang, jika tidak akan kembali undefined.

UPDATE 2019-10-17:

The chaining usulan opsional mencapai Tahap 3 pada proses komite ECMAScript , ini akan memungkinkan Anda untuk dengan aman akses properti sangat bersarang, dengan menggunakan token ?., yang baru chaining Operator opsional :

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

Jika salah satu level yang diakses adalah nullatau undefinedekspresi akan diselesaikanundefined dengan sendirinya.

Proposal juga memungkinkan Anda untuk menangani panggilan metode dengan aman:

obj?.level1?.method();

Ekspresi di atas akan menghasilkan undefinedjika obj, obj.level1atau obj.level1.methodyang nullatauundefined , jika tidak maka akan memanggil fungsi.

Anda dapat mulai bermain dengan fitur ini dengan Babel menggunakan plugin chaining opsional .

Sejak Babel 7.8.0 , ES2020 didukung secara default

Lihat contoh ini di Babel REPL.

🎉🎉UPDATE: Desember 2019 🎉🎉

Proposal perangkaian opsional akhirnya mencapai Tahap 4 pada pertemuan komite TC39 Desember 2019. Ini berarti fitur ini akan menjadi bagian dari ECMAScript 2020 Standard.

Berikut adalah pola yang saya ambil dari Oliver Steele :

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

Sebenarnya seluruh artikel itu adalah diskusi tentang bagaimana Anda bisa melakukan ini dalam javascript. Ia memilih menggunakan sintaks di atas (yang tidak terlalu sulit untuk dibaca setelah Anda terbiasa) sebagai ungkapan.

Memperbarui

Sepertinya lodash telah menambahkan _.get untuk semua properti bersarang Anda mendapatkan kebutuhan.

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

https://lodash.com/docs#get

Jawaban sebelumnya

pengguna lodash dapat menikmati lodash.contrib yang memiliki beberapa metode yang mengurangi masalah ini .

getPath

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

Mendapat nilai pada kedalaman apa pun di objek bersarang berdasarkan jalur yang dijelaskan oleh tombol yang diberikan. Kunci dapat diberikan sebagai array atau sebagai string yang dipisahkan titik. Kembali undefinedjika jalur tidak dapat dicapai.

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

Saya telah melakukan tes kinerja (terima kasih cdMinix untuk menambahkan lodash) pada beberapa saran yang diajukan untuk pertanyaan ini dengan hasil yang tercantum di bawah ini.

Penafian # 1 Mengubah string menjadi referensi adalah pemrograman meta yang tidak perlu dan mungkin sebaiknya dihindari. Jangan kehilangan jejak referensi Anda untuk memulai. Baca lebih lanjut dari jawaban ini untuk pertanyaan serupa .

Penafian # 2 Kita berbicara tentang jutaan operasi per milidetik di sini. Sangat tidak mungkin semua ini akan membuat banyak perbedaan dalam kebanyakan kasus penggunaan. Pilih mana yang paling masuk akal mengetahui keterbatasan masing-masing. Bagi saya, saya akan pergi dengan sesuatu seperti reducetidak nyaman.

Obyek Bungkus (oleh Oliver Steele) - 34% - tercepat

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

Solusi asli (disarankan dalam pertanyaan) - 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;
}

badut sedih - 100% - paling lambat

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

Anda dapat membaca properti objek di kedalaman apapun, jika Anda menangani nama seperti string: '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');

Ini mengembalikan undefinedjika salah satu segmen adalah 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; })
);

Jika Anda mengkode dalam lingkungan ES6 (atau menggunakan 6to5 ) maka Anda dapat memanfaatkan sintaks fungsi panah :

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

Mengenai kinerja, tidak ada penalti kinerja untuk menggunakan try..catch blok jika properti diatur. Ada dampak kinerja jika properti tidak disetel.

Pertimbangkan hanya menggunakan _.has:

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

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

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

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

bagaimana tentang

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

}

ES6 menjawab, diuji secara menyeluruh :)

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

→ lihat Codepen dengan cakupan tes penuh

Anda juga dapat menggunakan proposal chaining opsional tc39 bersama dengan babel 7 - tc39-proposal-opsional-chaining

Kode akan terlihat seperti ini:

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

Saya mencoba pendekatan rekursif:

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

The ! keys.length ||tendangan dari rekursi sehingga tidak menjalankan fungsi dengan tidak ada tombol kiri untuk tes. Tes:

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

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

Saya menggunakannya untuk mencetak tampilan html ramah sekelompok objek dengan kunci / nilai yang tidak diketahui, misalnya:

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

Saya pikir skrip berikut memberikan representasi yang lebih mudah dibaca.

mendeklarasikan suatu fungsi:

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

lalu gunakan seperti ini:

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

}

Saya menyebutnya "teknik badut sedih" karena menggunakan tanda o (

EDIT:

di sini adalah versi untuk TypeScript

itu memberikan pemeriksaan jenis pada waktu kompilasi (serta intellisense jika Anda menggunakan alat seperti Visual Studio)

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

penggunaannya sama:

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

tapi kali ini intellisense bekerja!

plus, Anda dapat menetapkan nilai default:

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

buat global functiondan gunakan di seluruh proyek

coba ini

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

jika kondisi

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

Salah satu cara sederhana adalah ini:

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

The try/catchmenangkap kasus-kasus ketika salah satu tingkat yang lebih tinggi objek seperti tes, test.level1, test.level1.level2 tidak didefinisikan.

Saya tidak melihat contoh seseorang menggunakan Proxy

Jadi saya membuat sendiri. Hal yang hebat tentang itu adalah Anda tidak perlu menyisipkan string. Anda benar-benar dapat mengembalikan fungsi objek yang dapat berantai dan melakukan beberapa hal ajaib dengannya. Anda bahkan dapat memanggil fungsi dan mendapatkan indeks array untuk memeriksa objek dalam

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

Kode di atas berfungsi dengan baik untuk hal-hal yang sinkron. Tapi bagaimana Anda menguji sesuatu yang tidak sinkron seperti panggilan ajax ini? Bagaimana Anda mengujinya? bagaimana jika responsnya bukan json ketika mengembalikan kesalahan 500 http?

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

yakin Anda bisa menggunakan async / menunggu untuk menyingkirkan beberapa panggilan balik. Tetapi bagaimana jika Anda bisa melakukannya dengan lebih ajaib? sesuatu yang terlihat seperti ini:

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

Anda mungkin bertanya-tanya di mana semua janji & .thenrantai ... ini bisa memblokir semua yang Anda tahu ... tetapi menggunakan teknik Proksi yang sama dengan janji, Anda benar-benar dapat menguji jalur rumit bersarang untuk keberadaannya tanpa pernah menulis fungsi tunggal

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

Berdasarkan jawaban ini , saya datang dengan menggunakan fungsi generik ES2015yang akan memecahkan masalah

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

Saya telah membuat sedikit fungsi untuk mendapatkan properti objek bersarang dengan aman.

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

Atau versi yang lebih sederhana namun sedikit tidak terbaca:

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

Atau bahkan lebih pendek tetapi tanpa fallback pada flag 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);
}

Saya memiliki tes dengan:

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

Dan inilah beberapa tes:

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

Untuk melihat semua kode dengan dokumentasi dan tes yang telah saya coba, Anda dapat memeriksa github gist saya: https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js

Versi lebih pendek, versi ES5 dari jawaban istimewa 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;
}

Dengan tes serupa:

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

Saya pikir ini sedikit perbaikan (menjadi 1-liner):

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

Ini berfungsi karena operator && mengembalikan operan terakhir yang dievaluasi (dan korsleting).

Saya mencari nilai yang akan dikembalikan jika properti itu ada, jadi saya mengubah jawaban dengan CMS di atas. Inilah yang saya pikirkan:

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

Jawaban yang diberikan oleh CMS berfungsi dengan baik dengan modifikasi berikut untuk cek nol juga

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

Opsi berikut dijabarkan mulai dari jawaban ini . Pohon yang sama untuk keduanya:

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

Hentikan pencarian saat tidak ditentukan

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

Pastikan setiap level satu per satu

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

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

Saya tahu pertanyaan ini sudah lama, tetapi saya ingin menawarkan ekstensi dengan menambahkan ini ke semua objek. Saya tahu orang-orang cenderung tidak suka menggunakan prototipe Obyek untuk fungsionalitas objek yang diperluas, tetapi saya tidak menemukan sesuatu yang lebih mudah daripada melakukan ini. Plus, sekarang diizinkan dengan metode 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;
}});

Sekarang, untuk menguji properti apa pun di objek apa pun yang dapat Anda lakukan:

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

Berikut ini adalah jsfiddle untuk mengujinya, dan khususnya mencakup beberapa jQuery yang rusak jika Anda memodifikasi Object.prototype secara langsung karena properti menjadi enumerable. Ini harus bekerja dengan baik dengan perpustakaan pihak ke-3.

Ini bekerja dengan semua objek dan array :)

ex:

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

ini adalah versi perbaikan dari jawaban Brian saya

Saya menggunakan _has sebagai nama properti karena dapat bertentangan dengan properti yang sudah ada (mis .: peta)

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

Ini biola

Inilah pendapat saya - sebagian besar solusi ini mengabaikan kasus array bersarang seperti pada:

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

Saya mungkin ingin memeriksa obj.l2[0].k

Dengan fungsi di bawah ini, Anda bisa melakukannya deeptest('l2[0].k',obj)

Fungsi akan mengembalikan true jika objek ada, false jika tidak

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

Sekarang kita juga dapat menggunakan reduceuntuk mengulang melalui kunci bersarang:

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

Anda dapat melakukan ini dengan menggunakan fungsi rekursif. Ini akan bekerja bahkan jika Anda tidak tahu semua nama kunci Object bersarang.

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

ada fungsi di sini diode kode (safeRead) yang akan melakukan ini dengan cara yang aman ... yaitu

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

jika properti apa pun adalah nol atau tidak terdefinisi, string kosong dikembalikan

Berdasarkan komentar sebelumnya , berikut adalah versi lain di mana objek utama tidak dapat didefinisikan:

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

Saya menulis fungsi saya sendiri yang mengambil jalur yang diinginkan, dan memiliki fungsi panggilan balik yang baik dan buruk.

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

Pemakaian:

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