यदि कोई ऑब्जेक्ट जावास्क्रिप्ट में एक विशिष्ट संपत्ति है, तो मैं कैसे जांच सकता हूं?

Question

यदि कोई ऑब्जेक्ट जावास्क्रिप्ट में एक विशिष्ट संपत्ति है, तो मैं कैसे जांच सकता हूं?

विचार करें:

x = {'key': 1};
if ( x.hasOwnProperty('key') ) {
    //Do this
}

क्या यह करने का सबसे अच्छा तरीका है?

Comments

मैंने सभी के उत्तरों के साथ एक jsperf टेस्ट लिखा, जो सबसे तेज़ है: jsperf.com/dEDIA-contains-key

— styfle

('गुणनाम' वस्तु में)? 'संपत्ति वहाँ नहीं है': 'संपत्ति है'

— मोहन राम

jsperf टेस्ट के लिए @styfle धन्यवाद। inऔर hasOwnPropertyबाहर आ गया जिस तरह से दूसरों की तुलना में धीमी मेरे लिए (98% धीमी)। मैं hasOwnPropertyधीमे होने के बारे में हैरान नहीं हूं लेकिन मैं हैरान हूं in।

— evanrmurphy

Answer 1

मैं उन उत्तरों से वास्तव में भ्रमित हूं जो दिए गए हैं - उनमें से ज्यादातर केवल एकमुश्त गलत हैं। बेशक आपके पास ऑब्जेक्ट गुण हो सकते हैं जिनके पास अपरिभाषित, अशक्त या गलत मान हैं। तो बस संपत्ति की जांच को कम करना typeof this[property], या इससे भी बदतर, x.keyआपको पूरी तरह से भ्रामक परिणाम देगा।

यह इस बात पर निर्भर करता है कि आप क्या खोज रहे हैं। यदि आप जानना चाहते हैं कि क्या किसी वस्तु में भौतिक रूप से संपत्ति है (और यह प्रोटोटाइप श्रृंखला पर कहीं से नहीं आ रही है) तो object.hasOwnPropertyजाने का रास्ता है। सभी आधुनिक ब्राउज़र इसका समर्थन करते हैं। (यह सफारी के पुराने संस्करणों - 2.0.1 और पुराने में गायब था - लेकिन ब्राउज़र के उन संस्करणों का उपयोग शायद ही कभी किया जाता है।)

यदि आप जिस चीज की तलाश कर रहे हैं, यदि कोई वस्तु उस पर एक संपत्ति है जो चलने योग्य है (जब आप वस्तु के गुणों पर पुनरावृति करते हैं, तो वह दिखाई देगा) तब करना: prop in objectआपको अपना वांछित प्रभाव देगा।

चूंकि उपयोग hasOwnPropertyकरना संभव है कि आप क्या चाहते हैं, और यह देखते हुए कि आप एक पतन विधि चाहते हैं, मैं आपके लिए निम्न समाधान प्रस्तुत कर सकता हूं:

var obj = {
    a: undefined,
    b: null,
    c: false
};

// a, b, c all found
for ( var prop in obj ) {
    document.writeln( "Object1: " + prop );
}

function Class(){
    this.a = undefined;
    this.b = null;
    this.c = false;
}

Class.prototype = {
    a: undefined,
    b: true,
    c: true,
    d: true,
    e: true
};

var obj2 = new Class();

// a, b, c, d, e found
for ( var prop in obj2 ) {
    document.writeln( "Object2: " + prop );
}

function hasOwnProperty(obj, prop) {
    var proto = obj.__proto__ || obj.constructor.prototype;
    return (prop in obj) &&
        (!(prop in proto) || proto[prop] !== obj[prop]);
}

if ( Object.prototype.hasOwnProperty ) {
    var hasOwnProperty = function(obj, prop) {
        return obj.hasOwnProperty(prop);
    }
}

// a, b, c found in modern browsers
// b, c found in Safari 2.0.1 and older
for ( var prop in obj2 ) {
    if ( hasOwnProperty(obj2, prop) ) {
        document.writeln( "Object2 w/ hasOwn: " + prop );
    }
}

उपरोक्त एक कार्य, क्रॉस-ब्राउज़र, hasOwnPropertyएक केविट के साथ समाधान है : यह उन मामलों के बीच अंतर करने में असमर्थ है जहां एक समान संपत्ति प्रोटोटाइप और उदाहरण के लिए है - यह सिर्फ यह मानता है कि यह प्रोटोटाइप से आ रहा है। आप इसे अपनी स्थिति के आधार पर अधिक उदार या सख्त होने के लिए स्थानांतरित कर सकते हैं, लेकिन कम से कम यह अधिक उपयोगी होना चाहिए।

Comments

@grantwparks यदि आप एक साधारण स्लाइडर प्लगइन का निर्माण कर रहे हैं और एक विकल्प आइटम के अस्तित्व की जांच करना चाहते हैं, तो यह वास्तव में आवश्यकता से अधिक हो सकता है। आप बस कुछ ऐसा कर सकते हैं var w = opts.w || 100;। लेकिन अगर आप किसी तरह की लाइब्रेरी में हैं, तो आपको कुछ हिस्सों में थोड़ा दूर जाना पड़ सकता है।

— हालिल Halzgür

@ kralco626: हाँ, आजकल मुझे लगता है कि hasOwnProperty () के साथ जाना बहुत सुरक्षित है - लेकिन सही मायने में सुरक्षित क्रॉस-ब्राउज़र समाधान के लिए, जॉन के साथ जाएं।

— याकूब

अशक्त करने के लिए अस्थायी परिवर्तन के बारे में क्या __proto__? सरल निहितार्थ: function hasOwnProperty(obj, prop) { var temp = obj.__proto__; obj.__proto__ = null; var ret = prop in obj; obj.__proto__ = temp; return ret; }(केस को obj.constructor.prototypeजोड़ा जाना चाहिए)।

— औसत जो

@ कैस्केन __proto__गैर-मानक है और कुछ पुराने ब्राउज़रों में काम नहीं करता है। और यहां तक Object.getPrototypeOfकि मानक के हालिया जोड़ से भी आप मौजूदा वस्तु के प्रोटोटाइप को बदल नहीं सकते।

— मैट ब्राउन

एक for(prop in object)लूप केवल गणना करने योग्य गुणों को पुनरावृत्त करता है। हालाँकि, यह prop in objectजाँच करता है कि प्रोटोपॉजिकल चेन में कहीं objectसंपत्ति propहै या नहीं, स्वतंत्र रूप से यह पता लगाने योग्य है कि नहीं।

— ओरिऑल

Answer 2

के साथ Underscore.jsया (और भी बेहतर ) lodash:

_.has(x, 'key');

जो कॉल करता है Object.prototype.hasOwnProperty, लेकिन (ए) टाइप करने के लिए छोटा है, और (बी) "एक सुरक्षित संदर्भ" का उपयोग करता है hasOwnProperty(यानी यह hasOwnPropertyओवरराइट किया गया है तो भी काम करता है)।

विशेष रूप से, लॉश परिभाषित _.hasकरता है:

   function has(object, key) {
      return object ? hasOwnProperty.call(object, key) : false;
   }
   // hasOwnProperty = Object.prototype.hasOwnProperty

Comments

मुझे लगता है कि यह होगा क्योंकि "इस पुस्तकालय को जोड़ने" शायद ही कभी एक लोकप्रिय समाधान है, जब प्रश्न जटिल डोम हेरफेर के बारे में है और जवाब "गो उपयोग jQuery" है।

— विनफील्ड ट्रेल

मैं आपकी बात देख रहा हूं, @sud प्रसिद्ध, धन्यवाद। संयोग से, अगर किसी को पूरे लॉश लाइब्रेरी में शामिल किया गया था, जो सब-कमर्स को संकलित कर सकता था या npm install lodash.hasजो एक npm मॉड्यूल को केवल एक hasफ़ंक्शन के साथ उजागर करता है जो कि minified होने पर 175 बाइट्स तक संकलित करता है। यह देखने के लिए भी व्यावहारिक है lodash.has/index.jsकि एक बहुत लोकप्रिय और विश्वसनीय पुस्तकालय कैसे काम करता है।

— ब्रायन एम। हंट

और इसके lodashसंस्करण इसके साथ काम .has(undefined, 'someKey') => falseकरते हैं : जबकि underscoreरिटर्नundefined

— ब्रैड पार्क्स

lodash"अभी तक एक और" निर्भरता के रूप में जोड़ने के बारे में रोना हर किसी के लिए : यह इस तरह की चीज के लिए एक काफी सामान्य (यदि सबसे आम नहीं) पुस्तकालय है। पहिया को मज़बूत बनाने में मज़ा लें।

— प्रिड्यू नीमरे

यहां तक ​​कि अगर आप पहिया को सुदृढ़ करना चाहते हैं, तो मौजूदा पहियों की जांच करना एक बुरा विचार नहीं है।

— अट्टुरसम्स

Answer 3

व्हाट अबाउट?

var x = {'key': 1};

if ('key' in x) {
    console.log('has');
}

Comments

बस ध्यान दें, यह संकीर्ण अर्थों में 'ऑब्जेक्ट्स' के साथ काम करता है, इसलिए {} के रूप में घोषित किया गया है या कंस्ट्रक्टर का उपयोग करके बनाया गया है, यह सरणियों या प्राइमेटिव्स को स्वीकार नहीं करता है। ऐसा नहीं है कि ओपी को इसकी आवश्यकता है, लेकिन कुछ अन्य उत्तर उपस्थित तकनीकें हैं जो अधिक व्यापक हैं (सरणियों, तार आदि के साथ काम करते हैं)

— डेन्यूबियन सेलर

@ РСТ accepted यह इंगित करने के लिए धन्यवाद कि (स्वीकृत उत्तर इस बात पर विवरण में नहीं है कि किसी को inऑपरेटर का उपयोग क्यों करना चाहिए या नहीं। यह भी ध्यान दें कि inऑपरेटर के पास उत्कृष्ट ब्राउज़र समर्थन IE 5.5+, Chrome 1.0+, Firefox 1.0+, Safari 3.0+ stackoverflow.com/questions/2920765/…

— Adrien

ऑपरेटर inप्रोटोटाइप गुणों के खिलाफ भी जांच करता है, जबकि hasOwnPropertyउपयोगकर्ता द्वारा परिभाषित गुणों को केवल पुनरावृत्त करता है। संदर्भ: developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— adi518

'key' in x ऐसा सरणियों के साथ काम करते हैं। प्रमाण: stackoverflow.com/questions/33592385/…

— CosmoMyzrailGorynych

सबसे अच्छा और सबसे छोटा विकल्प लगता है

— user365314

Answer 4

नोट : निम्नलिखित आजकल मोटे तौर पर अप्रचलित है सख्त मोड के लिए धन्यवाद, और hasOwnProperty। सही समाधान सख्त मोड का उपयोग करना और उपयोग करने वाली संपत्ति की उपस्थिति की जांच करना है obj.hasOwnProperty। यह उत्तर इन दोनों चीजों को पूर्व निर्धारित करता है , कम से कम व्यापक रूप से कार्यान्वित किया जाता है (हाँ, यह पुराना है)। निम्नलिखित को एक ऐतिहासिक नोट के रूप में लें।

---

ध्यान रखें कि undefinedहै (दुर्भाग्य से) नहीं जावास्क्रिप्ट में एक आरक्षित शब्द आप सख्त मोड का उपयोग नहीं कर रहे हैं। इसलिए, कोई (कोई और, जाहिर है) आपके कोड को तोड़ने, इसे फिर से परिभाषित करने का भव्य विचार हो सकता है।

एक अधिक मजबूत विधि इस प्रकार है:

if (typeof(x.attribute) !== 'undefined')

दूसरी तरफ, यह विधि बहुत अधिक क्रिया है और धीमी भी है। : - /

एक सामान्य विकल्प के लिए सुनिश्चित करें कि है undefinedहै वास्तव में अपरिभाषित, एक समारोह जो एक अतिरिक्त पैरामीटर स्वीकार करता है, कहा जाता है में कोड डालकर जैसे undefined, कि एक मूल्य के पारित नहीं किया जाता है। यह सुनिश्चित करने के लिए कि यह मान पारित नहीं हुआ है, आप इसे तुरंत स्वयं कह सकते हैं, जैसे:

(function (undefined) {
    … your code …
    if (x.attribute !== undefined)
        … mode code …
})();

Comments

बस जिज्ञासु, चूंकि void 0विहित को लौटाने के लिए परिभाषित किया गया है undefined, क्या कोई कर सकता है x.attribute !== void 0?

— ब्रायन एम। हंट

ब्रायन: मैं कोई विशेषज्ञ नहीं हूं, लेकिन यह सुनिश्चित करने के लिए कि यह सही होने के लिए एक चतुर तरीका है।

— क्रिस्टोफर स्मिथ

यदि प्रसिद्ध 'किसी और' ने जो अपरिभाषित है उसे फिर से परिभाषित किया है, तो मुझे लगता है कि एएचएटी कोड को फिर से लिखने के लिए कार्रवाई का सबसे अच्छा तरीका होगा।

— Oskar Holmkratz

एक ठोस अपरिभाषित संस्करण के लिए सबसे अच्छा है, एक क्लोजर के भीतर काम करना है, और एक बेजोड़ फ़ंक्शन हस्ताक्षर है:(function (undefined) { // undefined is actually undefined here })();

— bgusach

@evanrmurphy इसका उपयोग न करें, यह गंभीर रूप से पुराना है (मेरे उत्तर की शुरुआत में नोट देखें)।

— कोनराड रूडोल्फ

Answer 5

if (x.key !== undefined)

Armin Ronacher ने मुझे पहले ही हरा दिया लगता है , लेकिन:

Object.prototype.hasOwnProperty = function(property) {
    return this[property] !== undefined;
};

x = {'key': 1};

if (x.hasOwnProperty('key')) {
    alert('have key!');
}

if (!x.hasOwnProperty('bar')) {
    alert('no bar!');
}

कोनराड रूडोल्फ और अर्मिन रोनाचेर द्वारा बताया गया एक सुरक्षित, लेकिन धीमा समाधान होगा:

Object.prototype.hasOwnProperty = function(property) {
    return typeof this[property] !== 'undefined';
};

Comments

मुझे नहीं लगता कि यह काफी अच्छा है। x.hasOwnProperty('toString') === true;

— जो सिमंस

असहमत होने के लिए नहीं, बल्कि समझने के लिए। क्या कोई बिंदु है जहां x.hasOwnProperty एक बूलियन सच या झूठ के अलावा कुछ भी लौटाएगा? यदि नहीं, तो पोस्ट किए गए कोड को हर बार काम करना चाहिए। मुझे लगता है कि अगर विधि को ओवरराइड किया गया था, लेकिन तब, परिणाम पर भरोसा करना कभी भी विश्वसनीय नहीं होगा जब तक आप ओवरराइडिंग विधि को नहीं जानते।

— enobrev

मुझे लगता है कि हमारे पास गलत सूचना है। मेरा मतलब है कि आपकी पद्धति का उपयोग करते हुए, यह कहेंगे कि'String 'अपनी संपत्ति है, लेकिन यह नहीं है।

— जो सीमन्स

Object.prototypeपहले से ही एक अंतर्निहित, सही है hasOwnProperty। एक गलत कार्यान्वयन के साथ इसे ओवरराइट करना (1. गुणों का मूल्य हो सकता है undefined, 2. यह विरासत में मिली संपत्तियों के लिए झूठी सकारात्मकता देगा) बस एक छिपी हुई बुरी कल्पना है। गलत उत्तर हटाए जा सकते हैं और हटाए जाने चाहिए। मुझे नहीं पता कि जब आप Resig का उत्तर देखते हैं तो आप 'Sep8' में वापस कर सकते हैं , इसलिए अब ऐसा करने का सुझाव देते हुए टिप्पणी करना।

— TJ Crowder

Answer 6

आप inऑपरेटर का उपयोग यह जांचने के लिए कर सकते हैं कि संपत्ति किसी वस्तु पर मौजूद है या नहीं:

x = {'key': 1};
alert("key" in x);

आप लूप का उपयोग करके ऑब्जेक्ट के सभी गुणों के माध्यम से भी लूप कर सकते हैं for - in, और फिर विशिष्ट संपत्ति की जांच कर सकते हैं:

for (prop in x) {
    if (prop == "key") {
        //Do something
    }
}

आपको इस बात पर विचार करना चाहिए कि क्या यह ऑब्जेक्ट प्रॉपर्टी एन्युमरेबल है या नहीं, क्योंकि नॉन-एन्युमेरेबल प्रॉपर्टीज for-inलूप में नहीं दिखेंगी । इसके अलावा, अगर एन्युमेरेबल प्रॉपर्टी प्रोटोटाइप की गैर-एन्यूमरेबल प्रॉपर्टी को शैडो कर रही है, तो यह इंटरनेट एक्सप्लोरर 8 और उससे पहले के शो में दिखाई नहीं देगी ।

यदि आप सभी उदाहरण गुणों की एक सूची चाहते हैं, चाहे वह संभव हो या न हो, आप उपयोग कर सकते हैं

Object.getOwnPropertyNames(x);

यह उन सभी गुणों के नामों की एक सरणी लौटाएगा जो किसी ऑब्जेक्ट पर मौजूद हैं।

अंत में, आप ऑब्जेक्ट प्रॉपर्टी के डेटा प्रकार को सीधे जांचने के लिए टाइपोफ़ ऑपरेटर का उपयोग कर सकते हैं:

if (typeof x.key == "undefined") {
    alert("undefined");
}

यदि संपत्ति ऑब्जेक्ट पर मौजूद नहीं है, तो यह स्ट्रिंग को अपरिभाषित लौटा देगा। इसके बजाय यह उचित संपत्ति प्रकार लौटाएगा। हालाँकि, ध्यान दें कि यह हमेशा जाँचने का एक वैध तरीका नहीं है कि किसी वस्तु के पास कोई संपत्ति है या नहीं, क्योंकि आपके पास एक ऐसी संपत्ति हो सकती है जो अपरिभाषित है, जिस स्थिति में, उपयोग typeof x.keyकरना अभी भी सही होगा (भले ही कुंजी अभी भी हो वस्तु में)।

अद्यतन: आप जाँच सकते हैं कि क्या कोई संपत्ति अपरिभाषित जावास्क्रिप्ट संपत्ति की तुलना में मौजूद है

if (x.key === undefined) {
    alert("undefined");
}

यह तब तक काम करना चाहिए जब तक कि कुंजी विशेष रूप undefinedसे एक्स ऑब्जेक्ट पर सेट न हो

Comments

आपका अपडेट हिस्सा गलत है। कृपया यहां देखें: jsfiddle.net/sbgg04yg

— नंबर 945

उन परिदृश्यों को दिखाने के लिए, जहाँ जावास्क्रिप्ट अपरिभाषित संपत्ति की तुलना करना विफल हो सकता है

— goonerify

Answer 7

आइए यहां कुछ भ्रम से काटते हैं। पहले, चलो hasOwnPropertyपहले से मौजूद मानकर सरल करें ; उपयोग में वर्तमान ब्राउज़रों के विशाल बहुमत का यह सच है।

hasOwnPropertyसही है यदि विशेषता नाम जो इसे पास किया गया है वह ऑब्जेक्ट में जोड़ा गया है। यह पूरी तरह से इसके लिए सौंपे गए वास्तविक मूल्य से स्वतंत्र है जो कि वास्तव में हो सकता है undefined।

इसलिये:

var o = {}
o.x = undefined

var a = o.hasOwnProperty('x')  // a is true
var b = o.x === undefined // b is also true

तथापि:

var o = {}

var a = o.hasOwnProperty('x')  // a is now false
var b = o.x === undefined // b is still true

समस्या यह है कि क्या होता है जब प्रोटोटाइप श्रृंखला में एक वस्तु अपरिभाषित के मूल्य के साथ एक विशेषता होती है? hasOwnPropertyइसके लिए झूठ होगा, और ऐसा ही होगा !== undefined। फिर भी, for..inइसे अभी भी गणना में सूचीबद्ध करेगा।

लब्बोलुआब यह है कि कोई क्रॉस-ब्राउज़र तरीका नहीं है (चूंकि इंटरनेट एक्सप्लोरर उजागर नहीं करता है __prototype__) यह निर्धारित करने के लिए कि एक विशिष्ट पहचानकर्ता किसी वस्तु या इसके प्रोटोटाइप श्रृंखला में कुछ भी संलग्न नहीं किया गया है।

Answer 8

यदि आप एक संपत्ति खोज रहे हैं, तो "नहीं"। तुम्हें चाहिए:

if ('prop' in obj) { }

सामान्य तौर पर आपको परवाह नहीं करनी चाहिए कि संपत्ति प्रोटोटाइप या ऑब्जेक्ट से आती है या नहीं।

हालाँकि, क्योंकि आपने अपने नमूना कोड में 'कुंजी' का उपयोग किया है, ऐसा लगता है कि आप ऑब्जेक्ट को हैश के रूप में मान रहे हैं, जिस स्थिति में आपका उत्तर समझ में आएगा। सभी हैश कीज़ ऑब्जेक्ट में गुण होंगे, और आप प्रोटोटाइप द्वारा योगदान किए गए अतिरिक्त गुणों से बचते हैं।

जॉन रेजिग का जवाब बहुत व्यापक था, लेकिन मुझे लगा कि यह स्पष्ट नहीं था। विशेष रूप से जब "ओब्ज में" प्रोप का उपयोग करने के लिए "।

Comments

ध्यान दें कि inऑपरेटर के पास उत्कृष्ट ब्राउज़र सपोर्ट है IE 5.5+, Chrome 1.0+, Firefox 1.0+, Safari 3.0+ stackoverflow.com/questions/2920765/…

— Adrien Be

जैसा कि inऑपरेटर के उपयोग के संबंध में एक अन्य टिप्पणी में कहा गया है : "यह संकीर्ण अर्थों में 'ऑब्जेक्ट्स' के साथ काम करता है, इसलिए {} के रूप में घोषित किया गया है या निर्माणकर्ता का उपयोग करके बनाया गया है, यह सरणियों या आदिम स्वीकार नहीं करता है। ऐसा नहीं है कि ओपी को इसकी आवश्यकता है, लेकिन कुछ अन्य उत्तर उपस्थित तकनीकें जो अधिक व्यापक हैं (सरणियों, तार आदि के साथ काम करते हैं) "

— एड्रिन बी

टिप्पणी करने का कारण मुझे टिप्पणी के बिना दो बार अपमानित किया गया है। लेकिन मुझे अभी भी मेरा जवाब पसंद है। शायद जिसने भी ऐसा किया है वह सभी प्रकार की संपत्तियों के परीक्षण के लिए सभी तरीकों के लिए एक 'व्यापक' उत्तर चाहता था .. लेकिन मेरा उत्तर वैचारिक और उसके लिए पर्याप्त है। पुन: एड्रियन हो, एक अपरिवर्तनीय संपत्ति वह है जो सामान्य उपयोगकर्ता गुंजाइश के लिए नहीं है, इसलिए वैचारिक रूप से 'इन' ठीक है;)

— जेरार्ड ओनेइल

Answer 9

साधारण वस्तुओं के परीक्षण के लिए: if (obj[x] !== undefined)

यदि आपको नहीं पता कि यह किस प्रकार का उपयोग है: if (obj.hasOwnProperty(x))

अन्य सभी विकल्प धीमे हैं ।।

विवरण

यहां अन्य लोगों द्वारा सुझाए गए 5 विकल्पों के लिए नोडेज के तहत 100,000,000 चक्रों का प्रदर्शन मूल्यांकन:

function hasKey1(k,o) { return (x in obj); }
function hasKey2(k,o) { return (obj[x]); }
function hasKey3(k,o) { return (obj[x] !== undefined); }
function hasKey4(k,o) { return (typeof(obj[x]) !== 'undefined'); }
function hasKey5(k,o) { return (obj.hasOwnProperty(x)); }

मूल्यांकन हमें बताता है कि जब तक हम विशेष रूप से ऑब्जेक्ट की प्रोटोटाइप चेन और साथ ही ऑब्जेक्ट की जांच नहीं करना चाहते हैं, तब तक हमें सामान्य रूप का उपयोग नहीं करना चाहिए: if (X in Obj)... यह उपयोग के मामले के आधार पर 2 से 6 गुना धीमा है

hasKey1 execution time: 4s 510.427785ms
hasKey2 execution time: 0s 904.374806ms
hasKey3 execution time: 0s 760.336193ms
hasKey4 execution time: 0s 935.19901ms
hasKey5 execution time: 2s 148.189608ms

नीचे की रेखा, यदि आपका ओब्ज आवश्यक रूप से एक साधारण वस्तु नहीं है और आप ऑब्जेक्ट के प्रोटोटाइप चेन की जांच करने से बचना चाहते हैं और यह सुनिश्चित करना चाहते हैं कि एक्स सीधे ओब्ज के स्वामित्व में है, तो 'if (obj.hasOwnProperty (x)) ...' का उपयोग करें।

अन्यथा, जब एक साधारण वस्तु का उपयोग किया जाता है और ऑब्जेक्ट की प्रोटोटाइप श्रृंखला के बारे में चिंतित नहीं होता है, तो उपयोग if (typeof(obj[x]) !== 'undefined')...करना सबसे सुरक्षित और तेज़ तरीका है।

यदि आप एक हैश टेबल के रूप में एक साधारण वस्तु का उपयोग करते हैं और कभी भी कुछ भी नहीं करते हैं, तो मैं if (obj[x])...इसे और अधिक पठनीय पाता हूं।

मज़े करो।

Answer 10

हाँ यह है :) मुझे लगता है कि आप भी कर सकते हैं Object.prototype.hasOwnProperty.call(x, 'key')जो कि काम करना चाहिए अगर xकोई संपत्ति है जिसे hasOwnProperty:) कहा जाता है

लेकिन वह खुद के गुणों के लिए परीक्षण करता है। यदि आप यह जांचना चाहते हैं कि क्या उसके पास ऐसी संपत्ति है जो आपके द्वारा इस्तेमाल की जा सकने वाली भी हो सकती है typeof x.foo != 'undefined'।

Answer 11

if (typeof x.key != "undefined") {

}

चूंकि

if (x.key)

विफल रहता है अगर (उदाहरण के लिए ) x.keyहल करता है ।falsex.key = ""

Comments

सही नहीं होगा। निम्नलिखित वस्तु का प्रयास करें, const x = {key: undefined};जो इस समाधान के साथ झूठी वापसी करेगा, जबकि x.hasOwnProperty('key')); // trueऔर Reflect.has(x, 'key')); // true। संपत्ति वास्तव में मौजूद है, लेकिन मूल्य है undefined।

— विल्ट

Answer 12

आप ES6 Reflectऑब्जेक्ट का उपयोग भी कर सकते हैं :

x = {'key': 1};
Reflect.has( x, 'key'); // returns true

एमडीएन के लिए प्रलेखन यहांReflect.has पाया जा सकता है ।

स्थिर Reflect.has()विधि ऑपरेटर की तरह कार्य करती है।

Answer 13

ठीक है, ऐसा लगता है कि मेरे पास सही उत्तर था जब तक कि आपको विरासत में मिली संपत्ति नहीं चाहिए:

if (x.hasOwnProperty('key'))

विरासत में मिली संपत्तियों को शामिल करने के लिए यहां कुछ अन्य विकल्प दिए गए हैं:

if (x.key) // Quick and dirty, but it does the same thing as below.

if (x.key !== undefined)

Comments

कैविट x.hasOwnProperty ('की') सही हो सकती है जबकि x.key! == अपरिभाषित सत्य नहीं है।

— एंथनीवजोन

के लिए विधि गलत होगा। var x = { key: false };x.key

— मार्क के कोवान

अगर (x.key) सही नहीं है जैसे कि x = {key: 0}, तो यह चेकिंग पास नहीं करेगा।

— someUser

Answer 14

Do not do this object.hasOwnProperty(key)), its really bad because these methods may be shadowed by properties on the object in question - consider { hasOwnProperty: false } - or, the object may be a null object (Object.create(null)).

The best way is to do Object.prototype.hasOwnProperty.call(object, key) or:

const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
/* or */
import has from 'has'; // https://www.npmjs.com/package/has
// ...
console.log(has.call(object, key));

Comments

I agree with this method and it should be the accepted answer as it is the safest way while maintaining performance! eslint.org/docs/rules/no-prototype-builtins says "For example, it would be unsafe for a webserver to parse JSON input from a client and call hasOwnProperty directly on the resulting object, because a malicious client could send a JSON value like {"hasOwnProperty": 1} and cause the server to crash."

— Arman

Answer 15

Another relatively simple way is using Object.keys. This returns an array which means you get all of the features of an array.

var noInfo = {};
var info = {something: 'data'};

Object.keys(noInfo).length //returns 0 or false
Object.keys(info).length //returns 1 or true

Although we are in a world with great browser support. Because this question is so old I thought I'd add this: This is safe to use as of JS v1.8.5

Comments

Right but what if you wanted to know if info had a property with the name someotherthing? Which is think is what OP is looking for.

— Victorio Berra

Then you would do Object.keys(info).indexOf('someotherthing') !== -1

— hippietrail

Answer 16

hasOwnProperty "can be used to determine whether an object has the specified property as a direct property of that object; unlike the in operator, this method does not check down the object's prototype chain."

So most probably, for what seems by your question, you don't want to use hasOwnProperty, which determines if the property exists as attached directly to the object itself,.

If you want to determine if the property exists in the prototype chain you main want to use in, like:

if( prop in object ){ // do something }

I hope this helps.

Comments

I get " Cannot use 'in' operator to search for 'prop' in myObject"

— Victorio Berra

Answer 17

With risk of massive downvoting, here is another option for a specific case. :)

If you want to test for a member on an object and want to know if it has been set to something other than:

• ''
• false
• null
• undefined
• 0 ...

then you can use:

var foo = {};
foo.bar = "Yes, this is a proper value!";
if (!!foo.bar) {
        // member is set, do something
}

Comments

Compact and convenient

— Frederik Witte

A linter won't like this: eslint.org/docs/rules/no-extra-boolean-cast

— Wilt

Answer 18

ECMA Script 6 solution with reflect. Create wrapper like:

/**
Gets an argument from array or object.
The possible outcome:
- If the key exists the value is returned.
- If no key exists the default value is returned.
- If no default value is specified an empty string is returned.
@param obj    The object or array to be searched.
@param key    The name of the property or key.
@param defVal Optional default version of the command-line parameter [default ""]
@return The default value in case of an error else the found parameter.
*/
function getSafeReflectArg( obj, key, defVal) {
   "use strict";
   var retVal = (typeof defVal === 'undefined' ? "" : defVal);
   if ( Reflect.has( obj, key) ) {
       return Reflect.get( obj, key);
   }
   return retVal;
}  // getSafeReflectArg

Comments

Is this the best way to do it when you're targeting >= ES6?

— hippietrail

Imho it is the shortest and most simple answer, but maybe not the fastest in execution code. But speed is not an issue (anymore).

— Harm

Answer 19

There is method "hasOwnProperty" exists on object, but its not recommended to call this method directly because might be sometimes the object is null or some property exist on object like: { hasOwnProperty: false }

So better way would be:

// good
var obj = {"bar": "here bar desc"}
console.log(Object.prototype.hasOwnProperty.call(obj, "bar"));

// best
const has = Object.prototype.hasOwnProperty; // cache the lookup once, in module scope.
console.log(has.call(obj, "bar"));

Answer 20

You can use the following approaches-

var obj = {a:1}
console.log('a' in obj)               //1
console.log(obj.hasOwnProperty('a'))  //2
console.log(Boolean(obj.a))         //3

The difference between the following approaches are as follows-

1. In 1st and 3rd approach we are not just searching in object but its prototypal chain too. If the object does not have the property, but the property is present in its prototype chain it is going to give true.

 var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log('b' in obj)
    console.log(Boolean(obj.b))

2. 2nd approach will check only for its own properties. Ex -

var obj = {
      a:2,
      __proto__ :{b:2}
    }

    console.log(obj.hasOwnProperty('b'))

3. The difference between 1st and third is if there is a property which has value undefined the 3rd approach is going to give false while first will give true.

var obj = {
      b : undefined
    }
    console.log(Boolean(obj.b))
    console.log('b' in obj);

Answer 21

You need to use the method object.hasOwnProperty(property). It returns true if the object has the property and false if the object doesn't.

Answer 22

If the key you are checking is stored in a variable, you can check it like this:

x = {'key': 1};
y = 'key';
x[y];

Comments

How is this different conceptually then just testing x['key']? And how is that different than x.key? Other than when accessing an array of course..

— Gerard ONeill

Answer 23

Why over-complicate things when you can do:

var isProperty =  (objectname.keyname || "") ? true : false;

Simple and clear for most cases...

Comments

The most simplest one is var isProperty = !!objectname.keyname;

— John

यदि वस्तु इस प्रकार है तो const objectName = { keyname: false };यह सही लौटना चाहिए, क्योंकि keynameसंपत्ति है objectname। लेकिन चूंकि मूल्य गलत है, इसलिए यह इस तर्क के साथ गलत होगा।

— विल्ट