चेक करें कि क्या कोई मूल्य जावास्क्रिप्ट में एक वस्तु है

Question

यदि आप एक मान जावास्क्रिप्ट में एक वस्तु है, तो आप कैसे जांचेंगे?

Comments

एक चर एक चर है। यह किसी ऑब्जेक्ट को संदर्भित कर सकता है। इसके अलावा, आप "ऑब्जेक्ट" को परिभाषित करना चाह सकते हैं - जैसा कि उत्तर और टिप्पणियां दिखाती हैं, विभिन्न विरोधी परिभाषाएं हैं (जैसे कि nullएक वस्तु है)।

ओपी, आईएमओ आपको @ दान का उत्तर स्वीकार करना चाहिए क्योंकि यह सबसे अच्छा समाधान है और इसे अन्य उत्तरों से ऊपर सूचीबद्ध किया जाना चाहिए ताकि यह पहले दिखाई दे। (उन लोगों के लिए कोई अपराध नहीं है जिनके पास अच्छे उत्तर भी हैं।)

— टिफ़ॉन

IMHO यह वास्तव में इस बात पर निर्भर करता है कि आप (इस प्रश्न के उत्तर की तलाश में) किसी ऑब्जेक्ट पर विचार करते हैं, और आप इसे क्यों जाँच रहे हैं। यह सवाल अलग जवाब अगर आप सरणी (कि भेद करने के लिए कोशिश कर रहे हैं देता हैं वस्तुओं) से अन्य वस्तुओं या यदि आप "वैक्टर" से अदिश मानों को अलग करने की कोशिश कर रहे हैं। और भले ही अशक्त (कि है , एक वस्तु typeof के अनुसार) या कार्य (है कि कर रहे हैं वस्तुओं) या अलग करने की नहीं, यह वास्तव में तुम क्यों यह जाँच कर रहे हैं पर निर्भर करता है। इसलिए, बहुत सारे उत्तर हैं और उनमें से अधिकांश, संदर्भ में, सही हैं।

— फ्रांसेस्कोएम

const isEmpty = thing => {टाइपोफ़ चीज़ === "ऑब्जेक्ट"? बात || ऑब्जेक्ट .keys (बात) .length: बात! && बात! == 0}

— मयूर एस

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

— डॉन हैच

Answer 1

अद्यतन :

यह उत्तर अधूरा है और भ्रामक परिणाम देता है । उदाहरण के लिए, जावास्क्रिप्ट में nullभी प्रकार माना जाता है object, कई अन्य किनारे के मामलों का उल्लेख नहीं करना। नीचे दिए गए अनुशंसा का पालन करें और अन्य "सबसे ऊपर (और सही!) उत्तर" पर जाएं ।

---

मूल उत्तर :

का उपयोग करके देखें typeof(var)और / या var instanceof something।

EDIT: यह उत्तर वैरिएबल के गुणों की जांच करने के तरीके के बारे में बताता है, लेकिन यह बुलेटप्रूफ रेसिपी नहीं है (आखिर इसमें कोई रेसिपी बिल्कुल भी नहीं है!) यह जाँचने के लिए कि क्या यह एक वस्तु है, इससे दूर है। चूँकि लोग बिना किसी शोध के यहाँ से कुछ कॉपी करने के लिए देखते हैं, मैं अत्यधिक अनुशंसा करता हूँ कि वे दूसरे की ओर मुड़ें, सबसे अधिक (और सही!) उत्तर दें।

Comments

typeofएक ऑपरेटर है, इसलिए इसकी कोई आवश्यकता नहीं है ()।

— योशी

हां, कोई जरूरत नहीं। मैं इसे इस तरह से पसंद करता हूं।

— माइकल क्रेलिन - हैकर

@ माइकलक्रेलिन-हैकर: यह दुर्भाग्यपूर्ण है क्योंकि यह लोगों को भ्रमित करता है ।

— राइटसाइड्रेड्रेड

@RightSaidFred, मेरे पास इसके लिए कोई स्पष्टीकरण नहीं है, लेकिन मैं इन अभिव्यक्तियों में अतिरिक्त कोष्ठक जोड़ने के लिए बिल्कुल इच्छुक नहीं हूं :)

— माइकल क्रेलिन - हैकर

यह उत्तर गलत है। typeofअशक्त के लिए 'ऑब्जेक्ट' देता है, जो एक ऑब्जेक्ट नहीं है, और instanceofउपयोग की गई वस्तुओं के लिए काम नहीं करता है Object.create(null)।

— निकोलाई

Answer 2

यदि typeof yourVariable === 'object', यह एक वस्तु या अशक्त है। यदि आप अशक्त को बाहर करना चाहते हैं, तो बस इसे बनाएं typeof yourVariable === 'object' && yourVariable !== null।

Comments

फ़ंक्शंस भी ऑब्जेक्ट हैं और आपकी जांच में शामिल होना चाहिए।

— JS_Riddler

इस मामले में yourVariable !== nullबेहतर अभ्यास होगा?

— हिप्पिएट्रैल

@RightSaidFred लगता है कि ES6typeof null == 'object' में तय नहीं किया जाएगा । उन्होंने कहा:This proposal has been rejected. It was implemented in V8 but it turned out that it broke a lot of existing sites. In the spirit of One JavaScript this is not feasible.

— कोंस्टेंटिन स्मोलैनिन

@ साधारण उत्तर यह है कि सरणियों को वस्तु माना जाता है। अधिक विस्तृत उत्तर के लिए, आपको पढ़ना होगा typeofक्योंकि इसमें कुछ विशेष मामले हैं जो जरूरी नहीं कि पूरी तरह समझ में आए। यदि आप सरणियों और वस्तुओं के बीच अंतर करने की कोशिश कर रहे हैं जो सरणियाँ नहीं हैं, तो आप निश्चित रूप से उपयोग नहीं करना चाहते हैं typeof।

— मैट फेनविक

@Tresdin सबसे अच्छा तरीका है Object.prototype.toString.call(yourVar), रन करना , आपका विवर होना जो आपको निरीक्षण करने की आवश्यकता है। सरणियों के मामले में, Object.prototype.toString.call([1,2])रिटर्न[object Array]

— जोस रुई सैंटोस

Answer 3

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

आदिम, आदिम मूल्य

एक डेटा जो एक ऑब्जेक्ट नहीं है और इसमें कोई विधियाँ नहीं हैं। जावास्क्रिप्ट में 5 आदिम डेटाटाइप्स हैं: स्ट्रिंग, संख्या, बूलियन, अशक्त, अपरिभाषित।

क्या एक आदिम है?

• 3
• 'abc'
• true
• null
• undefined

एक वस्तु (यानी एक आदिम नहीं) क्या है?

• Object.prototype
• सब कुछ उतर गया Object.prototype
  • Function.prototype
    • Object
    • Function
    • function C(){} - उपयोगकर्ता द्वारा परिभाषित कार्य
  • C.prototype- उपयोगकर्ता द्वारा परिभाषित फ़ंक्शन का प्रोटोटाइप गुण: यह प्रोटोटाइप नहीं है C
    • new C() - "नया" -एक उपयोगकर्ता द्वारा परिभाषित फ़ंक्शन
  • Math
  • Array.prototype
    • सरणियों
  • {"a": 1, "b": 2} - शाब्दिक संकेतन का उपयोग करके बनाई गई वस्तुएं
  • new Number(3) - आदिम के आसपास रैपर
  • ... कई अन्य बातें ...
• Object.create(null)
• सब कुछ एक से उतरा Object.create(null)

कैसे जाँचें कि क्या कोई वस्तु है

instanceof अपने आप से काम नहीं करेगा, क्योंकि यह दो मामलों को याद करता है:

// oops:  isObject(Object.prototype) -> false
// oops:  isObject(Object.create(null)) -> false
function isObject(val) {
    return val instanceof Object; 
}

typeof x === 'object'झूठी सकारात्मक ( null) और झूठी नकारात्मक (कार्य) के कारण काम नहीं करेगा :

// oops: isObject(Object) -> false
function isObject(val) {
    return (typeof val === 'object');
}

Object.prototype.toString.call काम नहीं करेगा, क्योंकि सभी आदिम लोगों के लिए झूठी सकारात्मक:

> Object.prototype.toString.call(3)
"[object Number]"

> Object.prototype.toString.call(new Number(3))
"[object Number]"

इसलिए मैं उपयोग करता हूं:

function isObject(val) {
    if (val === null) { return false;}
    return ( (typeof val === 'function') || (typeof val === 'object') );
}

---

@ दान का जवाब भी काम करने लगता है:

function isObject(obj) {
  return obj === Object(obj);
}

क्योंकि, MDN डॉक्स के अनुसार :

ऑब्जेक्ट कंस्ट्रक्टर दिए गए मान के लिए ऑब्जेक्ट रैपर बनाता है। यदि मान शून्य या अपरिभाषित है, तो यह एक खाली ऑब्जेक्ट बनाएगा और लौटाएगा, अन्यथा, यह उस प्रकार का ऑब्जेक्ट लौटाएगा जो दिए गए मान से मेल खाता है। यदि मूल्य पहले से ही एक वस्तु है, तो यह मूल्य वापस कर देगा।

---

एक तीसरा तरीका जो काम करने लगता है (यह सुनिश्चित नहीं है कि अगर यह 100% है) का उपयोग करना है Object.getPrototypeOfजो एक अपवाद को फेंकता है यदि इसका तर्क एक वस्तु नहीं है:

// these 5 examples throw exceptions
Object.getPrototypeOf(null)
Object.getPrototypeOf(undefined)
Object.getPrototypeOf(3)
Object.getPrototypeOf('abc')
Object.getPrototypeOf(true)

// these 5 examples don't throw exceptions
Object.getPrototypeOf(Object)
Object.getPrototypeOf(Object.prototype)
Object.getPrototypeOf(Object.create(null))
Object.getPrototypeOf([])
Object.getPrototypeOf({})

Comments

obj === Object(obj)trueसरणियों के लिए रिटर्न ।

— ओनुर येल्ड्रिअम

var x = []; console.log(x === Object(x)); // return true

— इलुमिनेटर

जैसा कि मैंने अपने उत्तर में उल्लेख किया है @ आईल्यूमिनेटर सरणियाँ जावास्क्रिप्ट में ऑब्जेक्ट हैं ।

— मैट फेनविक

getPrototypeOfनिरस्त प्रॉक्सी के साथ जैसे काम नहीं करता है, जो ऑब्जेक्ट हैं लेकिन फेंकते हैं।

— ओरियल

क्यों नहीं ({}).toString.apply(obj) === '[object Object]'कि सरणियों नहीं हैं सरणियों और वस्तुओं के बीच इस अलग है

— MauricioJuanes

Answer 4

underscore.js निम्नलिखित विधि प्रदान करता है ताकि यह पता लगाया जा सके कि क्या वास्तव में कोई वस्तु है:

_.isObject = function(obj) {
  return obj === Object(obj);
};

अपडेट करें

V8 में पिछले बग और लघु माइक्रो स्पीड ऑप्टिमाइज़ेशन के कारण, विधि अंडरस्कोर के बाद से इस प्रकार दिखती है ।js 1.7.0 (अगस्त 2014):

_.isObject = function(obj) {
  var type = typeof obj;
  return type === 'function' || type === 'object' && !!obj;
};

Comments

जावास्क्रिप्ट में एक सरणी भी एक वस्तु है, इसलिए अधिकांश समय आप सरणी को बाहर करना चाहते हैं:return obj === Object(obj) && Object.prototype.toString.call(obj) !== '[object Array]'

— दान

आप किसी सरणी को क्यों छोड़ेंगे? वे पूर्ण विकसित वस्तुएं हैं।

— निकोलाई

क्योंकि अधिकांश समय आप एक {} से एक [] उदाहरण के लिए किसी फ़ंक्शन में इनपुट के रूप में अंतर करना चाहते हैं

— Daan

@ निकोलई .. और नेस्टेड वस्तुओं के माध्यम से पुनरावृति के लिए।

— रिकी बॉयस

बहुत बढ़िया जवाब। संभालती है null, भी। स्वीकृत उत्तर होना चाहिए।

— टिफ़न

Answer 5

Object.prototype.toString.call(myVar) वापस होगा:

• "[object Object]" अगर myVar एक ऑब्जेक्ट है
• "[object Array]" अगर myVar एक सरणी है
• आदि।

इस बारे में अधिक जानकारी के लिए और यह टाइपोफ के लिए एक अच्छा विकल्प क्यों है, इस लेख को देखें ।

Comments

मैं हाल ही में सीखा है कि typeof [] === 'object'-> true। आपको इस विधि की आवश्यकता है।

— जोंड्मल

@Christophe आदिम और वस्तुओं के बीच अंतर नहीं करता है । Object.prototype.toString.call(3)-> "[object Number]"। Object.prototype.toString.call(new Number(3))-> "[object Number]"

— मैट फेनविक

@MattFenwick मुझे नहीं लगता कि यह ओपी की पहचान करने के लिए "ऑब्जेक्ट" की तरह है

— क्रिस्टोफ

@Christophe आपको ऐसा क्यों लगता है? IMHO, "ऑब्जेक्ट" के लिए ओपी द्वारा दी गई किसी भी अन्य परिभाषा के अभाव में, यह सबसे अधिक उचित लगता है कि जो पूरे ईसीएस कल्पना में लगातार उपयोग किया जाता है।

— मैट फेनविक

getType=function(obj){return Object.prototype.toString.call(obj).match(/\[object (\w+)\]/)[1];};

— श्री पॉलीविरल

Answer 6

बस अतिरिक्त फ़ंक्शन कॉल (गति) के बिना ऑब्जेक्ट या एरे के खिलाफ जाँच के लिए। जैसा कि यहां भी पोस्ट किया गया है ।

isArray ()

isArray = function(a) {
    return (!!a) && (a.constructor === Array);
};
console.log(isArray(        )); // false
console.log(isArray(    null)); // false
console.log(isArray(    true)); // false
console.log(isArray(       1)); // false
console.log(isArray(   'str')); // false
console.log(isArray(      {})); // false
console.log(isArray(new Date)); // false
console.log(isArray(      [])); // true

isObject () - नोट: केवल ऑब्जेक्ट शाब्दिक के लिए उपयोग करें, क्योंकि यह कस्टम ऑब्जेक्ट्स के लिए गलत है, जैसे नई तिथि या नया YourCustomObject।

isObject = function(a) {
    return (!!a) && (a.constructor === Object);
};
console.log(isObject(        )); // false
console.log(isObject(    null)); // false
console.log(isObject(    true)); // false
console.log(isObject(       1)); // false
console.log(isObject(   'str')); // false
console.log(isObject(      [])); // false
console.log(isObject(new Date)); // false
console.log(isObject(      {})); // true

Comments

isObjectकेवल वस्तु शाब्दिक के साथ काम करता है। यदि मैं एक कस्टम प्रकार बनाता हूं, तो टाइप का एक उदाहरण बनाएं और इसे false

— परखें

@zupa: क्या करता है?

@ 3000 अच्छी तरह से, अगर हम (!) को छोड़ देते हैं तो यह दुर्घटनाग्रस्त हो जाता है, क्योंकि अशक्त और अपरिभाषित का कोई निर्माण नहीं होता है। (!!) उन्हें फ़िल्टर करता है। क्या वह आपके सवाल का जवाब है?

— झूप्पा

@zupa @ 3000 Boolean(a)लंबा है, लेकिन कहीं अधिक सहज है। बस का उपयोग न करें new Boolean(a): ( यहाँ क्यों है )!

— JayVee

सबसे अच्छा जवाब आश्चर्यचकित है अब तक पृष्ठ नीचे है। यह मूल रूप से सवाल का जवाब देता है- क्या यह JSON में किसी {चरित्र के साथ शुरू होने वाले कुछ के रूप में दर्शाया जाएगा । सरणी मामले के लिए, जब तक आपको IE <9 का समर्थन करने की आवश्यकता नहीं है, आप यह Array.isArray()निर्धारित करने के लिए उपयोग कर सकते हैं कि क्या कोई सरणी है। यह आपके द्वारा प्रदान किए गए सभी परीक्षण मामलों को पास करता है।

— किप

Answer 7

मैं बस शौकीन हूं:

function isObject (item) {
  return (typeof item === "object" && !Array.isArray(item) && item !== null);
}

यदि आइटम एक JS ऑब्जेक्ट है, और यह JS सरणी नहीं है, और यह नहीं है null... यदि तीनों सही साबित होते हैं, तो वापस लौटें true। यदि तीन में से कोई भी स्थिति विफल हो जाती है, तो &&परीक्षण शॉर्ट-सर्किट falseहोगा और वापस आ जाएगा। nullयदि (आप कैसे उपयोग के आधार पर वांछित परीक्षण छोड़ा जा सकता है null)।

डॉक्स:

http://devdocs.io/javascript/operators/typeof

http://devdocs.io/javascript/global_objects/object

http://devdocs.io/javascript/global_objects/array/isarray

http://devdocs.io/javascript/global_objects/null

Comments

कंसोल.लॉग (isObject (नई तिथि ())) के बारे में क्या? तारीख एक वस्तु क्यों होनी चाहिए लेकिन एक सरणी नहीं?

— शिरोमणि

@macher क्योंकि new Date()कोई ऑब्जेक्ट देता है। एक सरणी तार्किक दृष्टिकोण से है न कि कोई वस्तु - हालांकि जावास्क्रिप्ट संभालती है और उन्हें इस तरह से रिपोर्ट करती है। हालांकि व्यवहार में, उन्हें समान रूप से देखना उपयोगी नहीं है, क्योंकि वे नहीं हैं। किसी ऑब्जेक्ट में lengthउदाहरण के लिए कोई विशेषता नहीं होती है और इसमें पुश () जैसी कोई विधि नहीं होती है। और कभी-कभी आप एक फंक्शन ओवरलोडेड परमेस देना चाह सकते हैं, जहां आपको किसी ऐरे या ऑब्जेक्ट के बीच फर्क करने की जरूरत होती है, खासतौर पर अगर अन्य पैरामीटर निर्भर करते हैं, जिस पर एक दिया गया था।

— स्टेनी

@StanE Arrays निश्चित रूप से ऑब्जेक्ट हैं। यह निश्चित नहीं है कि आपको क्यों लगता है कि वस्तुओं में lengthसंपत्ति नहीं हो सकती है और न ही तरीके push, जैसे Object.create(Array.prototype)कि एक गैर-सरणी ऑब्जेक्ट का एक तुच्छ प्रतिसाद है जो इन है। क्या विशेष बनाता है कि वे एक कस्टम [[DefineOwnProperty]] आवश्यक आंतरिक विधि के साथ विदेशी वस्तुएं हैं, लेकिन वे अभी भी वस्तुएं हैं।

— ओरिऑल

@ ओरील ने न तो लिखा है कि एरे ऑब्जेक्ट्स नहीं हैं और न ही मैंने लिखा है कि ऑब्जेक्ट्स में कोई lengthसंपत्ति नहीं हो सकती है (मेरा मतलब था कि ऑब्जेक्ट शाब्दिकों में lengthडिफ़ॉल्ट रूप से कोई विशेषता नहीं है )। मैंने लिखा है कि तार्किक दृष्टिकोण से सरणियाँ ऑब्जेक्ट नहीं हैं । मैं प्रोग्राम लॉजिक के बारे में बोल रहा हूं। कभी-कभी यह जांचना आवश्यक है कि क्या कोई सरणी "वास्तविक" सरणी है और निश्चित रूप से "वास्तविक" ऑब्जेक्ट नहीं है। इसके Array.isArray()लिए जो है। कल्पना कीजिए कि आपके पास एक फ़ंक्शन है जो ऑब्जेक्ट या ऑब्जेक्ट की एक सरणी को स्वीकार करता है। एक विशेष विशेषता या विधि के लिए जाँच एक गंदा समाधान है। देशी तरीका हमेशा बेहतर होता है।

— 21

typeof nullहै "object", नहीं "undefined"।

— 2540625

Answer 8

समारोह के साथ Array.isArray:

function isObject(o) {
  return o !== null && typeof o === 'object' && Array.isArray(o) === false;
}

बिना कार्य Array.isArray:

बस आश्चर्य है कि गलत उत्तरों के लिए कितने उत्थान हैं answer
केवल 1 उत्तर ने मेरी परीक्षा उत्तीर्ण की !!! यहाँ मैंने अपना सरलीकृत संस्करण बनाया है:

function isObject(o) {
  return o instanceof Object && o.constructor === Object;
}

मेरे लिए, यह स्पष्ट और सरल है, और बस काम करता है! यहाँ मेरे परीक्षण:

console.log(isObject({}));             // Will return: true
console.log(isObject([]));             // Will return: false
console.log(isObject(null));           // Will return: false
console.log(isObject(/.*/));           // Will return: false
console.log(isObject(function () {})); // Will return: false

एक और समय: नहीं सभी जवाब इस परीक्षण पास !!! 🙈

---

मामले में आपको यह सत्यापित करने की आवश्यकता है कि वस्तु विशेष वर्ग का उदाहरण है जिसे आपको अपने विशेष वर्ग के साथ कंस्ट्रक्टर की जांच करनी है, जैसे:

function isDate(o) {
  return o instanceof Object && o.constructor === Date;
}

सरल परीक्षण:

var d = new Date();
console.log(isObject(d)); // Will return: false
console.log(isDate(d));   // Will return: true

परिणामस्वरूप, आपके पास सख्त और मजबूत कोड होगा!

---

मामले में आप की तरह काम करता है नहीं बनाएगा isDate, isError, isRegExp, आदि आप इस सामान्यीकृत कार्यों का उपयोग करने के लिए विकल्प पर विचार हो सकता है:

function isObject(o) {
  return o instanceof Object && typeof o.constructor === 'function';
}

पहले उल्लेखित सभी परीक्षण मामलों के लिए यह सही ढंग से काम नहीं करेगा, लेकिन यह सभी वस्तुओं (सादे या निर्मित) के लिए पर्याप्त है।

---

isObjectObject.create(null)आंतरिक कार्यान्वयन के कारण काम नहीं करेगा , Object.createजिसे यहां समझाया गया है, लेकिन आप isObjectअधिक परिष्कृत कार्यान्वयन में उपयोग कर सकते हैं :

function isObject(o, strict = true) {
  if (o === null || o === undefined) {
    return false;
  }
  const instanceOfObject = o instanceof Object;
  const typeOfObject = typeof o === 'object';
  const constructorUndefined = o.constructor === undefined;
  const constructorObject = o.constructor === Object;
  const typeOfConstructorObject = typeof o.constructor === 'function';
  let r;
  if (strict === true) {
    r = (instanceOfObject || typeOfObject) && (constructorUndefined || constructorObject);
  } else {
    r = (constructorUndefined || typeOfConstructorObject);
  }
  return r;
};

इस कार्यान्वयन के आधार पर npm v1 पर पहले से ही पैकेज बनाया गया है ! और यह सभी पहले वर्णित परीक्षण मामलों के लिए काम करता है! 🙂

Comments

सबसे बढ़िया उत्तर! यहां

— पुजारी

क्योंकि यह isObject (myDateObject) के लिए गलत है, यह प्रश्न का उत्तर नहीं है। यह नहीं बताता है कि एक चर एक वस्तु है, केवल अगर यह एक विशिष्ट वर्ग की वस्तु है। यहाँ प्रश्न एक सामान्य कार्य के लिए है जो किसी भी वस्तु के लिए सही है।

— यतिअंतरजोश १३'१

@Yetanotherjosh यह एक ऐसा उत्तर है जिसका आपने वास्तव में उल्लेख किया है, जो उत्तर में वर्णित है, और बिंदु - आपको isDateमजबूत कोड लिखने के उद्देश्य से अपनेDateObject के लिए उपयोग करना होगा अन्यथा आपके पास भंगुर isObjectविधि होगी ।

— वी। कोवपैक

@VladimirKovpak Dateमेरी टिप्पणी का उपयोग करने के कारण बीमार चुना गया था, हां, इसका जवाब चर्चा करता है Date। लेकिन Dateसिर्फ अनंत संभव वर्गों में से एक है और बिंदु किसी अन्य वर्ग के लिए है। उदाहरण: class Foo() { }; var x = new Foo(); isObject(x)रिटर्न false। मुझे ठीक से पता नहीं है कि ओपी का उपयोग मामला क्या है, लेकिन ऐसे परिदृश्यों की कल्पना करना आसान है जिनमें सभी संभावित वर्गों के बारे में जानना और विशेष रूप से उनमें से हर एक के खिलाफ जांच करना संभव नहीं है।

— यतनथोरजोश

@Yetanotherjosh मैंने अपना उत्तर अपडेट कर दिया है। और 1 और मामला जोड़ा।

— वी। कोवपैक

Answer 9

हे भगवान! मुझे लगता है कि यह पहले से कहीं ज्यादा छोटा हो सकता है, इसे देखते हैं:

लघु और अंतिम कोड

function isObject(obj)
{
    return obj != null && obj.constructor.name === "Object"
}

console.log(isObject({})) // returns true
console.log(isObject([])) // returns false
console.log(isObject(null)) // returns false

व्याख्या की

वापसी के प्रकार

टाइपऑफ जावास्क्रिप्ट ऑब्जेक्ट (सहित null) रिटर्न"object"

console.log(typeof null, typeof [], typeof {})

उनके निर्माणकर्ताओं पर जाँच

constructorउनके नाम के साथ उनकी संपत्ति रिटर्न फ़ंक्शन पर जाँच ।

console.log(({}).constructor) // returns a function with name "Object"
console.log(([]).constructor) // returns a function with name "Array"
console.log((null).constructor) //throws an error because null does not actually have a property

पेश है फंक्शन.नाम

Function.nameकिसी फ़ंक्शन या "anonymous"क्लोजर के लिए आसानी से नाम लौटाता है ।

console.log(({}).constructor.name) // returns "Object"
console.log(([]).constructor.name) // returns "Array"
console.log((null).constructor.name) //throws an error because null does not actually have a property

नोट: २०१8 तक, फंक्शन.नाम IE में काम नहीं कर सकता है। https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Function/name#Bebser_compatibility

Comments

मैं वास्तव में इस एक, छोटी और बात को पसंद करता हूं। यह केवल 1 चीज़ पर विफल होता है जहाँ तक मैं देख सकता हूँ। अगर obj = Object.create(null)और काफी है तो आप ऐसा क्यों करेंगे ...?

— जूलियन नाइट

Answer 10

ठीक है, आइए आपको अपने प्रश्न का उत्तर देने से पहले सबसे पहले यह अवधारणा दें, जावास्क्रिप्ट फ़ंक्शंस में ऑब्जेक्ट हैं, अशक्त, ऑब्जेक्ट, एरे और यहां तक ​​कि तिथि भी, इसलिए जैसा कि आप देखते हैं कि टाइपोफ़ ओब्ज === 'ऑब्जेक्ट' जैसा सरल तरीका नहीं है, इसलिए ऊपर उल्लिखित सब कुछ सच हो जाएगा , लेकिन फ़ंक्शन लिखने या जावास्क्रिप्ट फ्रेमवर्क का उपयोग करने के साथ इसे जांचने के तरीके हैं, ठीक है:

अब, कल्पना कीजिए कि आपके पास यह वस्तु है जो एक वास्तविक वस्तु है (शून्य या फ़ंक्शन या सरणी नहीं):

var obj = {obj1: 'obj1', obj2: 'obj2'};

शुद्ध जावास्क्रिप्ट:

//that's how it gets checked in angular framework
function isObject(obj) {
  return obj !== null && typeof obj === 'object';
}

या

//make sure the second object is capitalised 
function isObject(obj) {
   return Object.prototype.toString.call(obj) === '[object Object]';
}

या

function isObject(obj) {
    return obj.constructor.toString().indexOf("Object") > -1;
}

या

function isObject(obj) {
    return obj instanceof Object;
}

आप अपने कोड में उपरोक्त कार्यों में से किसी एक का उपयोग करके उन्हें कॉल कर सकते हैं और यदि यह एक वस्तु है तो यह सच हो जाएगा:

isObject(obj);

यदि आप एक जावास्क्रिप्ट फ्रेमवर्क का उपयोग कर रहे हैं, तो उन्होंने आमतौर पर आपके लिए इस तरह के कार्य तैयार किए हैं, ये उनमें से कुछ हैं:

jQuery:

 //It returns 'object' if real Object;
 jQuery.type(obj);

कोणीय:

angular.isObject(obj);

अंडरस्कोर और लॉडश:

//(NOTE: in Underscore and Lodash, functions, arrays return true as well but not null)
_.isObject(obj);

Comments

आप यह भी जांचना चाहते हैं कि यह कोई सरणी तो नहीं है। so function isObject (obj) {return obj! == null && typeof obj === '' '&&! Array.isArray (obj); }

— मैट गू

मैं आपसे सहमत हूं, लेकिन जैसा कि आप टिप्पणी में देखते हैं, यह एंगुलरज में कैसे किया जाता है और मैं फ़ंक्शन के सामने टिप्पणी में इसका उल्लेख करता हूं, वे एरे को एक वस्तु के रूप में गिनते हैं ... अधिक जानकारी के लिए यहां देखें: डॉक्स .angularjs.org / API / एनजी / समारोह / angular.isObject

— एलिरेज़ा

Answer 11

यह इस बात पर निर्भर करता है कि आप "एक वस्तु है" से क्या मतलब है। यदि आप वह सब कुछ चाहते हैं, जो एक आदिम नहीं है , यानी ऐसी चीजें, जिन पर आप नए गुण स्थापित कर सकते हैं, तो यह करना चाहिए:

function isAnyObject(value) {
    return value != null && (typeof value === 'object' || typeof value === 'function');
}

यह पुरातन शामिल नहीं (सादा संख्या / NaN/ Infinity, सादे तार, प्रतीक, true/ false, undefinedऔर null), लेकिन बाकी सब (सहित के लिए सच लौटना चाहिए Number, Booleanऔर Stringवस्तुओं)। ध्यान दें कि जेएस परिभाषित नहीं करता है कि "होस्ट" ऑब्जेक्ट्स, जैसे कि windowया console, जब उपयोग किया जाता है typeof, तो वापस आ जाना चाहिए , इसलिए उन पर एक चेक के साथ कवर करना मुश्किल है।

यदि आप यह जानना चाहते हैं कि क्या कोई वस्तु "सादा" वस्तु है, अर्थात इसे शाब्दिक {}या इसके साथ बनाया गया था Object.create(null), तो आप ऐसा कर सकते हैं:

function isPlainObject(value) {
    if (Object.prototype.toString.call(value) !== '[object Object]') {
        return false;
    } else {
        var prototype = Object.getPrototypeOf(value);
        return prototype === null || prototype === Object.prototype;
    }
}

संपादित करें 2018 : क्योंकि Symbol.toStringTagअब आउटपुट को कस्टमाइज़ करने की अनुमति देता है Object.prototype.toString.call(...), इसलिए isPlainObjectउपरोक्त फ़ंक्शन falseकुछ मामलों में वापस आ सकता है , जब ऑब्जेक्ट अपने जीवन को एक शाब्दिक के रूप में शुरू करता है। तर्क से, एक कस्टम स्ट्रिंग टैग के साथ एक वस्तु सम्मेलन द्वारा बिल्कुल किसी भी अधिक सादे वस्तु नहीं है, लेकिन यह आगे की परिभाषा को स्पष्ट कर दिया है कि जावास्क्रिप्ट में भी एक सादे वस्तु क्या है।

Comments

Typeof === 'फंक्शन' को ऑब्जेक्ट क्यों माना जाता है? एक समारोह एक वस्तु नहीं है, है ना? "new myFunc ()" एक ऑब्जेक्ट बन जाएगा, हां, लेकिन एक सादे कार्य?

— 21

नहीं, प्रत्येक फ़ंक्शन जावास्क्रिप्ट में एक ऑब्जेक्ट है, भले ही यह कैसे बनाया गया हो। आप उन पर गुण सेट कर सकते हैं (जब तक कि वे जमे हुए नहीं हैं), वे हैं instanceof Object, दो समान फ़ंक्शन शाब्दिक समान रूप से समान नहीं हैं, वे संदर्भ द्वारा पारित किए जाते हैं, आदि

— अंतिम-बच्चा

Answer 12

मेरे भगवान, अन्य उत्तरों में बहुत अधिक भ्रम।

संक्षिप्त जवाब

typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array)

इसे जांचने के लिए बस निम्नलिखित कथनों को क्रोम कंसोल में चलाएं।

मामला एक।

var anyVar = {};
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // true

केस 2।

anyVar = [];
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array) // false

केस 3।

anyVar = null;
typeof anyVar == 'object' && anyVar instanceof Object && !(anyVar instanceof Array); // false

व्याख्या

ठीक है। इसे तोड़ दो

typeof anyVar == 'object'तीन उम्मीदवारों से सच दिया जाता है - [], {} and null,

anyVar instanceof Object नीचे इन उम्मीदवारों को दो - [], {}

!(anyVar instanceof Array) केवल एक के लिए - {}

ड्रम रोल कृपया!

इसके द्वारा आप पहले से ही जान सकते हैं कि जावास्क्रिप्ट में एरे की जांच कैसे करें।

Comments

ध्यान दें, यह भी एक फ़ंक्शन के falseरूप में (वांछित के रूप में) देता anyVarहै।

— जेमी बर्च

Answer 13

मूल्य के प्रकार की जांच करने का सबसे उचित तरीका typeofऑपरेटर लगता है । केवल समस्या यह है कि यह बुरी तरह से टूट गया है:

• यह रिटर्न के "object"लिए है null, जो नल प्रकार का है।
• यह "function"कॉल करने योग्य वस्तुओं के लिए लौटता है , जो ऑब्जेक्ट प्रकार से संबंधित हैं।
• यह गैर-मानक गैर-कॉल करने योग्य वस्तुओं के लिए कुछ भी (लगभग) वापस कर सकता है। उदाहरण के लिए, IE की तरह लग रहा था "unknown"। केवल निषिद्ध परिणाम हैं "function"और आदिम प्रकार हैं।

typeofकेवल गैर- nullआदिम लोगों के लिए विश्वसनीय है । तो यह जांचने का एक तरीका है कि क्या कोई मूल्य एक वस्तु है यह सुनिश्चित करना है कि स्ट्रिंग द्वारा लौटाया गया typeofएक आदिम के अनुरूप नहीं है, और यह कि वस्तु नहीं है null। हालाँकि, समस्या यह है कि भविष्य का मानक एक नए आदिम प्रकार का परिचय दे सकता है, और हमारा कोड इसे एक वस्तु मानता है। नए प्रकार अक्सर दिखाई नहीं देते हैं, लेकिन उदाहरण के लिए ECMAScript 6 ने प्रतीक प्रकार पेश किया।

इसलिए, इसके बजाय typeof, मैं केवल उन दृष्टिकोणों की सलाह देता हूं जिनके परिणाम इस आधार पर भिन्न होते हैं कि मूल्य एक वस्तु है या नहीं। निम्नलिखित एक होने का इरादा रखता है

यदि कोई मान ऑब्जेक्ट प्रकार का है, तो परीक्षण करने के लिए उचित तरीकों की व्यापक लेकिन विस्तृत सूची नहीं।

• Object निर्माता

  Objectनिर्माता एक ऑब्जेक्ट के लिए पारित तर्क coerces। यदि यह पहले से ही एक वस्तु है, तो उसी वस्तु को लौटाया जाता है।

  इसलिए, आप इसका उपयोग किसी वस्तु के मूल्य को कम करने के लिए कर सकते हैं, और उस वस्तु की मूल मूल्य के साथ कड़ाई से तुलना कर सकते हैं।

  निम्नलिखित फ़ंक्शन के लिए ECMAScript 3 की आवश्यकता है, जो प्रस्तुत किया गया है ===:

  function isObject(value) { /* Requires ECMAScript 3 or later */
    return Object(value) === value;
  }

  मुझे यह दृष्टिकोण पसंद है क्योंकि यह सरल और आत्म-वर्णनात्मक है, और एक सादृश्य चेक बूलियन, संख्या और तारों के लिए भी काम करेगा। हालाँकि, सचेत रहें यह Objectन तो वैश्विक रूप से छाया हुआ है और न ही बदल रहा है।

• कंस्ट्रक्टर्स

  जब आप एक कंस्ट्रक्टर को इंस्टेंट करते हैं, तो यह केवल-निर्मित उदाहरण से भिन्न मान वापस कर सकता है। लेकिन उस मूल्य को नजरअंदाज कर दिया जाएगा जब तक कि यह एक वस्तु न हो।

  निम्नलिखित फ़ंक्शन के लिए ECMAScript 3 की आवश्यकता होती है, जिसने निर्माणकर्ताओं को गैर-ऑब्जेक्ट वापस करने की अनुमति दी थी। ECMAScript 3 से पहले जो एक त्रुटि थी, लेकिन tryबयान तब मौजूद नहीं थे।

  function isObject(value) { /* Requires ECMAScript 3 or later */
    return new function() { return value; }() === value;
  }

  जबकि पिछले उदाहरण की तुलना में थोड़ा सरल है, यह किसी भी वैश्विक संपत्ति पर भरोसा नहीं करता है, और इस प्रकार सबसे सुरक्षित हो सकता है।

• this मूल्य

  पुराने ECMAScript विनिर्देशों thisको एक वस्तु होने के लिए मूल्य की आवश्यकता होती है । ECMAScript 3 पेश किया गया Function.prototype.call, जिसने एक मनमाने thisमूल्य के साथ एक फ़ंक्शन को कॉल करने की अनुमति दी , लेकिन एक वस्तु के लिए मजबूर किया।

  ECMAScript 5 ने एक सख्त मोड की शुरुआत की, जिसने इस व्यवहार को हटा दिया, लेकिन मैला मोड में हम अभी भी (लेकिन यकीनन नहीं करना चाहिए) इस पर भरोसा करते हैं।

  function isObject(value) { /* Requires ECMAScript 3 or later in sloppy mode */
    return function() { return this === value; }.call(value);
  }

• [[प्रोटोटाइप]]

  सभी साधारण वस्तुओं में एक आंतरिक स्लॉट होता है जिसे [[प्रोटोटाइप]] कहा जाता है, जिसका मूल्य यह निर्धारित करता है कि यह किस अन्य वस्तु से प्राप्त होता है। मान केवल एक वस्तु या हो सकता है null। इसलिए, आप एक ऑब्जेक्ट बनाने का प्रयास कर सकते हैं जो वांछित मूल्य से विरासत में मिला है, और जांचें कि क्या यह काम किया है।

  दोनों Object.createऔर Object.getPrototypeOfECMAScript 5 की आवश्यकता है।

  function isObject(value) { /* Requires ECMAScript 5 or later */
    try {
      Object.create(value);
      return value !== null;
    } catch(err) {
      return false;
    }
  }

  function isObject(value) { /* Requires ECMAScript 5 or later */
    function Constructor() {}
    Constructor.prototype = value;
    return Object.getPrototypeOf(new Constructor()) === value;
  }

• कुछ नए ECMAScript 6 तरीके

  ECMAScript 6 कुछ नए अप्रत्यक्ष तरीकों को जाँचने के लिए पेश करता है एक मूल्य एक वस्तु है। वे मूल्य को पास करने के लिए पहले देखे गए दृष्टिकोण का उपयोग करते हैं कुछ कोड के लिए जो एक वस्तु की आवश्यकता होती है, एक के अंदर लिपटेtry त्रुटियों को पकड़ने के लिए बयान के । कुछ छिपे हुए उदाहरण, टिप्पणी करने के लायक नहीं

  function isObject(value) { /* Requires ECMAScript 6 or later */
    try {
      Object.setPrototypeOf({}, value);
      return value !== null;
    } catch(err) {
      return false;
    }
  }

  function isObject(value) { /* Requires ECMAScript 6 or later */
    try {
      new WeakSet([value]);
      return true;
    } catch(err) {
      return false;
    }
  }

---

नोट: मैंने जानबूझकर Object.getPrototypeOf(value)(ईएस 5) और Reflectतरीकों (ईएस 6) जैसे कुछ दृष्टिकोणों को छोड़ दिया है क्योंकि वे आवश्यक आंतरिक तरीकों को कहते हैं जो कि बुरा काम कर सकते हैं, जैसे कि valueएक प्रॉक्सी। सुरक्षा कारणों से मेरे उदाहरण केवल valueइसे एक्सेस किए बिना ही संदर्भ देते हैं।

Comments

"केवल मेरा उत्तर और दान पूरी तरह से सही हैं।" थोड़ा अनुमान लगाया जाता है कि मैं आपके पहले दो वाक्यों से पूरी तरह असहमत हूं ।

— zzzzBov

@zzzzBov खैर, मैंने सभी उत्तरों पर ध्यान दिया और वे हमेशा मेरा और डैन को छोड़कर, उचित उत्तर देना सुनिश्चित नहीं करते हैं। मैं उनमें से अधिकांश को प्रतिलिपि प्रस्तुत करने योग्य प्रतिकृतियां दे सकता हूं। यदि टाइपोफ़ "फ़ंक्शन" या "ऑब्जेक्ट" देता है, तो अन्य लोग यह जांचने की सलाह देते हैं, लेकिन जैसा कि मैंने समझाया था, कल्पना कुछ वस्तुओं के लिए अन्य परिणामों की अनुमति देती है। मैट फेनविक के उत्तर में डैन के समान ही सही उत्तर है, लेकिन इसमें गलत भी हैं।

— ओरोल

मैं इस आधार से असहमत था कि आपका उत्तर "पूरी तरह से सही" है, यह तर्क देते हुए कि अन्य लोग "हमेशा उचित उत्तर नहीं देना सुनिश्चित करते हैं" किसी भी तरह से मेरी स्थिति का खंडन नहीं करता है। इसके अतिरिक्त, इस सवाल का कोई दावा नहीं है कि इनपुट किस आउटपुट का उत्पादन करना चाहिए।

— zzzzBov

@zzzzBov सवाल पूछता है कि कैसे जांचा जाए कि कोई वस्तु है। ECMAScript परिभाषित करता है कि कोई वस्तु क्या है, इसलिए मैं उस परिभाषा का उपयोग करता हूं। मैं कोई अन्य उचित व्याख्या नहीं देख सकता। ऐसे उत्तर जो अन्य चीजों को करते हैं (जैसे सरणियों को छोड़कर) कुछ परिस्थितियों में उपयोगी हो सकते हैं, लेकिन वे जांच नहीं करते हैं कि क्या कोई वस्तु है।

— ओरियल

@ ऑरिओल शायद आप इस प्रश्न का उत्तर दे सकते हैं कि कोई ऑब्जेक्ट एक सादी वस्तु है या नहीं, यह जांचने के लिए जावास्क्रिप्ट में अंतर्निहित पद्धति क्यों नहीं है? ?

— 2:27 पर अतिथि271314

Answer 14

इसे इस्तेमाल करे

if (objectName instanceof Object == false) {
  alert('Not an object');
}
else {
  alert('An object');
}

Comments

आप बुलबुल की जाँच क्यों करते हैं?

— jkutianski

यह दो मामलों को याद करता है: Object.prototype instanceof Object-> असत्य। Object.create(null) instanceof Object-> झूठा।

— मैट फेनविक

तारीखों के बारे में क्या? new Date() instanceof Object => सच

— mauron85

Answer 15

जाँच के लिए कार्यों का उपयोग करने के लिए तैयार

function isObject(o) {
  return null != o && 
    typeof o === 'object' && 
    Object.prototype.toString.call(o) === '[object Object]';
}

function isDerivedObject(o) {
  return !isObject(o) && 
    null != o && 
    (typeof o === 'object' || typeof o === 'function') &&
    /^\[object /.test(Object.prototype.toString.call(o));
}

// Loose equality operator (==) is intentionally used to check
// for undefined too

// Also note that, even null is an object, within isDerivedObject
// function we skip that and always return false for null

---

व्याख्या

• जावास्क्रिप्ट में, null, Object, Array, Dateऔर functionसब वस्तुएं हैं। हालांकि, nullथोड़ा वंचित है। तो, nullपहले के लिए जांच करना बेहतर है, यह पता लगाने के लिए कि यह अशक्त नहीं है।

• किसी वस्तु के लिए typeof o === 'object'गारंटी की जाँच करना o। इस जाँच के बिना, Object.prototype.toStringव्यर्थ होगा, क्योंकि यह हमेशा के लिए वस्तु लौटाएगा, यहाँ तक कि undefinedऔर null! उदाहरण के लिए: toString(undefined)रिटर्न[object Undefined] !

  typeof o === 'object'जाँच के बाद , toString.call (o) यह जाँचने का एक शानदार तरीका है कि क्या oकोई वस्तु है, एक व्युत्पन्न वस्तु जैसे Array, Dateया a function।

• में isDerivedObjectसमारोह है, यह जाँच करता है के लिए oएक समारोह है। क्योंकि, फ़ंक्शन भी एक ऑब्जेक्ट है, इसीलिए यह वहां है। यदि उसने ऐसा नहीं किया, तो फ़ंक्शन गलत के रूप में वापस आ जाएगा। उदाहरण: isDerivedObject(function() {})वापसी होगी false, हालांकि अब यह वापस आ जाएगी true।

• एक वस्तु की परिभाषा को हमेशा बदल सकता है। तो, एक इन कार्यों को तदनुसार बदल सकता है।

---

टेस्ट

function isObject(o) {
  return null != o && 
    typeof o === 'object' && 
    Object.prototype.toString.call(o) === '[object Object]';
}

function isDerivedObject(o) {
  return !isObject(o) && 
    null != o && 
    (typeof o === 'object' || typeof o === 'function') &&
    /^\[object /.test(Object.prototype.toString.call(o));
}

// TESTS

// is null an object?

console.log(
  'is null an object?', isObject(null)
);

console.log(
  'is null a derived object?', isDerivedObject(null)
);

// is 1234 an object?

console.log(
  'is 1234 an object?', isObject(1234)
);

console.log(
  'is 1234 a derived object?', isDerivedObject(1234)
);

// is new Number(1234) an object?

console.log(
  'is new Number(1234) an object?', isObject(new Number(1234))
);

console.log(
  'is new Number(1234) a derived object?', isDerivedObject(1234)
);

// is function object an object?

console.log(
  'is (new (function (){})) an object?', 
  isObject((new (function (){})))
);

console.log(
  'is (new (function (){})) a derived object?', 
  isObject((new (function (){})))
);

// is {} an object?

console.log(
  'is {} an object?', isObject({})
);

console.log(
  'is {} a derived object?', isDerivedObject({})
);

// is Array an object?

console.log(
  'is Array an object?',
  isObject([])
)

console.log(
  'is Array a derived object?',
  isDerivedObject([])
)

// is Date an object?

console.log(
  'is Date an object?', isObject(new Date())
);

console.log(
  'is Date a derived object?', isDerivedObject(new Date())
);

// is function an object?

console.log(
  'is function an object?', isObject(function(){})
);

console.log(
  'is function a derived object?', isDerivedObject(function(){})
);

Answer 16

आप अगर जाँच करने के लिए चाहते हैं, तो prototypeएक के लिए objectपूरी तरह से आता है Object। फ़िल्टर बाहर String, Number, Array, Arguments, आदि

function isObject (n) {
  return Object.prototype.toString.call(n) === '[object Object]';
}

या एकल-अभिव्यक्ति तीर फ़ंक्शन (ES6 +) के रूप में

const isObject = n => Object.prototype.toString.call(n) === '[object Object]'

Comments

यह सबसे अच्छा तरीका है, लेकिन मैं इसे दूसरी पंक्ति में भी आसान बना return Object.prototype.toString.call(n) === '[object Object]'

— दूंगा

आप nullचेक को हटा भी सकते हैं , क्योंकिObject.prototype.toString.call(null) === '[object Null]'

— Gust van de Wal

Answer 17

var a = [1]
typeof a //"object"
a instanceof Object //true
a instanceof Array //true

var b ={a: 1}
b instanceof Object //true
b instanceof Array //false

var c = null
c instanceof Object //false
c instanceof Array //false

मुझे और विवरण प्रदान करने के लिए कहा गया। हमारे चर एक वस्तु है अगर जाँच का सबसे साफ और समझने योग्य तरीका typeof myVar। यह एक प्रकार के साथ एक स्ट्रिंग लौटाता है (जैसे "object","undefined" ) के ।

दुर्भाग्य से या तो अर्रे और नल का भी एक प्रकार है object। केवल वास्तविक वस्तुओं को लेने के लिए instanceofऑपरेटर का उपयोग करके विरासत श्रृंखला की जांच करने की आवश्यकता है । यह अशक्त को समाप्त कर देगा, लेकिन एरियर के पास विरासत श्रृंखला में ऑब्जेक्ट है।

तो समाधान है:

if (myVar instanceof Object && !(myVar instanceof Array)) {
  // code for objects
}

Comments

/./ instanceof Object //true

— यार्क

Answer 18

थोड़ी देर ... "सादे वस्तुओं" के लिए (मेरा मतलब है, जैसे {'x': 5, 'y': 7}) मेरे पास यह थोड़ा स्निपेट है:

function isPlainObject(o) {
   return ((o === null) || Array.isArray(o) || typeof o == 'function') ?
           false
          :(typeof o == 'object');
}

यह अगला आउटपुट जेनरेट करता है:

console.debug(isPlainObject(isPlainObject)); //function, false
console.debug(isPlainObject({'x': 6, 'y': 16})); //literal object, true
console.debug(isPlainObject(5)); //number, false
console.debug(isPlainObject(undefined)); //undefined, false
console.debug(isPlainObject(null)); //null, false
console.debug(isPlainObject('a')); //string, false
console.debug(isPlainObject([])); //array?, false
console.debug(isPlainObject(true)); //bool, false
console.debug(isPlainObject(false)); //bool, false

यह हमेशा मेरे लिए काम करता है। यदि "ओ" तभी वापस आएगा जब "ओ" का प्रकार "ऑब्जेक्ट" होगा, लेकिन कोई अशक्त, या सरणी या फ़ंक्शन नहीं। :)

Comments

जैसा कि पिछले उत्तरों में बताया गया है कि आपका दृष्टिकोण दिनांक ऑब्जेक्ट के मामले में विफल हो जाएगा।

— ग्रेजेर्गज पावलिक

Answer 19

lodash के पास PlainObject है , जो इस पेज पर आने वाले लोगों को ढूंढ सकता है। फंक्शन या एरे देने पर यह गलत हो जाता है।

Comments

उत्तम! मुझे पता था _.isObjectकि जेएस किसी वस्तु से क्या मेल खाता है। लेकिन मुझे आमतौर पर एक वस्तु शाब्दिक और एक सरणी के बीच अंतर करने की आवश्यकता होती है, जो _.isPlainObjectमुझे ऐसा करने की अनुमति देता है।

— चूना

Answer 20

यह काम करेगा। यह एक ऐसा फंक्शन है जो सच्चा, झूठा या संभवतः अशक्त लौटाता है।

const isObject = obj => obj && obj.constructor && obj.constructor === Object;

console.log(isObject({})); // true
console.log(isObject([])); // false
console.log(isObject(new Function)); // false
console.log(isObject(new Number(123))); // false
console.log(isObject(null)); // null

Comments

@SeregPie भविष्य में आपको उत्तरों में संपादन कोड से बचना चाहिए। जैसा कि यह उत्तर खड़ा है, जब परीक्षण मैंने nullअंतिम परीक्षा के बजाय परिणाम के रूप में प्राप्त किया false। देखें कि मुझे कोड बनाने के लिए संपादन कब करना चाहिए?

— निक

Answer 21

चूँकि इस समस्या को सही ढंग से संभालने के बारे में बहुत भ्रम है, मैं अपने 2 सेंट छोड़ दूंगा (यह उत्तर विशेष रूप से अनुपालन है और सभी परिस्थितियों में सही परिणाम प्रस्तुत करता है):

आदिम के लिए परीक्षण: undefined null boolean string number

function isPrimitive(o){return typeof o!=='object'||null}

एक वस्तु एक आदिम नहीं है:

function isObject(o){return !isPrimitive(o)}

या वैकल्पिक रूप से:

function isObject(o){return o instanceof Object}
function isPrimitive(o){return !isObject(o)}

किसी भी ऐरे के लिए परीक्षण:

const isArray=(function(){
    const arrayTypes=Object.create(null);
    arrayTypes['Array']=true;
    arrayTypes['Int8Array']=true;
    arrayTypes['Uint8Array']=true;
    arrayTypes['Uint8ClampedArray']=true;
    arrayTypes['Int16Array']=true;
    arrayTypes['Uint16Array']=true;
    arrayTypes['Int32Array']=true;
    arrayTypes['Uint32Array']=true;
    arrayTypes['BigInt64Array']=true;
    arrayTypes['BigUint64Array']=true;
    arrayTypes['Float32Array']=true;
    arrayTypes['Float64Array']=true;
    return function(o){
        if (!o) return false;
        return !isPrimitive(o)&&!!arrayTypes[o.constructor.name];
    }
}());

ऑब्जेक्ट को छोड़कर परीक्षण करना: Date RegExp Boolean Number String Functionकोई भी ऐरे

const isObjectStrict=(function(){
    const nativeTypes=Object.create(null);
    nativeTypes['Date']=true;
    nativeTypes['RegExp']=true;
    nativeTypes['Boolean']=true;
    nativeTypes['Number']=true;
    nativeTypes['String']=true;
    nativeTypes['Function']=true;
    return function(o){
        if (!o) return false;
        return !isPrimitive(o)&&!isArray(o)&&!nativeTypes[o.constructor.name];
    }
}());

Answer 22

जब सब कुछ विफल हो जाता है, तो मैं इसका उपयोग करता हूं:

var isObject = function(item) {
   return item.constructor.name === "Object";
}; 

Comments

स्ट्रिंग तुलना क्यों, बस क्यों नहीं item.constructor === Object?

— K3 --- rnc

nullएक अपवाद फेंकता हैUncaught TypeError: Cannot read property 'constructor' of null(…)

— Vitim.us

@ मैं पुराने IE संस्करणों का समर्थन करने का लक्ष्य बना रहा हूं, यह IE में काम क्यों नहीं करता है? कारण indexOfया वजह से constructor.name?

— जंकपंकट

Answer 23

Ramda कार्यात्मक पुस्तकालय जावास्क्रिप्ट प्रकार का पता लगाने के लिए एक अद्भुत कार्य है।

पूरा समारोह पैराफ्रेसिंग :

function type(val) {
  return val === null      ? 'Null'      :
         val === undefined ? 'Undefined' :
         Object.prototype.toString.call(val).slice(8, -1);
}

मुझे हंसना पड़ा जब मुझे एहसास हुआ कि समाधान कितना सरल और सुंदर था।

रामदा प्रलेखन से उदाहरण उपयोग :

R.type({}); //=> "Object"
R.type(1); //=> "Number"
R.type(false); //=> "Boolean"
R.type('s'); //=> "String"
R.type(null); //=> "Null"
R.type([]); //=> "Array"
R.type(/[A-z]/); //=> "RegExp"
R.type(() => {}); //=> "Function"
R.type(undefined); //=> "Undefined"

Answer 24

बहुत सारे कार्यान्वयनों को पढ़ने और आज़माने के बाद, मैंने देखा है कि बहुत कम लोग मानों की जाँच करने की कोशिश करते हैं JSON, जैसे Math,document 1 कदम से अधिक समय प्रोटोटाइप श्रृंखला के साथ या वस्तुओं।

typeofहमारे वैरिएबल की जाँच करने और फिर किनारे-केसों को हैक करने के बजाय , मैंने सोचा कि बेहतर होगा कि चेक को सरल बनाए रखा जाए क्योंकि रिफैक्टर के पास जाने से बचने के लिए जब नई प्राइमेटीज़ या देशी वस्तुएं जुड़ती हैं जो रजिस्टर के रूप में जुड़ती हैंtypeof 'ऑब्जेक्ट' के में होती हैं। '।

आखिरकार, typeofऑपरेटर आपको बताएगा कि क्या कुछ जावास्क्रिप्ट के लिए एक वस्तु है , लेकिन अधिकांश वास्तविक दुनिया परिदृश्यों (जैसे typeof null === 'object') के लिए जावास्क्रिप्ट की एक वस्तु की परिभाषा बहुत व्यापक है । नीचे एक फ़ंक्शन है जो यह निर्धारित करता है कि क्या चर हैv दो चेक को अनिवार्य रूप से दोहराकर एक वस्तु है:

1. एक लूप शुरू किया जाता है जो तब तक जारी रहता है जब तक का कड़ा संस्करण vहै '[object Object]'।
   मैं चाहता था कि फ़ंक्शन का परिणाम नीचे दिए गए लॉग की तरह हो, इसलिए यह एकमात्र "ऑब्जेक्टीनेस" है-क्राइटेरिया जिसे मैंने समाप्त किया। यदि यह विफल हो जाता है, तो फ़ंक्शन तुरंत गलत हो जाता है।
2. vश्रृंखला में अगले प्रोटोटाइप के साथ प्रतिस्थापित किया जाता है v = Object.getPrototypeOf(v), लेकिन इसके बाद सीधे मूल्यांकन भी किया जाता है। जब का नया मूल्य vहै null, तो इसका मतलब है कि रूट प्रोटोटाइप (जो श्रृंखला के अंदर एकमात्र प्रोटोटाइप हो सकता है) सहित हर प्रोटोटाइप ने चेक को लूप में पास कर दिया है और हम सही रिटर्न कर सकते हैं। अन्यथा, एक नया पुनरावृत्ति शुरू होता है।

function isObj (v) {
  while (     Object.prototype.toString.call(v) === '[object Object]')
  if    ((v = Object.getPrototypeOf(v))         === null)
  return true
  return false
}

console.log('FALSE:')
console.log('[]                   -> ', isObj([]))
console.log('null                 -> ', isObj(null))
console.log('document             -> ', isObj(document))
console.log('JSON                 -> ', isObj(JSON))
console.log('function             -> ', isObj(function () {}))
console.log('new Date()           -> ', isObj(new Date()))
console.log('RegExp               -> ', isObj(/./))

console.log('TRUE:')
console.log('{}                   -> ', isObj({}))
console.log('new Object()         -> ', isObj(new Object()))
console.log('new Object(null)     -> ', isObj(new Object(null)))
console.log('new Object({})       -> ', isObj(new Object({foo: 'bar'})))
console.log('Object.prototype     -> ', isObj(Object.prototype))
console.log('Object.create(null)  -> ', isObj(Object.create(null)))
console.log('Object.create({})    -> ', isObj(Object.create({foo: 'bar'})))
console.log('deep inheritance     -> ', isObj(Object.create(Object.create({foo: 'bar'}))))

Answer 25

if(typeof value === 'object' && value.constructor === Object)
{
    console.log("This is an object");
}

Comments

अगर valueहै nullकि यह एक त्रुटि फेंक होगा ...

— गेर्शोम

और निश्चित रूप से यह falseवस्तु के लिए होगा Object.assign({}, {constructor: null})।

— user4642212

Answer 26

यदि स्पष्ट रूप से जांचना चाहते हैं कि क्या दिया गया मान है {}।

function isObject (value) {
 return value && typeof value === 'object' && value.constructor === Object;
}

Answer 27

const isObject = function(obj) {
  const type = typeof obj;
  return type === 'function' || type === 'object' && !!obj;
};

!!objअगर objसच है (छानने के लिए null) जाँच के लिए आशुलिपि है

Answer 28

यह एक पुराना सवाल है, लेकिन इसे यहीं छोड़ देना चाहिए। अधिकांश लोग यह जाँच रहे हैं कि चर का {}अर्थ है कि की-वैल्यू पेयर किया गया है और यह नहीं कि अंडरलाइन निर्माण क्या है जो जावास्क्रिप्ट किसी दिए गए चीज के लिए उपयोग कर रहा है, क्यूज ईमानदार होना ज्यादातर जावास्क्रिप्ट में सब कुछ एक वस्तु है। इसलिए उस रास्ते से ले जाना। यदि तुम करो...

let x = function() {}
typeof x === 'function' //true
x === Object(x) // true
x = []
x === Object(x) // true

// also
x = null
typeof null // 'object'

हम जो चाहते हैं उसका अधिकांश समय यह जानना होता है कि क्या हमारे पास किसी API से संसाधन वस्तु है या ORM से हमारा डेटाबेस कॉल लौटा है। हम तब परीक्षण कर सकते हैं यदि कोई नहीं है Array, नहीं है null, टाइपोफ़ नहीं है 'function', और एक हैObject

// To account also for new Date() as @toddmo pointed out

x instanceof Object && x.constructor === Object

x = 'test' // false
x = 3 // false
x = 45.6 // false
x = undefiend // false
x = 'undefiend' // false
x = null // false
x = function(){} // false
x = [1, 2] // false
x = new Date() // false
x = {} // true

Comments

pops के trueलिएnew Date()

— toddmo

@toddmo कि बाहर इशारा करने के लिए धन्यवाद। अब उदाहरण कोड के लिए गलत हैnew Date()

— गिल्बर्ट

Answer 29

मुझे इसका उपयोग करना पसंद है

function isObject (obj) {
  return typeof(obj) == "object" 
        && !Array.isArray(obj) 
        && obj != null 
        && obj != ""
        && !(obj instanceof String)  }

मुझे लगता है कि ज्यादातर मामलों में एक तारीख को एक वस्तु के रूप में चेक पास करना होगा, इसलिए मैं तारीखों को फ़िल्टर नहीं करता

Answer 30

मुझे इस एसओ प्रश्न से केवल इस तरह की जाँच करने का एक "नया" तरीका मिला: कुछ शाब्दिकों के लिए इंस्टाफॉफ़ क्यों गलत है?

उस से, मैंने निम्न प्रकार की जाँच के लिए एक फ़ंक्शन बनाया:

function isVarTypeOf(_var, _type){
    try {
        return _var.constructor === _type;
    } catch(ex) {
        return false;         //fallback for null or undefined
    }
}

तो आप बस कर सकते हैं:

console.log(isVarTypeOf('asdf', String));   // returns true
console.log(isVarTypeOf(new String('asdf'), String));   // returns true
console.log(isVarTypeOf(123, String));   // returns false
console.log(isVarTypeOf(123, Number));   // returns true
console.log(isVarTypeOf(new Date(), String));   // returns false
console.log(isVarTypeOf(new Date(), Number));   // returns false
console.log(isVarTypeOf(new Date(), Date));   // returns true
console.log(isVarTypeOf([], Object));   // returns false
console.log(isVarTypeOf([], Array));   // returns true
console.log(isVarTypeOf({}, Object));   // returns true
console.log(isVarTypeOf({}, Array));   // returns false
console.log(isVarTypeOf(null, Object));   // returns false
console.log(isVarTypeOf(undefined, Object));   // returns false
console.log(isVarTypeOf(false, Boolean));   // returns true

यह क्रोम 56, फ़ायरफ़ॉक्स 52, माइक्रोसॉफ्ट एज 38, इंटरनेट एक्सप्लोरर 11, ओपेरा 43 पर परीक्षण किया गया है

संपादित करें:
यदि आप यह भी जांचना चाहते हैं कि क्या एक चर शून्य या अपरिभाषित है, तो आप इसके बजाय इसका उपयोग कर सकते हैं:

function isVarTypeOf(_var, _type){
    try {
        return _var.constructor === _type;
    } catch(ex) {
        return _var == _type;   //null and undefined are considered the same
        // or you can use === if you want to differentiate them
    }
}

var a = undefined, b = null;
console.log(isVarTypeOf(a, undefined)) // returns true
console.log(isVarTypeOf(b, undefined)) // returns true
console.log(isVarTypeOf(a, null)) // returns true

इनक की टिप्पणी से अपडेट: चुनौती स्वीकार की गई: डी

यदि आप वस्तुओं की तुलना करना चाहते हैं, तो आप इस तरह की कोशिश कर सकते हैं:

function isVarTypeOf(_var, _type, looseCompare){
    if (!looseCompare){
        try {
            return _var.constructor === _type;
        } catch(ex){
            return _var == _type;
        }
    } else {
        try{
            switch(_var.constructor){
                case Number:
                case Function:
                case Boolean:
                case Symbol:
                case Date:
                case String:
                case RegExp:
                    // add all standard objects you want to differentiate here
                    return _var.constructor === _type;
                case Error:
                case EvalError:
                case RangeError:
                case ReferenceError:
                case SyntaxError:
                case TypeError:
                case URIError:
                    // all errors are considered the same when compared to generic Error
                    return (_type === Error ? Error : _var.constructor) === _type;
                case Array:
                case Int8Array:
                case Uint8Array:
                case Uint8ClampedArray:
                case Int16Array:
                case Uint16Array:
                case Int32Array:
                case Uint32Array:
                case Float32Array:
                case Float64Array:
                    // all types of array are considered the same when compared to generic Array
                    return (_type === Array ? Array : _var.constructor) === _type;
                case Object:
                default:
                    // the remaining are considered as custom class/object, so treat it as object when compared to generic Object
                    return (_type === Object ? Object : _var.constructor) === _type;
            }
        } catch(ex){
            return _var == _type;   //null and undefined are considered the same
            // or you can use === if you want to differentiate them
        }
    }
}

इस तरह, आप inanc की टिप्पणी की तरह कर सकते हैं:

isVarTypeOf(new (function Foo(){}), Object); // returns false
isVarTypeOf(new (function Foo(){}), Object, true); // returns true

या

Foo = function(){};
Bar = function(){};
isVarTypeOf(new Foo(), Object);   // returns false
isVarTypeOf(new Foo(), Object, true);   // returns true
isVarTypeOf(new Bar(), Foo, true);   // returns false
isVarTypeOf(new Bar(), Bar, true);   // returns true
isVarTypeOf(new Bar(), Bar);    // returns true

Comments

यह पता नहीं लगा सकता है कि एक नया वर्ग एक वस्तु है या नहीं। isVarTypeOf (नया (फ़ंक्शन Foo () {}), ऑब्जेक्ट) // यह सच के बजाय गलत रिटर्न देता है। उचित जाँच के लिए नीचे मेरा उत्तर देखें।

— इनक गमूस

हालाँकि, आप instanceofऑब्जेक्ट के लिए जाँच करने के लिए उपयोग कर सकते हैं । फिर भी, यह एक सटीक विज्ञान नहीं है।

— इनक गमुस

@inanc, अच्छी तरह से है क्योंकि new Foo()एक Fooवस्तु देता है , उसी तरह new String()एक Stringवस्तु देता है , या new Date()एक Dateवस्तु लौटाता है , आप यह Foo = function(){}; isVarTypeOf(new Foo(), Foo);भी कर सकते हैं

— am05mhz

हाँ, यह वही है जो मैं वास्तव में कहता हूं: आप जाँच नहीं कर रहे हैं कि क्या यह अभी एक वस्तु है।

— इनक गमुस

@inanc चीयर्स, मैं टाइप चेकिंग करने का एक तरीका ढूंढ रहा था (सिर्फ ऑब्जेक्ट नहीं), इस पेज और दूसरे पेज पर गया, तो मैं बहुत उत्साहित हो गया कि मैं इस सवाल का संदर्भ भूल गया, मेरा बुरा :)

— am05mhz