दिलचस्प पोस्ट
कैसे socket.io में कनेक्शन का पुन: उपयोग करने के लिए? डायनामिक रूप से फ़ॉर्म बनाएं और सबमिट करें यूनिकोडएनकोड त्रुटि: 'charmap' कोडेक सांकेतिक शब्दों में बदलना नहीं कर सकते हैं – वर्णों को <undefined> के लिए प्रिंट, प्रिंट फ़ंक्शन SQL सर्वर में 1/1/1753 का महत्व क्या है? ऑब्जेक्टफोरकी और वैल्यू के बीच का अंतर? अपरिवर्तनीय बिटमैप दुर्घटना त्रुटि कंसोल हो सकता है। केवल पूरी कंसोल के बजाय एक पंक्ति को साफ़ करने के लिए क्लीयर का उपयोग करें? NSubstitute DbSet / IQueryable <T> "=>" PHP में क्या मतलब है? PHP में आरएसए के साथ एन्क्रिप्ट और डिक्रिप्ट पाठ सी फ़ंक्शन घोषणा में, "…" अंतिम पैरामीटर के रूप में क्या होता है? एक टेबल में एक MySQL डाटाबेस में सभी तालिकाओं को हटा दें? Google दिशानिर्देश एपीआई (बिजनेस / वर्क लेवल) पर प्रति अनुरोध सीमा से अधिक 23 प्वाइंट उद्देश्य-सी में फ्लोट्स के साथ परेशानी एंड्रॉइड स्लीप / स्टैंडबाय मोड

नेस्टेड ऑब्जेक्ट कुंजी के अस्तित्व के लिए जावास्क्रिप्ट परीक्षण

अगर मेरे पास एक वस्तु का संदर्भ है –

var test = {}; 

कि संभवतः (लेकिन तुरंत नहीं) नेस्टेड ऑब्जेक्ट्स, जैसे कुछ –

 { level1:{level2:{level3:'level3'}} }; 

सबसे गहरी नीडिंत वस्तुओं में कुंजियों के अस्तित्व की जांच करने का सबसे अच्छा तरीका क्या है?

इस –

 alert(test.level1); 

रिटर्न 'अपरिभाषित', लेकिन यह –

 alert(test.level1.level2.level3); 

विफल रहता है।

मैं वर्तमान में ऐसा कुछ कर रहा हूं –

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

लेकिन मैं सोच रहा था कि क्या एक बेहतर तरीका है।

Solutions Collecting From Web of "नेस्टेड ऑब्जेक्ट कुंजी के अस्तित्व के लिए जावास्क्रिप्ट परीक्षण"

यदि आप एक 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 

यहां ओलिवर स्टील से उठाए गए एक पैटर्न है:

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

वास्तव में यह पूरा आलेख चर्चा करता है कि आप जावास्क्रिप्ट में यह कैसे कर सकते हैं। वह उपरोक्त सिंटैक्स का प्रयोग करने पर सुलझेगा (जो कि एक बार आप इसे इस्तेमाल करने के बाद पढ़ना मुश्किल नहीं है) मुहावरे के रूप में

अद्यतन करें

ऐसा लगता है कि रदाम ने आपके सभी नेस्टेड गुणों की आवश्यकता के लिए _.get को जोड़ा है।

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

https://lodash.com/docs#get


पिछला उत्तर

रद्दी उपयोगकर्ताओं को आनंद लेते हैं जो कि इस समस्या को कम करने के लिए कुछ तरीके हैं ।

getPath

हस्ताक्षर: _.getPath(obj:Object, ks:String|Array)

दी गई चाबियाँ द्वारा वर्णित पथ के आधार पर नेस्टेड ऑब्जेक्ट में किसी भी गहराई पर मान हो जाता है। कुंजियों को एक सरणी के रूप में या एक डॉट से अलग स्ट्रिंग के रूप में दिया जा सकता है। रिटर्न रिटर्न यदि पथ तक नहीं पहुंचा जा सकता है

 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 

मैंने नीचे दिए गए परिणामों के साथ इस प्रश्न के लिए प्रस्तावित कुछ सुझावों पर प्रदर्शन परीक्षण ( धन्यवादशोआ को जोड़ने के लिए धन्यवाद) के लिए किया है।

अस्वीकरण # 1 संदर्भों में स्ट्रिंग्स को बदलना अनावश्यक मेटा-प्रोग्रामिंग है और शायद सबसे अच्छा बचा। अपने संदर्भों का ट्रैक खोना न करें इसी उत्तर के लिए इस उत्तर से और भी पढ़ें ।

अस्वीकरण # 2 हम यहां मिलीसेकेंड के बारे में लाखों कार्यों के बारे में बात कर रहे हैं। यह बहुत संभावना नहीं है इनमें से कोई भी अधिकांश उपयोग मामलों में बहुत अंतर कर सकता है। प्रत्येक की सीमाओं को जानने के लिए जो भी सबसे अधिक महत्व देता है उसे चुनें मेरे लिए मैं कुछ के साथ जाना होगा जैसे सुविधा से बाहर निकलना

वस्तु लपेटें (ओलिवर स्टील द्वारा) – 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; 

चेक किए गए – 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 } } 

वैध चाइना – 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)); } 

नेस्टेडप्रॉपर्टी एक्सिस – 69%

 function nestedPropertyExists(obj, props) { var prop = props.shift(); return prop === undefined ? true : obj.hasOwnProperty(prop) ? nestedPropertyExists(obj[prop], props) : false; } 

_.get – 72%

डीप्टेस्ट – 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 abc; }), isset(function () { return abcdef; }) ); 

यदि आप ES6 वातावरण में कोडिंग कर रहे हैं (या 6to5 का उपयोग कर रहे हैं ) तो आप तीर फ़ंक्शन सिंटैक्स का लाभ उठा सकते हैं:

 // ES6 using the arrow function console.log( isset(() => abc), isset(() => abcdef) ); 

प्रदर्शन के बारे में, try..catch ब्लॉक का उपयोग करने के लिए कोई प्रदर्शन जुर्माना नहीं है यदि संपत्ति सेट है यदि संपत्ति सेट न होने पर प्रदर्शन का प्रभाव पड़ता है

बस _.has का उपयोग करने पर विचार करें:

 var object = { 'a': { 'b': { 'c': 3 } } }; _.has(object, 'a'); // → true _.has(object, 'abc'); // → true _.has(object, ['a', 'b', 'c']); // → true 

कैसा रहेगा

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

मैंने एक पुनरावर्ती दृष्टिकोण की कोशिश की:

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

! keys.length || ! 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'; 

एक सरल तरीका यह है:

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

जब उच्च स्तर की किसी भी तरह की परीक्षा जैसे test, test.level1, test.level1.level2 परिभाषित नहीं हैं, तब के लिए try/catch पकड़ता है।

@ सीएमएस के उत्कृष्ट उत्तर का एक छोटा, 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 

इस उत्तर के आधार पर, मैं इस सामान्य कार्य के साथ ES2015 का उपयोग 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 ); } 

मुझे लगता है कि निम्न स्क्रिप्ट अधिक पठनीय प्रतिनिधित्व देता है।

एक समारोह घोषित करें:

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

तो इसे इस तरह प्रयोग करें:

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

मैं इसे "उदासीन जोकर तकनीक" कहता हूं क्योंकि यह साइन ओ का उपयोग कर रहा है (


संपादित करें:

यहाँ टाइपस्क्रिप्ट के लिए एक संस्करण है

यह समय संकलन पर टाइप चेक देता है (साथ ही साथ अगर आप विजुअल स्टूडियो जैसे उपकरण का इस्तेमाल करते हैं तो इंटेलिसेंस)

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

सीएमएस द्वारा दिए गए जवाब में निरर्थक जांच के लिए निम्नलिखित संशोधन के साथ ही ठीक काम करता है

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

मुझे पता है कि यह सवाल पुराना है, लेकिन मैं इसे सभी वस्तुओं में जोड़कर एक विस्तार प्रदान करना चाहता था। मुझे पता है कि लोगों को ऑब्जेक्ट प्रोटोटाइप का उपयोग करके विस्तारित ऑब्जेक्ट की कार्यक्षमता पर भ्रूभंग करना पड़ता है, लेकिन मुझे ऐसा करने से कुछ भी आसान नहीं लगता। इसके अलावा, अब यह ऑब्जेक्ट के साथ अनुमति दी गई है। 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") ) 

यहां इसका परीक्षण करने के लिए एक जेएसफ़िड है, और विशेष रूप से इसमें कुछ jQuery शामिल है, जो कि आप वस्तु को संशोधित करते हैं, क्योंकि आप संपत्ति को अभिप्राय बनाते हैं। यह तृतीय पक्ष पुस्तकालयों के साथ ठीक काम करना चाहिए

यह सभी वस्तुओं और सरणियों के साथ काम करता है 🙂

उदाहरण के लिए:

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

यह ब्रायन के जवाब का मेरा बेहतर संस्करण है

मैंने संपत्ति नाम के रूप में _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 लिए 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) 

मैंने सोचा था कि मैं एक और जो मैं आज के साथ आया था जोड़ना चाहते हैं मुझे इस समाधान पर गर्व होने का कारण यह है कि यह नेस्टेड ब्रैकेट से बचा जाता है जिसका उपयोग कई समाधानों में होता है जैसे ऑब्जेक्ट लपेट (ओलिवर स्टील द्वारा) :

(इस उदाहरण में मैं एक प्लेसहोल्डर चर के रूप में अंडरस्कोर का उपयोग करता हूं, लेकिन कोई भी चर नाम काम करेगा)

 //the 'test' object var test = {level1: {level2: {level3: 'level3'}}}; let _ = test; if ((_=_.level1) && (_=_.level2) && (_=_.level3)) { let level3 = _; //do stuff with level3 } 

कोकोडोड (सुरक्षित रीड) पर एक फ़ंक्शन यहां लाया गया है जो यह एक सुरक्षित तरीके से करेंगे … यानी

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

यदि कोई संपत्ति रिक्त या अपरिभाषित है, तो रिक्त स्ट्रिंग लौटाई गई है

पिछली टिप्पणी के आधार पर, यहां एक और संस्करण है जहां मुख्य ऑब्जेक्ट को परिभाषित नहीं किया जा सकता है:

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

निम्नलिखित विकल्पों को इस उत्तर से शुरू किया गया है। दोनों के लिए समान पेड़:

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

अपरिभाषित होने पर खोज बंद करें

 var u = undefined; oa ? oab ? oabc : u : u // 1 ox ? oxy ? oxyz : u : u // undefined (o = oa) ? (o = ob) ? oc : u : u // 1 

प्रत्येक स्तर एक के बाद एक सुनिश्चित करें

 var $ = function (empty) { return function (node) { return node || empty; }; }({}); $($(oa).b).c // 1 $($(ox).y).z // undefined 
 //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 

मुझे लगता है कि यह थोड़ा सुधार है (1-लाइनर बन जाता है):

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

यह काम करता है क्योंकि && ऑपरेटर अंतिम ऑपरेंड देता है और इसका मूल्यांकन किया (और यह शॉर्ट सर्किट)।

अगर संपत्ति मौजूद है तो मैं लौटाए गए मूल्य की तलाश कर रहा था, इसलिए मैंने उपरोक्त सीएमएस द्वारा जवाब संशोधित किया। यहां बताया गया है कि मैं किसके साथ आया हूं:

 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 

मैं एक ही मुद्दा रहा था और यह देखना चाहता था कि क्या मैं अपने स्वयं के समाधान के साथ आ सकता हूं। यह उस पथ को स्वीकार करता है जिसे आप स्ट्रिंग के रूप में देखना चाहते हैं।

 function checkPathForTruthy(obj, path) { if (/\[[a-zA-Z_]/.test(path)) { console.log("Cannot resolve variables in property accessors"); return false; } path = path.replace(/\[/g, "."); path = path.replace(/]|'|"/g, ""); path = path.split("."); var steps = 0; var lastRef = obj; var exists = path.every(key => { var currentItem = lastRef[path[steps]]; if (currentItem) { lastRef = currentItem; steps++; return true; } else { return false; } }); return exists; } 

यहां कुछ लॉगिंग और परीक्षण के मामलों के साथ एक स्निपेट दिया गया है:

 console.clear(); var testCases = [ ["data.Messages[0].Code", true], ["data.Messages[1].Code", true], ["data.Messages[0]['Code']", true], ['data.Messages[0]["Code"]', true], ["data[Messages][0]['Code']", false], ["data['Messages'][0]['Code']", true] ]; var path = "data.Messages[0].Code"; var obj = { data: { Messages: [{ Code: "0" }, { Code: "1" }] } } function checkPathForTruthy(obj, path) { if (/\[[a-zA-Z_]/.test(path)) { console.log("Cannot resolve variables in property accessors"); return false; } path = path.replace(/\[/g, "."); path = path.replace(/]|'|"/g, ""); path = path.split("."); var steps = 0; var lastRef = obj; var logOutput = []; var exists = path.every(key => { var currentItem = lastRef[path[steps]]; if (currentItem) { logOutput.push(currentItem); lastRef = currentItem; steps++; return true; } else { return false; } }); console.log(exists, logOutput); return exists; } testCases.forEach(testCase => { if (checkPathForTruthy(obj, testCase[0]) === testCase[1]) { console.log("Passed: " + testCase[0]); } else { console.log("Failed: " + testCase[0] + " expected " + testCase[1]); } }); 

पथ में नेस्टेड एरे की अनुमति देने के लिए इस उत्तर में थोड़ा बदलाव करें

 var has = function (obj, key) { return key.split(".").every(function (x) { if (typeof obj != "object" || obj === null || !x in obj) return false; if (obj.constructor === Array) obj = obj[0]; obj = obj[x]; return true; }); } 

मैंने इस प्रक्रिया को स्वचालित किया

 if(isset(object,["prop1","prop2"])){ // YES! } function isset(object, props){ var dump; try { for(var x in props){ if(x == 0) { dump = object[props[x]]; return; } dump = dump[props[x]]; } } catch(e) { return false; } return true; } 

Another ES5 solution:

 function hasProperties(object, properties) { return !properties.some(function(property){ if (!object.hasOwnProperty(property)) { return true; } object = object[property]; return false; }); } 

My solution that I use since long time (using string unfortunaly, couldn't find better)

 function get_if_exist(str){ try{return eval(str)} catch(e){return undefined} } // way to use if(get_if_exist('test.level1.level2.level3')) { alert(test.level1.level2.level3); } // or simply alert(get_if_exist('test.level1.level2.level3')); 

edit: this work only if object "test" have global scope/range. else you have to do something like :

 // i think it's the most beautiful code I have ever write :p function get_if_exist(obj){ return arguments.length==1 || (obj[arguments[1]] && get_if_exist.apply(this,[obj[arguments[1]]].concat([].slice.call(arguments,2)))); } alert(get_if_exist(test,'level1','level2','level3')); 

edit final version to allow 2 method of call :

 function get_if_exist(obj){ var a=arguments, b=a.callee; // replace a.callee by the function name you choose because callee is depreceate, in this case : get_if_exist // version 1 calling the version 2 if(a[1] && ~a[1].indexOf('.')) return b.apply(this,[obj].concat(a[1].split('.'))); // version 2 return a.length==1 ? a[0] : (obj[a[1]] && b.apply(this,[obj[a[1]]].concat([].slice.call(a,2)))); } // method 1 get_if_exist(test,'level1.level2.level3'); // method 2 get_if_exist(test,'level1','level2','level3');