নেস্টেড জাভাস্ক্রিপ্ট অবজেক্ট কীটির অস্তিত্বের জন্য পরীক্ষা

Question

আমার যদি কোনও জিনিসের রেফারেন্স থাকে:

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

তবে আমি ভাবছিলাম যে এর চেয়ে আরও ভাল উপায় আছে কিনা?

Comments

আপনি সম্ভবত একটি স্পর্শকাতর সম্পর্কিত প্রশ্ন যাচাই করতে চান যা সম্প্রতি জিজ্ঞাসা করা হয়েছিল স্ট্যাকওভারফ্লো.com

— অনুরাগ

স্ট্যাকওভারফ্লোও

— জেমস ম্যাকমাহন

সেখানে বেশ কয়েকটি প্রস্তাব রয়েছে: স্ট্যাকওভারফ্লো.com

— পাতাগুলি

আপনার বর্তমান পদ্ধতির একটি সম্ভাব্য সমস্যা রয়েছে যদি লেভেল 3 সম্পত্তিটি মিথ্যা হয় তবে সেক্ষেত্রে সম্পত্তি উপস্থিত থাকলেও পুনরায় ফিরে আসবে এই উদাহরণটি একবার দেখুন দয়া করে jsfiddle.net/maz9bLjx

— গিব্বোক

কেবল আপনি চেষ্টা করেও ক্যাচ ব্যবহার করতে পারেন

— রাঘভেন্দ্র

Answer 1

আপনি যদি না চান তবে আপনাকে ধাপে ধাপে এটি করতে হবে 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:

ঐচ্ছিক chaining প্রস্তাব উপর পর্যায় 3 পৌঁছে নাম ECMAScript কমিটি প্রক্রিয়া , এই অনুমতি দেবে আপনি নিরাপদে এক্সেস গভীরভাবে নেস্টেড সম্পত্তি, টোকেন ব্যবহার দ্বারা ?.নতুন ঐচ্ছিক chaining অপারেটর :

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

অ্যাক্সেস করা স্তরের কোনওটি যদি হয় nullবা undefinedঅভিব্যক্তিটি undefinedনিজে থেকেই সমাধান হয়ে যায়।

প্রস্তাবটি আপনাকে পদ্ধতি কলগুলি নিরাপদে পরিচালনা করতে দেয়:

obj?.level1?.method();

উপরের এক্সপ্রেশনটি উত্পন্ন করবে undefinedযদি obj, obj.level1বা obj.level1.methodহয় nullবা undefinedঅন্যথায় এটি ফাংশনটি কল করে।

Babচ্ছিক চেইন প্লাগইন ব্যবহার করে আপনি বাবেলের সাথে এই বৈশিষ্ট্যটি খেলতে শুরু করতে পারেন ।

যেহেতু হট্টগোল 7.8.0 , ES2020 ডিফল্ট দ্বারা সমর্থিত

বাবেল আরপিএলে এই উদাহরণটি দেখুন ।

আপডেট: ডিসেম্বর 2019 🎉🎉

Cচ্ছিক শৃঙ্খলা সংক্রান্ত প্রস্তাব টিসি 39 কমিটির 2019 ডিসেম্বরে অবশেষে পর্যায় 4 এ পৌঁছেছে । এর অর্থ এই বৈশিষ্ট্যটি ECMAScript 2020 স্ট্যান্ডার্ডের অংশ হবে ।

Comments

argumentsআসলে একটি অ্যারে নয়। Array.prototype.slice.call(arguments)এটিকে একটি আনুষ্ঠানিক অ্যারেতে রূপান্তরিত করে। শিখুন

— ডিফর

হতে this'd আরও দক্ষ অনেক করতে var obj = arguments[0];এবং থেকে শুরু var i = 1অনুলিপি পরিবর্তে argumentsবস্তুর

— Claudiu

আমি কৃপণতার জন্য চেষ্টা / ধরার সাথে একটি সংস্করণ একসাথে রেখেছি, এবং কোনও আশ্চর্যের কিছু নেই - পারফরম্যান্সটি ভয়াবহ (কোনও কারণে সাফারি বাদে)। নীচে কিছু উত্তর রয়েছে যা ক্লাডিয়ুর পরিবর্তনের সাথে বেশ পারফরম্যান্ট যা নির্বাচিত উত্তরের চেয়ে উল্লেখযোগ্যভাবে আরও পারফরম্যান্ট। Jsperf এখানে দেখুন jsperf.com/check-if- প্রদীপ

— প্রপার্টি-

ES6-এ argsভেরিয়েবল ডিক্লেয়ারেশন মুছে ফেলা যায় এবং পদ্ধতিটির ...args জন্য দ্বিতীয় আর্গুমেন্ট হিসাবে এটি ব্যবহার করা যেতে পারে checkNested। বিকাশকারী.মোজিলা.আর.ইন

— ভার্নন

এটি একটি খুব অকল্পনীয়। যদি কোনও সম্পত্তি কীগুলি পরিবর্তিত হয় (তারা করবে), প্রকল্পের সমস্ত ডিভগুলিকে পুরো কোডবেস 'স্ট্রিং অনুসন্ধান' করতে হবে। এটি আসলেই সমস্যার সমাধান নয়, কারণ এটি আরও অনেক বড় সমস্যার পরিচয় দেয়

— Drenai

Answer 2

অলিভার স্টিলের কাছ থেকে আমি তুলেছি এমন একটি প্যাটার্ন এখানে :

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

আসলে পুরো নিবন্ধটি জাভাস্ক্রিপ্টে আপনি কীভাবে এটি করতে পারেন তা আলোচনা। তিনি উপরের সিনট্যাক্সটি (যা একবার পড়তে অভ্যস্ত হয়ে উঠলে তা পড়া এতটা কঠিন নয়) একটি প্রতিমা হিসাবে ব্যবহার করেন on

Comments

@ যুদ্ধে আমি মনে করি এটি বেশিরভাগ ক্ষেত্রেই কতটা সংক্ষিপ্ত জন্য আকর্ষণীয়। লিঙ্কযুক্ত পোস্টে পারফরম্যান্সের বৈশিষ্ট্যগুলির বিষয়ে বিস্তারিত আলোচনা রয়েছে। হ্যাঁ এটি সর্বদা সমস্ত পরীক্ষা করে, তবে এটি টেম্প ভার্স তৈরি করা এড়িয়ে যায়, এবং আপনি যদি প্রতিবার একটি নতুন ফাঁকা বস্তু তৈরির ওভারহেডকে আটকাতে চান তবে আপনি কোনও উপায়ে alias alias করতে পারেন। 99% ক্ষেত্রে আমি গতির বিষয়টি বিবেচনা করতে পারব না, এবং ক্ষেত্রে এটির জন্য প্রোফাইলিংয়ের বিকল্প নেই।

— গাব মোথার্ট

@ মুহাম্মাদ উমর না, মূল কথাটি (test || {})হচ্ছে যদি পরীক্ষাটি অপরিজ্ঞাত হয় তবে আপনি করছেন ({}.level1 || {})। অবশ্যই, অপরিবর্তিত {}.level1, তাই এর অর্থ হল আপনি করছেন {}.level2এবং আরও কিছু।

— জোশুয়া টেলর

@ জোশুয়া টেইলর: আমার মনে হয় তার অর্থ যদি testঘোষিত না হয় তবে একটি রেফারেন্স এরির হবে , তবে এটি কোনও সমস্যা নয়, কারণ যদি এটি ঘোষিত না হয় তবে একটি বাগ ঠিক করতে হবে, তাই ত্রুটিটি একটি ভাল জিনিস।

তুমি বলেছিলে "যা নয় যে কঠিন পড়তে একবার আপনি ব্যবহার করতে পারেন এটি বর্তমানে এমন" । ভাল, এগুলি লক্ষণগুলি যা আপনি ইতিমধ্যে জানেন এটি একটি গোলযোগ । তাহলে কেন এই সমাধানটির পরামর্শ দিন? এটি টাইপসের ঝুঁকিপূর্ণ এবং পাঠযোগ্যতার জন্য একেবারে কিছুই দেয় না । শুধু দেখুন! আমি আছে একটি কুশ্রী লাইন লিখুন, এটা হতে asswell উচিত পাঠযোগ্য ; সুতরাং আমি কেবল সাথে আটকে যাচ্ছিif(test.level1 && test.level1.level2 && test.level1.level2.level3)

— শার্কি

আমি যদি কিছু মিস করি না, তবে এটি বুলেয়ান এন্ড প্রোপার্টিগুলির পক্ষে কাজ করবে না যা ভুল হতে পারে ... দুঃখের বিষয়। নাহলে আমি এই প্রতিমাটি ভালবাসি।

— T3db0t

Answer 3

হালনাগাদ

দেখে মনে হচ্ছে যে আপনার সমস্ত নেস্টেড সম্পত্তি পাওয়ার প্রয়োজনের জন্য লোডাশ যোগ _.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

Comments

লোড্যাশের জন্য সত্যই একটি _.আইপথডেফাইন্ড (ওজেক্ট, প্যাথস্ট্রিং) পদ্ধতি দরকার।

— ম্যাথু পায়েেন

@ ম্যাথেজপেয়েন এটি খুব সুন্দর লাগবে তবে এটি সত্যিই প্রয়োজনীয় নয়। আপনি নিজেই এটি খুব সহজেই করতে পারতেনfunction isPathDefined(object, path) { return typeof _.getPath(object, path) !== 'undefined'; }

— Thor84no

লোড্যাশের নিজেই এই একই কার্যকারিতা রয়েছে:_.get(countries, 'greece.sparta.playwright', 'default'); // → 'default' _.has(countries, 'greece.spart.playwright') // → false

— টম

আরও ভাল _ _ ফলাফল হবে

— শিশির অরোরা

আপনার যদি একাধিক বিভিন্ন পাথ বিবেচনা করতে হয় তবে তা বিবেচনা করুন: var url = _.get(e, 'currentTarget.myurl', null) || _.get(e, 'currentTarget.attributes.myurl.nodeValue', null) || null

— সাইমন হাচিসন

Answer 4

নীচে তালিকাভুক্ত ফলাফলগুলি সহ এই প্রশ্নের প্রস্তাবিত কয়েকটি পরামর্শের জন্য আমি পারফরম্যান্স টেস্ট করেছি ( লোড্যাশ যুক্ত করার জন্য সিডিমিনিক্সকে ধন্যবাদ )।

দাবি অস্বীকার # 1 স্ট্রিংগুলিকে রেফারেন্সে রূপান্তর করা অপ্রয়োজনীয় মেটা-প্রোগ্রামিং এবং সম্ভবত সেরা এড়ানো সম্ভব। আপনার রেফারেন্সগুলি শুরু করতে ট্র্যাকটি হারাবেন না। একটি অনুরূপ প্রশ্নের এই উত্তর থেকে আরও পড়ুন ।

অস্বীকৃতি # 2 আমরা এখানে মিলিসেকেন্ডে কয়েক মিলিয়ন অপারেশন সম্পর্কে কথা বলছি। বেশিরভাগ ব্যবহারের ক্ষেত্রে এর মধ্যে কোনওটিই খুব বেশি পার্থক্য আনবে এটি খুব সম্ভবত unlikely যে কোনও একটির সীমাবদ্ধতাগুলি জেনে সর্বাধিক বোধগম্য হন তা চয়ন করুন। আমার জন্য আমি reduceসুবিধার বাইরে এমন কিছু নিয়ে যাব ।

অবজেক্ট মোড়ানো (অলিভার স্টিল দ্বারা) - 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;
}

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

Comments

এটা উল্লেখ করা উচিত যে আরো% একটি পরীক্ষা আছে - ধীর এটা

— avalanche1

লোডাশ কি _.get()? এই উত্তরগুলির সাথে তুলনা করা কতটা পারফরম্যান্ট?

— beniutek

এগুলির প্রতিটি পদ্ধতি পরিস্থিতির উপর নির্ভর করে অন্যান্য পদ্ধতির তুলনায় ধীর বা দ্রুত। যদি সমস্ত কীগুলি পাওয়া যায় তবে "অবজেক্ট মোড়ানো" দ্রুততম হতে পারে, তবে যদি কোনও কী না পাওয়া যায় তবে "নেটিভ সমাধান / মূল সমাধান" দ্রুততর হতে পারে।

— অশুভরিকো

@ অ্যাভিলআরিকো কোনও কী না পাওয়া গেলে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে ধীরে একই রকম হবে বলে মনে হয়। তবে, আপনি ঠিক বলেছেন - এটি অন্য যে কোনও কিছুর চেয়ে বৌদ্ধিক অনুশীলন বেশি। আমরা এখানে মিলিসেকেন্ডে এক মিলিয়ন পুনরাবৃত্তি সম্পর্কে কথা বলছি। আমি কোনও ব্যবহারের ক্ষেত্রে দেখতে পাচ্ছি না যেখানে এটির চেয়ে বেশি পার্থক্য হবে। আমাকে ব্যক্তিগতভাবে আমি সুবিধার জন্য reduceবা try/catchবাইরে যেতে চাই ।

— ইউনিটরিও

এটি কতটা পারফরম্যান্ট তা তুলনায়try { test.level1.level2.level3 } catch (e) { // some logger e }

— লেক্স

Answer 5

আপনি যে কোনো গভীরতার এ একটি বস্তু সম্পত্তি পড়তে পারেন, যদি আপনি একটি স্ট্রিং মত নাম হ্যান্ডেল: '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।

Comments

কমপক্ষে ক্রোমে এই পদ্ধতিটি খুব পারফরম্যান্সযুক্ত, উল্লেখ করা যায় না যে কয়েকটি ক্ষেত্রে @ ক্লাডিউ নির্বাচিত উত্তরের পরিবর্তিত সংস্করণকে ছাড়িয়ে যায়। পারফরম্যান্স টেস্টটি এখানে দেখুন: jsperf.com/check-if-DP-property-exists-withnotwrowth

— নেটপোটিকা

Answer 6

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

Comments

আমি মনে করি try-catchপদ্ধতির সেরা উত্তর। কোনও বস্তুর প্রকারের জন্য জিজ্ঞাসা করা, এবং API উপস্থিত রয়েছে এবং ধরে না নিলে সেই অনুযায়ী ব্যর্থ হওয়ার মধ্যে দার্শনিক পার্থক্য রয়েছে। দ্বিতীয়টি আলগাভাবে টাইপ করা ভাষায় আরও উপযুক্ত appropriate স্ট্যাকওভারফ্লো . com/a/408305/2419669 দেখুন । try-catchপদ্ধতির এছাড়াও চেয়ে অনেক পরিস্কার হয় if (foo && foo.bar && foo.bar.baz && foo.bar.baz.qux) { ... }।

— ইয়াংমিলস্টিওরি

Answer 7

কেমন

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

}

Comments

আমি মনে করি না চেষ্টা / ধরা কোনও কোনও অস্তিত্বের অস্তিত্বের জন্য পরীক্ষা করার ভাল উপায়: চেষ্টা / ধরা ব্যতিক্রমগুলি হ্যান্ডেল করার জন্য, এখানে পরীক্ষার মতো সাধারণ পরিস্থিতি নয়। আমি মনে করি (প্রতিটি ধাপে টাইপ foo == "অপরিজ্ঞাত") আরও ভাল - এবং সাধারণভাবে, আপনি যদি এত গভীরভাবে বাসাযুক্ত সম্পত্তি নিয়ে কাজ করছেন তবে সম্ভবত কিছু সংশোধনকারী প্রয়োজন। এছাড়াও, চেষ্টা / ক্যাচ ফায়ারব্যাগে বিরতি সৃষ্টি করবে (এবং কোনও ব্রাউজারে যেখানে ব্রেক-অন-ত্রুটি চালু আছে) যদি ব্যতিক্রম ছুঁড়ে দেওয়া হয়।

— স্যাম ডটন

আমি এটিতে ভোট দিয়েছি, কারণ আপনি যদি অন্যান্য সমাধান ব্যবহার করেন তবে ব্রাউজার দু'বার অস্তিত্ব পরীক্ষা করবে। বলুন আপনি ´acb = 2´ কল করতে চান ´ ব্রাউজার হয়েছে মান পরিবর্তন করার আগে অস্তিত্ব পরীক্ষা করুন (অন্যথায় এটি ওএস হাতে ক্যাচ একটি মেমরি ত্রুটি হতে হবে)।

এখনও প্রশ্নটি রয়ে গেছে: ব্রাউজারগুলির জন্য একটি ক্যাপচার সেট আপ করতে বা ডাকে কল করতে ডাইনি এক দ্রুত hasOwnProperty()?

কেন আবার এই খারাপ? এটি আমার কাছে সবচেয়ে পরিষ্কার দেখাচ্ছে।

— অস্টিন প্রার্থনা

আমি বলব: আপনি যদি আশা করেন যে সম্পত্তিটি এটির চেয়ে অস্তিত্বের চেয়ে বেশি রয়েছে তবে এটি চেষ্টা করে ব্লকে জড়িয়ে রাখা ঠিক is যদি তা না থাকে তবে এটি একটি ত্রুটি। তবে আপনি যদি অলস হন এবং সম্পত্তিটির অস্তিত্ব না থাকে তার জন্য ক্যাচ ব্লকে নিয়মিত কোড রাখুন চেষ্টা করুন / ধরার অপব্যবহার হয়েছে। এখানে একটি যদি / অন্য কিছু বা অনুরূপ কিছু প্রয়োজন।

— রোবসচ

Answer 8

ES6 উত্তর, পুরোপুরি পরীক্ষিত :)

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

Full সম্পূর্ণ পরীক্ষার কভারেজ সহ কোডেন দেখুন →

Comments

আমি আপনার পরীক্ষাগুলি ফ্ল্যাট প্রপ এর মান 0 এ সেট করতে ব্যর্থ করে দিয়েছি You

— জীবাণু

নেই @germain এই আপনার জন্য কাজ করে? (আমি স্পষ্টভাবে ===বিভিন্ন falsys, এবং যোগ টেস্টের জন্য তুলনা করি । আপনার যদি আরও ভাল ধারণা থাকে তবে আমাকে জানান)।

— ফ্রাঙ্ক নোক 11

আমি আপনার পরীক্ষাগুলি আবার ফ্ল্যাট প্রোপের মান সেট করে ব্যর্থ করে দিয়েছি false। এবং তারপরে আপনি নিজের অবজেক্টটিতে একটি মান রাখতে চান undefined(আমি জানি এটি অদ্ভুত তবে জেএস)। আমি এতে একটি ইতিবাচক মিথ্যা মান সেট করেছি 'Prop not Found':const hasTruthyProp = prop => prop === 'Prop not found' ? false : true const path = obj => path => path.reduce((obj, prop) => { return obj && obj.hasOwnProperty(prop) ? obj[prop] : 'Prop not found' }, obj) const myFunc = compose(hasTruthyProp, path(obj))

— জার্মাইনে

আপনি কি আমার কোডেনকে কাঁটাচামচ করতে (উপরে ডানদিকের, সহজ), সংশোধন ও পরীক্ষা যুক্ত করতে পারেন এবং আমাকে আপনার URL টি প্রেরণ করতে পারেন? ধন্যবাদ =)

— ফ্রাঙ্ক নোক

একটি (বিশাল) তৃতীয় পক্ষের লাইব্রেরিতে দৌড়ানো ... সম্ভব, তবে আমার পছন্দ নয়।

— ফ্রাঙ্ক নোক্কে

Answer 9

আপনি বাবেল 7 - tc39-प्रस्ताव-alচ্ছিক-চেইন সহ একসাথে tc39 alচ্ছিক চেইনিং প্রস্তাব ব্যবহার করতে পারেন

কোডটি এর মতো দেখাবে:

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

Comments

মনে রাখবেন যে কিছু টিসি 39 সদস্যের আপত্তি থাকায় এই বাক্য গঠনটি প্রায় অবশ্যই পরিবর্তন হবে।

— jhpratt GOFUNDME RELICENSING

সম্ভবত তবে এটি সময়ে কোনও কোনও আকারে উপলভ্য হবে এবং এটিই কেবল গুরুত্বপূর্ণ ..

— Goran.it

Answer 10

আমি পুনরাবৃত্তির পদ্ধতির চেষ্টা করেছি:

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

আমি এটি অজানা কী / মানগুলির সাথে একগুচ্ছ অবজেক্টগুলির একটি বন্ধুত্বপূর্ণ এইচটিএমএল ভিউ মুদ্রণ করতে ব্যবহার করছি eg

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

Answer 11

আমি মনে করি যে নিম্নলিখিত লিপিটি আরও পাঠযোগ্য উপস্থাপনা দেয়।

একটি ফাংশন ঘোষণা:

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

কিন্তু এবার ইন্টেলিজেন্স কাজ করে!

এছাড়াও, আপনি একটি ডিফল্ট মান সেট করতে পারেন:

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

Comments

°0o <°(())))><

— ড্যানিয়েল ডব্লিউ।

আমি এটি পছন্দ করি, কারণ এটি সৎ এবং আপনার Objectধরণের যখন আপনি জানেন না তখন আপনার মুখে একটি "অপরিজ্ঞাত" ছুঁড়ে দেয় । +1 টি।

যতক্ষণ আপনি এই বক্তব্যকে

— পেরেনস এ রাখেন ততক্ষণ

ধন্যবাদ সুইভেনটিস আমি আপনার মন্তব্য পছন্দ। এটি দেখতে বেশ সুন্দর কোণ - এই জাতীয় শর্তগুলি বেশিরভাগ "ifs" এ ব্যবহৃত হয় এবং সর্বদা বাহ্যিক বন্ধনী দ্বারা বেষ্টিত থাকে। সুতরাং, হ্যাঁ, এটি বেশিরভাগ ক্ষেত্রেই সত্যিই একটি সুখী ক্লাউন :)))

— VeganHunter

— এটির

Answer 12

একটি গ্লোবাল তৈরি 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)){
   ....
}

Comments

দুর্দান্ত কাজ করে। সহজ এবং দক্ষ

— gbland777

Answer 13

একটি সহজ উপায় হ'ল:

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 সংজ্ঞায়িত না হয়।

Answer 14

আমি প্রক্সি ব্যবহার করার কোনও উদাহরণ দেখিনি

তাই আমি আমার নিজের সাথে এসেছি। এটি সম্পর্কে দুর্দান্ত জিনিসটি হল যে আপনাকে স্ট্রিংগুলি ইন্টারপোল্ট করতে হবে না। আপনি আসলে একটি চেইন-সক্ষম অবজেক্ট ফাংশনটি ফিরিয়ে দিতে পারেন এবং এটির সাথে কিছু জাদুকরী কাজ করতে পারেন। এমনকি আপনি গভীর ফাংশনগুলির জন্য চেক করতে ফাংশনগুলিতে কল করতে এবং অ্যারে সূচকগুলি পেতে পারেন

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

উপরের কোডটি সিঙ্ক্রোনাস স্টাফের জন্য সূক্ষ্মভাবে কাজ করে। তবে আপনি কীভাবে এমন কোনও কিছুর পরীক্ষা করবেন যা এই এজ্যাক্স কলটির মতো অ্যাসিনক্রোনাস? আপনি কিভাবে এটি পরীক্ষা করবেন? যদি প্রতিক্রিয়া 500 টি ত্রুটি ত্রুটি দেয় যখন জাসন না হয়?

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

নিশ্চিত যে আপনি কিছু কলব্যাক থেকে মুক্তি পাওয়ার জন্য অ্যাসিঙ্ক ব্যবহার করতে / অপেক্ষা করতে পারেন। তবে আপনি যদি আরও যাদুতে এটি করতে পারতেন তবে কী হবে? এরকম দেখতে এমন কিছু:

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

Comments

যদি কেউ আগ্রহী হন, আমি এনপিএম

— এন্ডলেস

Answer 15

এই উত্তরের ভিত্তিতে , আমি এই জেনেরিক ফাংশনটি নিয়ে এসেছি 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 );
}

Comments

এখানে আমার চূড়ান্ত পন্থাটি রয়েছেfunction validChain (object, path) { return path.split('.').reduce((a, b) => (a || { })[b], object) !== undefined }

— জেমস হ্যারিংটন

Answer 16

নেস্টেড অবজেক্টের বৈশিষ্ট্যগুলি নিরাপদে পাওয়ার জন্য আমি একটি সামান্য ফাংশন তৈরি করেছি।

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

ডকুমেন্টেশন সহ সমস্ত কোড এবং পরীক্ষাগুলি দেখার জন্য আপনি আমার গিথুব গিস্টটি পরীক্ষা করতে পারেন: https://gist.github.com/vsambor/3df9ad75ff3de489bbcb7b8c60beebf4#file-javascriptgetnestedvalues-js

Answer 17

@ সিএমএসের দুর্দান্ত উত্তরের একটি সংক্ষিপ্ত, 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

Comments

এটির সাথে একমাত্র সমস্যাটি যদি সেখানে একাধিক স্তরের সংজ্ঞায়িত কীগুলি থাকে তবে আপনি একটি টাইপরর পেতে পারেন, যেমনcheckObjHasKeys(test, ['level1', 'level2', 'asdf', 'asdf']);

— জে.কে.এস

আরও উপযুক্ত পদ্ধতি হ'ল প্রতিটি , যার মান সরাসরি ফেরত যেতে পারে।

— রবজি

হয়তো পরিবর্তন success = false;করতে return false। একবারে আপনার বিরতি জেনে যাওয়ার পরে আপনাকে জামিন দেওয়া উচিত, একবারের শূন্যতা বা অপরিজ্ঞাত হওয়ার পরে আরও গভীর কিছু থাকতে পারে না। এটি গভীর নেস্টেড আইটেমগুলিতে ত্রুটিগুলি আটকাতে পারে, যেহেতু তারা স্পষ্টতই নেই।

— ওয়েড

Answer 18

আমি মনে করি এটি সামান্য উন্নতি (1-লাইনারে পরিণত হয়):

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

এটি কাজ করে কারণ && অপারেটর এটির চূড়ান্ত অপারেন্ডটি মূল্যায়ন করে (এবং এটি শর্ট সার্কিট) returns

Answer 19

সম্পত্তিটি উপস্থিত থাকলে আমি ফিরে আসার মান খুঁজছিলাম, তাই আমি উপরের সিএমএস দ্বারা উত্তরটি পরিবর্তন করেছি। আমি এখানে যা এলাম তা এখানে:

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

Answer 20

সিএমএসের দেওয়া উত্তরটি নাল চেকগুলির জন্য নিম্নলিখিত সংশোধন করেও ভাল কাজ করে

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

Answer 21

নিম্নলিখিত উত্তরগুলি এই উত্তর থেকে শুরু করে বিশদভাবে বর্ণিত হয়েছিল । উভয়ের জন্য একই গাছ:

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

Answer 22

আমি জানি এই প্রশ্নটি পুরানো, তবে আমি এটি সমস্ত বস্তুতে যুক্ত করে একটি এক্সটেনশান অফার করতে চেয়েছিলাম। আমি জানি যে লোকেরা প্রসারিত অবজেক্টের কার্যকারিতার জন্য অবজেক্ট প্রোটোটাইপটি ব্যবহার করার প্রবণতা দেখায়, তবে আমি এটি করার চেয়ে সহজ কিছু পাই না। এছাড়াও, এটি এখন অবজেক্ট.ডিফাইনপোপার্টি পদ্ধতি দ্বারা অনুমোদিত।

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 অন্তর্ভুক্ত রয়েছে যা আপনি সম্পত্তিটি অগণনীয় হওয়ার কারণে সরাসরি অবজেক্ট.প্রোটোটাইপটি সংশোধন করেন s এটি তৃতীয় পক্ষের গ্রন্থাগারগুলির সাথে সূক্ষ্মভাবে কাজ করা উচিত।

Answer 23

এটি সমস্ত অবজেক্ট এবং অ্যারে নিয়ে কাজ করে :)

উদা:

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

এটি ব্রায়ানের উত্তরের আমার উন্নত সংস্করণ

আমি সম্পত্তিটিকে নাম হিসাবে ব্যবহার করেছি কারণ এটি বিদ্যমান সম্পত্তিগুলির সাথে বিরোধ করতে পারে (উদা: মানচিত্র)

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

এখানে বেহালার

Answer 24

আমি এখানে এটি গ্রহণ করি - এই সমাধানগুলির বেশিরভাগ নীচে নেস্টেড অ্যারের ক্ষেত্রে উপেক্ষা করে:

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

Answer 25

এখন আমরা 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)

Answer 26

আপনি পুনরাবৃত্তি ফাংশন ব্যবহার করে এটি করতে পারেন। আপনি সমস্ত নেস্টেড অবজেক্ট কীগুলির নাম না জানলেও এটি কাজ করবে।

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

Answer 27

এখানে কোডোডাবোডে (সেফরেড) একটি ফাংশন রয়েছে যা এটি নিরাপদ উপায়ে করবে ... যেমন

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

যদি কোনও সম্পত্তি নাল বা অপরিজ্ঞাত হয় তবে একটি খালি স্ট্রিংটি ফিরে আসে

Comments

আমি

— টেম্প্লেটিংয়ের

Answer 28

পূর্ববর্তী মন্তব্যের উপর ভিত্তি করে , এখানে আরও একটি সংস্করণ দেওয়া হয়েছে যেখানে মূল বিষয়টিকেও সংজ্ঞায়িত করা যায়নি:

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

Answer 29

আমি আমার নিজস্ব ফাংশন লিখেছি যা পছন্দসই পথে নিয়ে যায়, এবং একটি ভাল এবং খারাপ কলব্যাক ফাংশন রয়েছে।

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

Comments

আমার উত্তরটির

— ডেভউডহল

Answer 30

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