ถ้าฉันมีการอ้างอิงถึงวัตถุ:

var test = {};

ที่อาจเกิดขึ้น (แต่ไม่ทันที) มีวัตถุซ้อนกันบางอย่างเช่น:

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

วิธีที่ดีที่สุดในการตรวจสอบการมีอยู่ของทรัพย์สินในวัตถุที่ซ้อนกันอย่างล้ำลึกคืออะไร?

alert(test.level1);ผลผลิตundefinedแต่alert(test.level1.level2.level3);ล้มเหลว

ฉันกำลังทำสิ่งนี้:

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

แต่ฉันสงสัยว่ามีวิธีที่ดีกว่านี้หรือไม่

คุณต้องทำทีละขั้นถ้าคุณไม่ต้องการTypeErrorเพราะถ้าหนึ่งในสมาชิกคือnullหรือundefinedและคุณพยายามเข้าถึงสมาชิกข้อยกเว้นจะถูกโยน

คุณสามารถcatchยกเว้นได้อย่างง่ายดายหรือสร้างฟังก์ชั่นเพื่อทดสอบการมีอยู่ของหลาย ๆ ระดับดังนี้:

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:

นี่คือฟังก์ชั่นดั้งเดิมที่สั้นกว่าโดยใช้คุณสมบัติ ES6 และการเรียกซ้ำ (ยังอยู่ในรูปแบบการเรียกหางที่เหมาะสม ):

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

อย่างไรก็ตามหากคุณต้องการรับค่าของคุณสมบัติซ้อนกันและไม่เพียง แต่ตรวจสอบการมีอยู่ของมันนี่คือฟังก์ชั่นหนึ่งบรรทัดง่ายๆ:

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

ฟังก์ชั่นด้านบนอนุญาตให้คุณรับค่าคุณสมบัติซ้อนกันมิฉะนั้นจะส่งคืน undefinedฟังก์ชั่นดังกล่าวข้างต้นจะช่วยให้คุณได้รับค่าของคุณสมบัติที่ซ้อนกันมิฉะนั้นจะกลับมา

อัพเดท 2019-10-17:

ข้อเสนอการผูกมัดตัวเลือกถึง 3 ขั้นตอนในกระบวนการของคณะกรรมการ ECMAScriptนี้จะช่วยให้คุณได้อย่างปลอดภัยการเข้าถึงคุณสมบัติที่ซ้อนกันอย่างลึกซึ้งโดยใช้โทเค็น?.ใหม่ผู้ประกอบการผูกมัดตัวเลือก :

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

หากระดับการเข้าถึงใด ๆ เป็นnullหรือundefinedการแสดงออกจะแก้ไขundefinedด้วยตัวเอง

ข้อเสนอนี้ยังช่วยให้คุณสามารถจัดการวิธีการโทรได้อย่างปลอดภัย:

obj?.level1?.method();

การแสดงออกดังกล่าวข้างต้นจะผลิตundefinedถ้าobj, obj.level1หรือobj.level1.methodมีnullหรือundefinedมิฉะนั้นจะเรียกใช้ฟังก์ชัน

คุณสามารถเริ่มเล่นด้วยคุณสมบัตินี้กับ Babel โดยใช้ปลั๊กอินเสริมที่ผูกมัดตัวเลือกการผูกมัดปลั๊กอิน

ตั้งแต่Babel 7.8.0 , ES2020 ได้รับการสนับสนุนโดยค่าเริ่มต้น

ตรวจสอบตัวอย่างนี้ใน Babel REPL

🎉🎉UPDATE: ธันวาคม 2562 🎉🎉

ในที่สุดข้อเสนอที่เป็นตัวเลือกถึงขั้นตอนที่ 4ในการประชุมธันวาคม 2558 ของคณะกรรมการ TC39 นี่หมายความว่าฟีเจอร์นี้จะเป็นส่วนหนึ่งของมาตรฐานECMAScript 2020

นี่คือรูปแบบฉัน เลือกจาก Oliver Steele :

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

ในความเป็นจริงบทความทั้งหมดเป็นการสนทนาว่าคุณสามารถทำได้ใน javascript เขานั่งลงที่การใช้ไวยากรณ์ข้างต้น (ซึ่งไม่ยากที่จะอ่านเมื่อคุณคุ้นเคย) เป็นสำนวน

ปรับปรุง

ดูเหมือนว่า lodash ได้เพิ่ม _.getความต้องการที่อยู่อาศัยทั้งหมดของคุณ

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

https://lodash.com/docs#get

คำตอบก่อนหน้า

ผู้ใช้lodashอาจเพลิดเพลินไปกับlodash.contribซึ่งมีวิธีการสองสามอย่างที่ช่วยลดปัญหานี้ได้ได้

getPath

ลายเซ็น: _.getPath(obj:Object, ks:String|Array)

รับค่าที่ระดับความลึกใด ๆ ในวัตถุที่ซ้อนกันตามเส้นทางที่อธิบายโดยคีย์ที่กำหนด คีย์อาจได้รับเป็นอาร์เรย์หรือเป็นสตริงที่คั่นด้วยจุด ส่งคืนundefinedหากไม่สามารถเข้าถึงพา ธ

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

ฉันได้ทำการทดสอบประสิทธิภาพแล้ว(ขอบคุณcdMinixสำหรับการเพิ่ม lodash) จากคำแนะนำบางส่วนที่เสนอให้กับคำถามนี้พร้อมผลลัพธ์ตามรายการด้านล่าง

ข้อสงวนสิทธิ์ # 1การเปลี่ยนสตริงให้เป็นการอ้างอิงนั้นไม่จำเป็นต้องมีการเขียนโปรแกรมเมตาและอาจหลีกเลี่ยงได้ดีที่สุด อย่าลืมติดตามการอ้างอิงของคุณเพื่อเริ่มต้นด้วย อ่านเพิ่มเติมจากคำตอบนี้เพื่อคำถามที่คล้ายกันอ่านข้อมูลเพิ่มเติมจากคำตอบนี้ไปคำถามที่คล้ายกัน

ข้อสงวนสิทธิ์ # 2เรากำลังพูดถึงการดำเนินงานหลายล้านต่อมิลลิวินาทีที่นี่ มันไม่น่าเป็นไปได้ที่สิ่งเหล่านี้จะสร้างความแตกต่างอย่างมากในกรณีการใช้งานส่วนใหญ่ เลือกวิธีที่เหมาะสมที่สุดที่จะรู้ถึงข้อ จำกัด ของแต่ละข้อ สำหรับฉันฉันจะไปกับบางสิ่งบางอย่างที่reduceไม่สะดวก

การห่อวัตถุ (โดย Oliver Steele) - 34% - เร็วที่สุด

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

โซลูชันดั้งเดิม (แนะนำในคำถาม) - 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;
}

ตัวตลกเศร้า - 100% - ช้าที่สุด

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

คุณสามารถอ่านคุณสมบัติวัตถุที่ระดับความลึกใด ๆ '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');

ก็จะส่งกลับundefinedถ้าใด ๆ 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; })
);

หากคุณกำลังเข้ารหัสในสภาพแวดล้อม ES6 (หรือใช้6to5 ) จากนั้นคุณสามารถใช้ประโยชน์จากไวยากรณ์ฟังก์ชั่นลูกศร :

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

เกี่ยวกับประสิทธิภาพไม่มีการลงโทษประสิทธิภาพการใช้ try..catchบล็อกหากมีการตั้งค่าคุณสมบัติ มีผลกระทบต่อประสิทธิภาพหากคุณสมบัติไม่ได้ถูกตั้งค่า

พิจารณาโดยใช้เพียง_.has:

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

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

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

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

เกี่ยวกับ

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

}

คำตอบ ES6 ทดสอบอย่างละเอียด :)

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

→ดูCodepen พร้อมการทดสอบเต็มรูปแบบ

นอกจากนี้คุณยังสามารถใช้ข้อเสนอการผูกมัดเสริม tc39 ร่วมกับ babel 7 - tc39-proposal-optional-chaining

รหัสจะมีลักษณะเช่นนี้:

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

ฉันลองใช้วิธีเรียกซ้ำ:

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

การ! keys.length ||เตะซ้ำจากการเรียกซ้ำดังนั้นจึงไม่เรียกใช้ฟังก์ชันโดยไม่มีปุ่มเหลือให้ทดสอบ แบบทดสอบ:

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

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

ฉันใช้มันเพื่อพิมพ์มุมมอง html ที่เป็นมิตรของกลุ่มวัตถุที่มีคีย์ / ค่าที่ไม่รู้จักเช่น:

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

ฉันคิดว่าสคริปต์ต่อไปนี้ให้การแสดงที่อ่านง่ายขึ้น

ประกาศฟังก์ชั่น:

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

จากนั้นใช้แบบนี้:

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

}

ฉันเรียกมันว่า "เทคนิคตัวตลกเศร้า" เพราะใช้เครื่องหมาย o (

แก้ไข:

นี่คือเวอร์ชันสำหรับTypeScript

มันให้การตรวจสอบประเภทที่รวบรวมเวลา (เช่นเดียวกับ Intellisense ถ้าคุณใช้เครื่องมือเช่น Visual Studio)

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

การใช้งานเหมือนกัน:

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

แต่เวลานี้ intellisense ทำงาน!

บวกคุณสามารถตั้งค่าเริ่มต้น:

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

สร้างโลกfunctionและใช้ในโครงการทั้งหมด

ลองนี้

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

ถ้าเงื่อนไข

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

วิธีง่ายๆอย่างหนึ่งคือ:

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

try/catchจับกรณีเมื่อใด ๆ ของระดับที่สูงกว่าวัตถุเช่นการทดสอบ test.level1, test.level1.level2 ยังไม่ได้กำหนด

ฉันไม่เห็นตัวอย่างของคนที่ใช้พร็อกซี่

ดังนั้นฉันมากับของตัวเอง สิ่งที่ดีเกี่ยวกับมันคือคุณไม่จำเป็นต้องสอดแทรกสตริง คุณสามารถส่งคืนฟังก์ชั่นวัตถุที่สามารถใช้โซ่ได้และทำสิ่งมหัศจรรย์บางอย่างกับมัน คุณสามารถเรียกใช้ฟังก์ชันและรับดัชนีอาร์เรย์เพื่อตรวจสอบวัตถุที่มีความลึกได้

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

รหัสด้านบนทำงานได้ดีสำหรับสิ่งที่ซิงโครนัส แต่คุณจะทดสอบบางสิ่งที่ไม่ตรงกันแบบอาแจ็กซ์นี้ได้อย่างไร คุณทดสอบได้อย่างไร เกิดอะไรขึ้นถ้าการตอบสนองไม่ json เมื่อมันกลับข้อผิดพลาด 500 http?

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

แน่ใจว่าคุณสามารถใช้ async / รอคอยเพื่อกำจัดการเรียกกลับบางอย่าง แต่ถ้าคุณทำมันได้อย่างน่าอัศจรรย์ยิ่งกว่านี้ล่ะ? สิ่งที่มีลักษณะเช่นนี้:

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

คุณอาจสงสัยว่าสัญญา & .thenโซ่ทั้งหมดอยู่ที่ไหน... นี่อาจเป็นการปิดกั้นทุกสิ่งที่คุณรู้ ... แต่ใช้เทคนิคพร็อกซี่เดียวกันกับสัญญาคุณสามารถทดสอบเส้นทางที่ซับซ้อนที่ซ้อนกันอยู่จริงโดยไม่ต้องเขียนฟังก์ชั่นเดียว

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

จากคำตอบนี้ฉันพบกับฟังก์ชั่นทั่วไปที่ใช้ES2015ซึ่งจะแก้ปัญหาได้

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

ฉันได้สร้างฟังก์ชั่นเล็ก ๆ น้อย ๆ เพื่อให้ได้รับคุณสมบัติของวัตถุที่ซ้อนกันอย่างปลอดภัย

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

หรือเวอร์ชันที่เรียบง่าย แต่อ่านไม่ได้เล็กน้อย:

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

หรือแม้แต่สั้นกว่า แต่ไม่มีทางเลือกในการตั้งค่าสถานะที่ผิดพลาด:

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

ฉันมีการทดสอบด้วย:

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

และนี่คือการทดสอบบางส่วน:

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

หากต้องการดูโค้ดทั้งหมดที่มีเอกสารประกอบและการทดสอบที่ฉันได้ลองคุณสามารถตรวจสอบ github gist ของฉันได้ที่: https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js

คำตอบที่ยอดเยี่ยมของ @ CMS รุ่นสั้นลง 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;
}

ด้วยการทดสอบที่คล้ายกัน:

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

ฉันกำลังมองหาค่าที่จะส่งคืนหากมีอสังหาริมทรัพย์อยู่ดังนั้นฉันจึงแก้ไขคำตอบโดย CMS ด้านบน นี่คือสิ่งที่ฉันมาด้วย:

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

คำตอบที่ได้รับจาก CMS ทำงานได้ดีกับการแก้ไขต่อไปนี้สำหรับการตรวจสอบค่า Null เช่นกัน

function checkNested(obj /*, level1, level2, ... levelN*/) 
      {
             var args = Array.prototype.slice.call(arguments),
             obj = args.shift();

            for (var i = 0; i < args.length; i++) 
            {
                if (obj == null || !obj.hasOwnProperty(args[i]) ) 
                {
                    return false;
                }
                obj = obj[args[i]];
            }
            return true;
    }

ตัวเลือกต่อไปนี้ถูกอธิบายอย่างละเอียดโดยเริ่มจากคำตอบนี้ ต้นไม้เดียวกันสำหรับทั้งสอง:

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

หยุดการค้นหาเมื่อไม่ได้กำหนด

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

ตรวจสอบให้แน่ใจแต่ละระดับหนึ่งโดยหนึ่ง

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

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

ฉันรู้ว่าคำถามนี้เก่า แต่ฉันต้องการที่จะนำเสนอส่วนขยายโดยการเพิ่มไปยังวัตถุทั้งหมด ฉันรู้ว่าคนมักจะขมวดคิ้วในการใช้ต้นแบบวัตถุสำหรับฟังก์ชั่นการขยายวัตถุ แต่ฉันไม่พบอะไรง่ายไปกว่าทำสิ่งนี้ นอกจากนี้ยังอนุญาตให้ใช้เมธอด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;
}});

ตอนนี้เพื่อทดสอบคุณสมบัติในวัตถุใด ๆ ที่คุณสามารถทำได้:

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

นี่คือ jsfiddleเพื่อทดสอบและโดยเฉพาะอย่างยิ่งมันรวม jQuery บางอย่างที่แตกถ้าคุณแก้ไข Object.prototype โดยตรงเนื่องจากคุณสมบัติกลายเป็น enumerable สิ่งนี้น่าจะใช้ได้ดีกับห้องสมุดบุคคลที่สาม

ฉันคิดว่านี่เป็นการปรับปรุงเล็กน้อย (กลายเป็น 1 ซับ):

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

สิ่งนี้ใช้งานได้เนื่องจากตัวดำเนินการ && ส่งคืนตัวถูกดำเนินการสุดท้ายที่ประเมิน (และวงจรสั้น)

ใช้งานได้กับวัตถุและอาร์เรย์ทั้งหมด :)

อดีต:

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

นี่เป็นคำตอบของ Brian ที่ได้รับการปรับปรุง

ฉันใช้_hasเป็นชื่อคุณสมบัติเนื่องจากอาจขัดแย้งกับคุณสมบัติที่มีอยู่แล้ว (เช่นแผนที่)

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

นี่คือซอ

นี่คือสิ่งที่ฉันทำ - โซลูชันส่วนใหญ่ไม่สนใจกรณีของอาร์เรย์ที่ซ้อนกันใน:

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

ฉันอาจต้องการตรวจสอบ obj.l2[0].k

ด้วยฟังก์ชั่นด้านล่างคุณสามารถทำได้ deeptest('l2[0].k',obj)

ฟังก์ชั่นจะกลับจริงถ้าวัตถุที่มีอยู่เป็นเท็จอย่างอื่น

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

ตอนนี้เรายังสามารถใช้reduceวนลูปผ่านคีย์ที่ซ้อนกัน:

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

คุณสามารถทำได้โดยใช้ฟังก์ชั่นวนซ้ำ สิ่งนี้จะใช้ได้แม้ว่าคุณจะไม่ทราบชื่อคีย์ของวัตถุที่ซ้อนกันทั้งหมด

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

มีฟังก์ชั่นที่นี่ใน the codeabode (safeRead)ซึ่งจะทำสิ่งนี้ในลักษณะที่ปลอดภัย ... เช่น

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

ถ้าคุณสมบัติใด ๆ เป็นโมฆะหรือไม่ได้กำหนดสตริงว่างจะถูกส่งกลับ

จากความคิดเห็นก่อนหน้านี่คือรุ่นอื่นที่ไม่สามารถกำหนดวัตถุหลักได้:

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

ฉันเขียนฟังก์ชันของตัวเองที่ใช้เส้นทางที่ต้องการและมีฟังก์ชั่นโทรกลับที่ดีและไม่ดี

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

การใช้งาน:

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