कॉफ़ीस्क्रिप्ट: ऑब्जेक्ट मेथड्स

ECMAScript के 5 वें संस्करण में, वस्तुओं के साथ काम करने के कई नए तरीके प्रकट हुए हैं, लेकिन उनका विस्तृत विवरण और रूसी में आंतरिक कार्यान्वयन (अक्सर अंग्रेजी में) इतना सरल नहीं है। यह इस कारण से है कि इस आलेख में ऑब्जेक्ट ऑब्जेक्ट के सभी तरीकों की जांच की जाएगी और ECMAScript विनिर्देश के 3 और 5 वें संस्करण के अनुसार विस्तार से वर्णन किया जाएगा।

सामग्री

1. Object.create (प्रोटो [, गुण])
2. Object.defineProperty (ऑब्जेक्ट, प्रॉपर्टी, डिस्क्रिप्टर)
3. Object.defineProperties (ऑब्जेक्ट, गुण)
4. Object.getOwnPropertyDescriptor (ऑब्जेक्ट, गुण)
5. Object.keys (ऑब्जेक्ट)
6. Object.getOwnPropertyNames (ऑब्जेक्ट)
7. डेटा डिस्क्रिप्टर
8. एक्सेसर डिस्क्रिप्टर
9. Object.getPrototypOf (ऑब्जेक्ट)
10. Object.preventExtensions (ऑब्जेक्ट)
11. Object.isExtensible (ऑब्जेक्ट)
12. Object.seal (ऑब्जेक्ट)
13. Object.isSealed (ऑब्जेक्ट)
14. Object.freeze (ऑब्जेक्ट)
15. Object.deepFreeze (ऑब्जेक्ट) (गैर-मानक)
16. Object.prototype.hasOwnProperty (संपत्ति)
17. Object.prototype.isPrototypOf (ऑब्जेक्ट)
18. Object.prototype.propertyIsEnumerable (ऑब्जेक्ट)
19. निष्कर्ष

Object.create (प्रोटो [, गुण])

Object.create () दिए गए प्रोटोटाइप ऑब्जेक्ट और गुणों के साथ एक नई वस्तु बनाता है:

object = Object.create property: 1 object.property # 1 

एक विधि दो इनिशियलाइज़ेशन पैरामीटर ले सकती है।
पहला पैरामीटर आवश्यक है, यह ऑब्जेक्ट का प्रोटोटाइप सेट करता है और इसे शून्य या ऑब्जेक्ट होना चाहिए।
दूसरा पैरामीटर वैकल्पिक है; यह ऑब्जेक्ट के गुणों को इनिशियलाइज़ करता है।

एक उदाहरण पर विचार करें:

 object = Object.create {}, property: value: 1 object.property # 1 

इस उदाहरण में, हम पहले पैरामीटर को एक खाली ऑब्जेक्ट पर सेट करते हैं, जो दूसरे पैरामीटर में परिभाषित गुणों के लिए प्रोटोटाइप ऑब्जेक्ट होगा।

रहस्यमय मूल्य संपत्ति को आपको परेशान न करें, थोड़ा बाद में हम इस विषय पर अधिक विस्तार से विचार करेंगे।

तो पहले और दूसरे विकल्प के बीच अंतर क्या हैं?
मुझे लगता है कि निम्नलिखित उदाहरण इस प्रश्न के उत्तर को स्पष्ट कर सकते हैं:

 object = Object.create property: 1 object.property = 2 object.property # 2 object = Object.create {}, property: value: 1 object.property = 2 object.property # 1 

तुम क्या पूछते हो?
बस, डिफ़ॉल्ट रूप से लिखने का दूसरा रूप यह है कि गुण केवल-पढ़े जाते हैं, हटाए नहीं जा सकते, और सूचीबद्ध नहीं किए जा सकते!

आइए एक उदाहरण देखें:

 object = Object.create {} property: value: 1 object.property = 2 object.property # 1 object.method = -> object.property do object.method # 1 key for key of object # method delete object.property # false 

जैसा कि आप देख सकते हैं, हमने प्रॉपर्टी के लिए कोई नया मान सेट नहीं किया है, उसे एन्यूमरेट करें, या हटाएं।

और अब मैं ध्यान आकर्षित करना चाहूंगा कि Object.create () का उपयोग करके प्रोटोटाइप वंशानुक्रम कैसे लागू किया जाता है:

 A = a: 1 b: 2 B = Object.create A, c: value: 3 enumerable: on for own key, value of B console.log " # {key}: # {value}" # c:3, a:1, b:2 

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

मैं यह नोट करना चाहता हूं कि कथन के लिए स्वयं ऑपरेटर की उपस्थिति लूप के शरीर में hasOwnProperty विधि के उपयोग से बचती है और ऑब्जेक्ट प्रोटोटाइप चेन में संपत्ति की जांच को रोकती है।
इस ऑपरेटर का अधिक विस्तृत विवरण मेरे पिछले लेख में पाया जा सकता है।

यदि आप रुचि रखते हैं कि अंदर से निर्माण () विधि कैसे काम करती है, तो मैं जो भी पढ़ता हूं उसे समेकित करने के लिए असाइनमेंट के रूप में, मैं विनिर्देश के अनुसार इसका कार्यान्वयन लाता हूं:

 Object.create = (object, properties) -> # 1. If Type(O) is not Object or Null throw a TypeError exception. if typeof object is not 'object' throw new TypeError "Object.create: # {object.toString()} is not an Object or Null" # 2. Let obj be the result of creating a new object as if by the expression new Object() # where Object is the standard built-in constructor with that name __new__ = new Object # 3. Set the [[Prototype]] internal property of obj to O. if '__proto__' of init __new__.__proto__ = object; else __new__.constructor:: = object # 4. If the argument Properties is present and not undefined, add own properties # to obj as if by calling the standard built-in function Object.defineProperties # with arguments obj and Properties. if typeof props is not 'undefined' Object.defineProperties object, props # 5. Return obj. object 

Object.defineProperty (ऑब्जेक्ट, प्रॉपर्टी, डिस्क्रिप्टर)

Object.defineProperty () विधि आपको किसी ऑब्जेक्ट की नई संपत्ति को परिभाषित करने और / या किसी मौजूदा संपत्ति की विशेषताओं को संशोधित करने की अनुमति देती है। नतीजतन, एक नई वस्तु वापस आ जाती है।

ऑब्जेक्ट - वह वस्तु जिसके लिए आप गुणों को परिभाषित करना चाहते हैं
संपत्ति - परिभाषित या संशोधित की जाने वाली संपत्ति का नाम
डिस्क्रिप्टर - डिस्क्रिप्टर

एक उदाहरण पर विचार करें:

 object = {} Object.defineProperty object, 'property' value: 1 

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

नए तरीकों के साथ, नए शब्द ECMAScript 5 में भी दिखाई दिए हैं, विशेष रूप से एक उपयोगकर्ता विवरणक ।

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

दूसरे शब्दों में, वर्णनकर्ता आपको संपत्ति विशेषताओं को नियंत्रित करने की अनुमति देते हैं।
ECMAScript 5 के आगमन से पहले, ऑब्जेक्ट विशेषताओं के साथ काम करने के लिए हमारे लिए बहुत अधिक मामूली उपकरण उपलब्ध थे: Object.prototype.propertyIsEnumerable () और Object.prototype.hasOwnProperty () ।

औपचारिक रूप से, डिस्क्रिप्टर को तीन प्रकारों में विभाजित किया जाता है: डेटा डिस्क्रिप्टर ( डेटा डिस्क्रिप्टर ), एक्सेस डिस्क्रिप्टर ( एक्सेसर डिस्क्रिप्टर ) और सामान्य डिस्क्रिप्टर ( जेनेरिक डिस्क्रिप्टर )।
हालांकि, हम अंतिम प्रकार के विवरणों पर विचार नहीं करेंगे, क्योंकि उनका वर्णन व्यावहारिक की तुलना में प्रकृति में अधिक सैद्धांतिक है।

डेटा डिस्क्रिप्टर

यह गुण तब बनाया जाता है जब विवरणक खाली हो या विवरणक के पास दो विशेषताओं में से एक हो: मूल्य या लेखन ।
आंतरिक विधि [[IsDataDescriptor]] विशेषताओं की उपस्थिति के लिए जाँच के लिए जिम्मेदार है:

 IsDataDescriptor (Descriptor): if Descriptor is undefined return off if !Descriptor.[[Value]] and !Descriptor.[[Writable]] return off return on 

आवश्यक विशेषताओं के अलावा, डेटा डिस्क्रिप्टर में वैकल्पिक विशेषताएं हैं: कॉन्फ़िगर करने योग्य और गणना करने योग्य ।

 { configurable: false, enumerable: false } 

आइए अब सभी विशेषताओं पर एक नज़र डालें:

मूल्य - वस्तु की संपत्ति का मूल्य निर्धारित करता है।
लिखने योग्य - यह निर्धारित करता है कि क्या किसी संपत्ति को बदला जा सकता है।
विन्यास योग्य - एक संपत्ति को नष्ट करने की क्षमता को परिभाषित करता है।
enumerable - एक संपत्ति गणना की पहुँच निर्धारित करता है

कार्यान्वयन के भीतर, इन विशेषताओं के निम्नलिखित नाम हैं: [[मूल्य]] , [[लिखने योग्य]] , [[असंख्य]] , [[विन्यास योग्य]] ।

डिफ़ॉल्ट रूप से, सभी डेटा डिस्क्रिप्टर विशेषताएँ झूठी हैं , मान विशेषता के अपवाद के साथ, इसका मान अपरिभाषित है ।

नोट: औपचारिक रूप से, ECMAScript 3 में उपयोगकर्ता विवरणक अनुपस्थित हैं, लेकिन आंतरिक विशेषताएँ DontEnum , ReadOnly और DontDelete नहीं हैं ।

इस प्रकार, हम स्वयं वस्तु गुणों के लिए समान विशेषताएं निर्धारित कर सकते हैं:

 Object.defineProperty {}, 'property' value: 1 writable: on enumerable: on configurable: on 

अब आइए कल्पना करें कि हमें वस्तु प्रोटोटाइप का विस्तार करने की आवश्यकता है:

 Object::method = -> @ 

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

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

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

 Object::my_super_method = -> @ 

यह संभावना नहीं है कि उस नाम के साथ एक विधि कभी विनिर्देश में गिर जाएगी।

दूसरी बात, हम जो वस्तु प्रोटोटाइप में जोड़ते हैं वह अन्य वस्तुओं में गिरता है:

 Object::method = -> 1 list = [] do list.method # 1 

तीसरा, इस तरह के एक विधि के पास enumerable विशेषता का सही मूल्य होगा:

 Object::method = -> 1 object = {}; i for i of object # method 

आप इस तरह से ऑब्जेक्ट से विधि विधि की गणना को रोक सकते हैं:

 i for own i of object 

इस तथ्य के बावजूद कि यह समाधान काम करता है, इसे ऑब्जेक्ट प्रोटोटाइप में एक विधि जोड़ने के चरण में भी सुधार किया जा सकता है:

 Object.defineProperty Object::, 'method' value: -> 1 enumerable: false i for i of object # 

जैसा कि आप देख सकते हैं, विधि कथन के लिए सूचीबद्ध नहीं थी ।

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

गौण विवरणक

एक एक्सेस डिस्क्रिप्टर वह है जिसमें एक गेट या सेट विशेषता होती है। इस मामले में, इन विशेषताओं की एक साथ उपस्थिति स्वीकार्य है। हालांकि, मूल्य और लेखन योग्य विशेषताओं की उपस्थिति की अनुमति नहीं है :

 IsDataDescriptor (Descriptor): if Descriptor is undefined return off if !Descriptor.[[Get]] and !Descriptor.[[Set]] return off return on 

तब आंतरिक विधि [[DefineOwnProperty]] को कहा जाता है
कार्यान्वयन के भीतर, विवरणक विशेषताओं के निम्नलिखित नाम हैं: [[प्राप्त करें]] और [[सेट]] ।

डेटा डिस्क्रिप्टर में विन्यास योग्य और गणना करने योग्य विशेषताएँ भी उपलब्ध हैं:

 property = 0 object = Object.defineProperty {}, 'property' get: -> property set: (value) -> property = value configurable: on enumerable: on object.property = 1 # set object.property # 1, get 

मैं यह भी नोट करना चाहता हूं कि डेटा और एक्सेस डिस्क्रिप्टर का एक साथ उपयोग अनुमत नहीं है:

 Object.defineProperty {}, 'property' get: -> 1 value: 1 # TypeError: property descriptors must not specify a value or be writable when a getter or setter has been specified 'value: 1" 

Object.create () के साथ , विरासत एक ही सिद्धांत का पालन करती है:

 A = a: 1 b: 2 B = Object.defineProperty A, 'c' value: 3 enumerable: on for own key, value of B console.log " # {key}: # {value}" # a:1, b:2, c:3 

Object.defineProperties (ऑब्जेक्ट, गुण)

आपको ऑब्जेक्ट के नए गुणों को परिभाषित करने और / या मौजूदा गुणों की विशेषताओं को संशोधित करने की अनुमति देता है। नतीजतन, एक नई वस्तु वापस आ जाती है। दूसरे शब्दों में, Object.defineProperties () केवल बहुत सारे गुणों के साथ Object.defineProperty () के समान है।

 object = Object.defineProperties {}, a: value: 1 enumerable: on b: value: 2 enumerable: on for own key, value of object console.log " # {key}: # {value}" # a:1, b:2 

यदि परिभाषित गुणों के नाम विरासत में प्राप्त लोगों के साथ मेल खाते हैं, तो विरासत में दिए गए लोगों को फिर से परिभाषित किया गया है:

 A = a: 1 b: 2 object = Object.defineProperties {} a: value: 3 enumerable: on b: value: 4 enumerable: on for own key, value of object console.log " # {key}: # {value}" # a:3, b:4 

यह याद रखने योग्य है कि किसी एक्सेसर को पुनर्परिभाषित करने से काम नहीं चलता:

 object = Object.defineProperty {}, 'property' get: -> 0 Object.defineProperty object, 'property' get: -> 1 object.property # 0 

जाहिर है, किसी संपत्ति को ओवरराइड करने के लिए, आपको कॉन्फ़िगर करने योग्य विशेषता के मूल्य को बदलने की आवश्यकता है:

 object = Object.defineProperty {}, 'property' get: -> 0 configurable: on Object.defineProperty object, 'property' get: -> 1 object.property # 1 

दुर्भाग्य से, IE संस्करण 9 के नीचे इस पद्धति का समर्थन नहीं करता है। हालांकि, सब कुछ इतना बुरा नहीं है, क्योंकि 8 वें संस्करण में एक Object.defineProperty () विधि है, जिसके आधार पर Object.defineProperties () लागू की जा सकती है:

 Object.defineProperties = (object, properties) -> type = (object) -> Object::toString.call object is '[object Object]' if !type object and !type properties throw new TypeError 'Object.defineProperties(Object object, properties Object)' if !Object.defineProperty return object; for own key, value of properties Object.defineProperty object, key, value object 

Object.getOwnPropertyDescriptor (ऑब्जेक्ट, गुण)

यह विधि आपको डिस्क्रिप्टर गुणों तक पहुंचने की अनुमति देती है।

 object = {} Object.defineProperty object, 'property' value: 1 writable: off enumerable: off configurable: on Object.getOwnPropertyDescriptor object, 'property' ### { value: 1, writable: true, enumerable: true, configurable: true } ### 

क्योंकि विवरणक गुण आंतरिक ECMAScript गुण हैं, Object.getOwnPropertyDescriptor () एकमात्र तरीका है जिसके द्वारा ऐसी जानकारी प्राप्त की जा सकती है। यह ध्यान देने योग्य है कि Object.getOwnPropertyDescriptor () केवल अपने गुणों के साथ काम करता है:

 Object.getOwnPropertyDescriptor {}, 'valueOf' # undefined 

क्योंकि valueOf संपत्ति विरासत में मिली है और प्रोटोटाइप श्रृंखला में है:

 {}.hasOwnProperty 'valueOf' # false 'valueOf' of {} # true 

जैसा कि मैंने पहले ही नोट किया है, ऑपरेटर के विपरीत, hasOwnProperty () विधि, केवल अपने गुणों की जांच करती है।

आप इस तरह से सीधे valueOf संपत्ति का उपयोग कर सकते हैं:

 {}.constructor::valueOf # function 

स्पष्टता के लिए, मैं निम्नलिखित उदाहरण पर विचार करना चाहूंगा:

 object = {} object.constructor::valueOf = 1 object.valueOf # 1 

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

 object = {} object.valueOf = 1 object.constructor::valueOf = 2 object.toString # 1 

जैसा कि आप देख सकते हैं, यदि कोई संपत्ति स्पष्ट रूप से ( स्वयं की संपत्ति ) किसी वस्तु पर सेट है, तो उसका मूल्य प्रोटोटाइप ऑब्जेक्ट के माध्यम से निर्दिष्ट संपत्ति को "ओवरलैप" करता है। अधिक सटीक रूप से, प्रोटोटाइप ऑब्जेक्ट में संपत्ति का मूल्य गायब नहीं होता है, यह बस हल नहीं करता है और हमेशा सीधे उपलब्ध होता है:

 object = {} object.toString = 1 object.constructor::valueOf = 2 object.toString # 1 object.constructor::valueOf # 2 'valueOf' of object # true object.hasOwnProperty 'valueOf' # false 

दूसरे शब्दों में, यदि ऑब्जेक्ट की संपत्ति स्पष्ट रूप से सेट नहीं है, तो खोज प्रोटोटाइप श्रृंखला में जारी है:

 object = {} object.constructor::constructor::constructor::property = 1 object.property # 1 

होमवर्क के रूप में, मेरा सुझाव है कि आप निम्नलिखित उदाहरण पर विचार करें:

 fn = (x) -> x * x fn 2 # 4 fn::constructor 4 # 8 

Object.keys (ऑब्जेक्ट)

एक सरणी देता है जिसमें ऑब्जेक्ट के एन्यूमरेटेड स्वयं के गुणों वाले नाम होते हैं।

एक विशिष्ट उदाहरण पर विचार करें:

 Object.keys a: 1 b: 2 .length # 2 

अक्सर, Object.keys का उपयोग एरे ऑब्जेक्ट के अन्य तरीकों के साथ संयोजन में किया जाता है:

 object = a: 1 b: 2 Object.keys(object).filter (i) -> i if object[i] > 1 # 2 

Object.keys () विधि का कार्यान्वयन काफी सरल है:

 Object.keys = (object) -> i for own i of object 

हालाँकि, मैं हमेशा इनपुट तर्क सत्यापन का उपयोग करने की अत्यधिक सलाह देता हूं।
मामूली सुधार के बाद, Object.keys () का एक विशिष्ट कार्यान्वयन कुछ इस तरह दिखना चाहिए:

 Object.keys = (object) -> if Object::toString.call(object) is not '[object Object]' throw new TypeError "Object.keys: # {object.toString()} is not an Object" i for own i of object 

विनिर्देश के अनुसार Object.keys () का कार्यान्वयन:

 Object.keys = (object) -> # 1. If the Type(O) is not Object, throw a TypeError exception if Object::toString.call(object) is not '[object Object]' throw new TypeError "Object.keys: # {object.toString()} is not an Object" # 2. Let count be the number of own enumerable properties of O count = Object.getOwnPropertyNames(object).length # 3. Let array be the result of creating a new Object as if by the expression new Array(n) # where Array is the standard built-in constructor with that name array = new Array count # 4. Let index be 0 index = 0; # 5. For each own enumerable property of O whose name String is P for own property of object if !object.propertyIsEnumerable property continue # a. Call the [[DefineOwnProperty]] internal method of array with arguments # ToString(index), the PropertyDescriptor # {[[Value]]: P, [[Writable]]: true, [[Enumerable]]: true, [[Configurable]]: true}, and false # b. Increment index by 1 Object.defineProperty array, index++, value: property writable: on enumerable: on configurable: on # 6. Return array array 

Object.getOwnPropertyNames (ऑब्जेक्ट)

एक सरणी देता है जिसमें ऑब्जेक्ट के अपने गुणों के नाम होते हैं।
Object.keys (ऑब्जेक्ट) के विपरीत , यह विधि ध्यान देने योग्य विशेषता के मूल्य को ध्यान में नहीं रखती है:

 object = a: 1 b: 2 Object.defineProperty object, '' value: 3, enumerable: off, Object.keys(object).length # 2 Object.getOwnPropertyNames(object).length # 3 

विनिर्देश के अनुसार Object.getOwnPropertyNames () का कार्यान्वयन:

 Object.getOwnPropertyNames = (object) -> # 1. If the Type(O) is not Object, throw a TypeError exception if Object::toString.call(object) is not '[object Object]' throw new TypeError "Object.getOwnPropertyNames: # {object.toString()} is not an Object" # 2. Let array be the result of creating a new Object as if by the expression new Array(n) # where Array is the standard built-in constructor with that name array = new Array # 3. Let index be 0 index = 0; # 4. For each named own property P of O for own name of object # a. Let name be the String value that is the name of P. # b. Call the [[DefineOwnProperty]] internal method of array with arguments # ToString(n), the PropertyDescriptor {[[Value]]: name, [[Writable]]: true, # [[Enumerable]]: true, [[Configurable]]: true}, and false. # c. Increment n by 1. Object.defineProperty array, index++, value: name writable: on enumerable: on configurable: on # console.log array # 5. Return array array 

Object.getPrototypOf (ऑब्जेक्ट)

निर्दिष्ट ऑब्जेक्ट की [[प्रोटोटाइप]] संपत्ति का संदर्भ देता है।

 object = {} Object.getPrototypeOf(object).property = 1 object.property # 1 

विधि कार्यान्वयन:

 Object.getPrototypeOf = (object) -> if Object::toString.call(object) is not '[object Object]' throw new TypeError "Object.getPrototypeOf: # {object.toString()} is not an Object" object.__proto__ or object.constructor:: 

Object.preventExtensions (ऑब्जेक्ट)

किसी वस्तु के विस्तार को अवरुद्ध करता है।

 object = a: 1 Object.preventExtensions object object.b = 1 'b' of object # false Object.getOwnPropertyDescriptor object, 'a' # { configurable: true, enumerable: true, value: 1, writable: true } 

मैं इस तथ्य पर विशेष ध्यान देना चाहता हूं कि विधियों का उपयोग करके एक बंद वस्तु को विस्तारित करने का प्रयास: Object.defineProperty और Object.defineProperties प्रकार के अपवाद को फेंक देंगे!

 object = {} Object.preventExtensions object Object.defineProperty object, 'property' value: 1 # TypeError: Object.defineProperties(object, 'property', ...) is not extensible 

इसके अलावा, TypeError को हमेशा सख्त मोड में फेंका जाता है:

 do -> 'use strict' object = {} Object.preventExtensions object object.property = 1 # "TypeError: object.property is not extensible 

इस मामले में, विशेष रूप से सावधान रहें, क्योंकि यदि आप टाइपर्रर को नहीं पकड़ते हैं, तो एप्लिकेशन काम करना बंद कर देगा!

Object.isExtensible (ऑब्जेक्ट)

ऑब्जेक्ट एक्सटेंशन की उपलब्धता को निर्धारित करता है। एक बूलियन मान लौटाता है।

 object = {} Object.preventExtensions object Object.isExtensible object # false 

Object.seal (ऑब्जेक्ट)

किसी वस्तु के गुणों को सील करता है।

 Object.seal = Object.preventExtensions + {[[Configurable]]: off} 

एक उदाहरण पर विचार करें:

 object = property: 1 Object.seal object delete object.property # false Object.getOwnPropertyDescriptor object, 'property' # { configurable: false, enumerable: true, value: 1, writable: true } 

Object.seal () सभी ऑब्जेक्ट गुणों के लिए कॉन्फ़िगर करने योग्य विशेषता के लिए गलत सेट करता है:

 Object.getOwnPropertyDescriptor(Object.seal property: 1, 'property').configurable # false 

यह ध्यान देने योग्य है कि वस्तु स्वयं सील नहीं है, लेकिन केवल इसके गुण हैं:

 object = {} Object.defineProperty, 'property' value: 1 Object.seal object delete object.property # false delete object # false object.property # 1 object # Object 

जैसा कि आप देख सकते हैं, किसी ऑब्जेक्ट को हटाने से काम नहीं चलेगा, क्योंकि डिलीट [[डिलीट]] ऑपरेटर किसी ऑब्जेक्ट के केवल गुण हटाता है।
इसका कारण यह है कि जावास्क्रिप्ट कोड में अनुवाद के चरण में, सभी चर पूर्ववर्ती कीवर्ड से होते हैं।

ऑब्जेक्ट को स्वयं हटाने के लिए, आपको इसे वैश्विक वैश्विक ऑब्जेक्ट की संपत्ति बनाने की आवश्यकता है:

 global.object = {} #  @object,     Object.seal object delete object object # ReferenceError: object is not defined 'object' 

हालांकि, वस्तुओं की ऐसी परिभाषा अच्छा अभ्यास नहीं है, क्योंकि वस्तु वैश्विक दायरे में आती है:

 do -> global.object = {} object # Object 

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

 object = {} object = undefined object # undefined 

यदि किसी बिंदु पर आपको फिर से इस चर का उपयोग करने की आवश्यकता है, तो आपको अशक्त ऑपरेटर का उपयोग करना चाहिए, जो संकेत देगा कि चर में एक बार ऑब्जेक्ट का संदर्भ था।

1. CoffeeScript में कोई शून्य ऑपरेटर नहीं है, इसके बजाय, आपको अपरिभाषित का उपयोग करना चाहिए, जो कि शून्य 0 में अनुवाद करता है ।
2. पूर्वनिर्धारित संपत्तियों को हटाने के बारे में कोई स्पष्ट नियम नहीं है।
उदाहरण के लिए, यह एक दिनांक ऑब्जेक्ट की अब संपत्ति को हटाने के लिए पूरी तरह से स्वीकार्य है, लेकिन साथ ही, आप फ़ंक्शन ऑब्जेक्ट की कॉल विधि को हटा नहीं सकते हैं:

  delete Date.now # true Date.now # undefined delete Function.call Function.call # [Function: call] 

उसी समय, इसे कंस्ट्रक्टर को हटाने की अनुमति है, जिसमें शामिल है और ऑब्जेक्ट ([विन्यास योग्य]]: सच) :

  delete Object # true typeof Object # undefined Object # ReferenceError: Object is not defined 

2. मैंने डिलीट ऑपरेटर को अधिक विस्तार से नहीं माना, क्योंकि यह इस लेख में शामिल करने के लिए एक बहुत बड़ा विषय है। यदि आप अभी भी इस प्रश्न में रुचि रखते हैं, तो मैं कंगैक्स के लेख को एक अंडरस्टैंडिंग डिलीट पढ़ने की सलाह देता हूं

इस तथ्य के अलावा कि Object.seal () ऑब्जेक्ट गुणों को हटाने पर रोक लगाता है, यह नए लोगों को जोड़ने को भी रोकता है:

 object = {} Object.seal object object.property = 1 object.property # undefined 

नोट: सर्वर कार्यान्वयन एक TypeError फेंक देगा!

हालाँकि, सीलिंग ऑब्जेक्ट प्रॉपर्टी वैल्यू के संशोधन तक सीमित नहीं है:

 object = property: 1 Object.seal object object.property = 2 object.property # 1 

जैसा कि Object.preventExtensions () के साथ , किसी ऑब्जेक्ट के गुणों को सख्त मोड में संशोधित करने का प्रयास करने या Object.defineProperty / Object.defineProperties का उपयोग करने से एक TypeError अपवाद होगा!

विनिर्देश के अनुसार Object.seal () का कार्यान्वयन:

 Object.seal = (object) -> # 1. If Type(O) is not Object throw a TypeError exception if Object::toString.call(object) is not '[object Object]' throw new TypeError "Object.seal: # {object} is not callable!" # 2. For each named own property name P of O, Object.getOwnPropertyNames(object).forEach (property) -> # a. Let desc be the result of calling the [[GetOwnProperty]] internal method of O with P __desc__ = Object.getOwnPropertyDescriptor object, property # b. If desc.[[Configurable]] is true, set desc.[[Configurable]] to false. if __desc__.configurable is on __desc__.configurable = off # c. Call the [[DefineOwnProperty]] internal method of O with P, desc, and true as arguments Object.defineProperty object, property, __desc__ # 3. Set the [[Extensible]] internal property of O to false # 4. Return O. Object.preventExtensions object 

Object.isSealed (ऑब्जेक्ट)

निर्धारित करता है कि क्या वस्तु सील है। एक बूलियन मान लौटाता है।

 object = {} Object.seal object Object.isSealed object # true 

यदि किसी खाली वस्तु को गैर-एक्स्टेंसिबल बनाया जाता है, तो वह सील हो जाएगी:

 object = {} Object.preventExtensions object Object.isSealed object # true 

हालांकि, यदि आप अब ऑब्जेक्ट में एक संपत्ति जोड़ते हैं, तो यह सील होना बंद हो जाएगा:

 object = property: 1 Object.preventExtensions object Object.isSealed object # false 

विनिर्देश के अनुसार Object.isSealed () का कार्यान्वयन:

 Object.isSealed = (object) -> # 1. If Type(O) is not Object throw a TypeError exception. if Object::toString.call(object) is not '[object Object]' throw new TypeError "Object.isSealed: # {object} is not callable!" # 2. For each named own property name P of O then Object.getOwnPropertyNames(object).forEach (property) -> # a. Let desc be the result of calling the [[GetOwnProperty]] internal method of O with P. __desc__ = Object.getOwnPropertyDescriptor object, property # b. If desc.[[Configurable]] is true, then return false. if __desc__.configurable is on return off # 3. If the [[Extensible]] internal property of O is false, then return true. # 4. Otherwise, return false. if !Object.isExtensible(object) then on else off 

ऑब्जेक्ट.फ़्रीज़ (ऑब्जेक्ट)

किसी वस्तु को मुक्त करता है।

 Object.freeze = Object.preventExtensions + Object.seal + {[[Writable]]: off} 

दूसरे शब्दों में, Object.freeze () ऑब्जेक्ट के नए गुणों को जोड़ने, मौजूदा लोगों को संशोधित करने और हटाने से रोकता है।

 object = a: 1 object.a = 0 # false    object.b = 0 # false     delete object.a # false    Object.getOwnPropertyDescriptor object, 'a' # { configurable: false, enumerable: true, value: 1, writable: false} 

क्योंकि हमने पहले ही विस्तार से जांच की है Object.preventExtensions () और Object.seal () दोहराने का कोई मतलब नहीं है।
केवल एक चीज जो मैं आपका ध्यान आकर्षित करना चाहता हूं वह है "फ्रीज" की गहराई:

 object = property: internal: 1 Object.freeze object object.property = 0 # false object.property.internal = 0 # true Object.getOwnPropertyDescriptor(object.property, 'internal').writable # true 

जैसा कि आप देख सकते हैं, पहले स्तर के केवल बच्चे के गुण अवरुद्ध हैं!
वास्तव में, ECMASctipt 5 के बारे में चिंता करने की कोई बात नहीं है कि कोई गहरी फ्रीज विधि नहीं है। आइए Object.deepFreeze () को स्वयं कार्यान्वित करने का प्रयास करें:

 Object.deepFreeze = (object) -> isObject = (value) -> Object::toString.call(value) is '[object Object]' if !isObject object throw new TypeError "Object.deepFreeze: # {object} is not callable!" for own key, value of object if isObject(value) and !Object.isFrozen value Object.deepFreeze(value) Object.freeze object object = property: internal: 1 Object.deepFreeze object Object.getOwnPropertyDescriptor(object.property, 'internal').writable # false 

विनिर्देश के अनुसार Object.freeze () का कार्यान्वयन:

 Object.freeze = (object) -> # 1. If Type(O) is not Object throw a TypeError exception if Object::toString.call(object) is not '[object Object]' throw new TypeError "Object.freeze: # {object} is not callable!" # 2. For each named own property name P of O, Object.getOwnPropertyNames(object).forEach (property) -> # a. Let desc be the result of calling the [[GetOwnProperty]] internal method of O with P __desc__ = Object.getOwnPropertyDescriptor object, property # b. If IsDataDescriptor(desc) is true, then # If desc.[[Writable]] is true, set desc.[[Writable]] to false if __desc__.value and __desc__.writable is on __desc__.writable = off # c. If desc.[[Configurable]] is true, set desc.[[Configurable]] to false if __desc__.configurable is on __desc__.configurable = off # d. Call the [[DefineOwnProperty]] internal method of O with P, desc, and true as arguments Object.defineProperty object, property, __desc__ # 3. Set the [[Extensible]] internal property of O to false # 4. Return O. Object.preventExtensions object 

Object.isFrozen (ऑब्जेक्ट)

निर्धारित करता है कि वस्तु जमी है या नहीं।

 object = property: 1 Object.isFrozen object # false Object.freeze object Object.isFrozen object # true 

विनिर्देश के अनुसार Object.isFrozen () का कार्यान्वयन :

 Object.isFrozen = (object) -> # 1. If Type(O) is not Object throw a TypeError exception. if Object::toString.call(object) is not '[object Object]' throw new TypeError "Object.isFrozen: # {object} is not callable!" # 2. For each named own property name P of O then Object.getOwnPropertyNames(object).forEach (property) -> # a. Let desc be the result of calling the [[GetOwnProperty]] internal method of O with P. __desc__ = Object.getOwnPropertyDescriptor object, property # b. If IsDataDescriptor(desc) is true then # i. If desc.[[Writable]] is true, return false. if __desc__.value and __desc__.writable is on return off # c. If desc.[[Configurable]] is true, then return false. if __desc__.configurable is on return off # 3. If the [[Extensible]] internal property of O is false, then return true. # 4. Otherwise, return false. if !Object.isExtensible(object) then on else off 

Object.prototype.hasOwnProperty (संपत्ति)

यह निर्धारित करता है कि किसी वस्तु की संपत्ति उसकी अपनी है या नहीं। एक बूलियन मान लौटाता है।

 object = property: 1 object.hasOwnProperty 'property' # true object.hasOwnProperty 'toString' # false 

आप न केवल अपने स्वयं के गुण, लेकिन यह भी विरासत में मिला है, जिस स्थिति में हैं, तो ऑपरेटर का उपयोग करना चाहिए जाँच करना चाहते हैं की , जो प्रोटोटाइप श्रृंखला की जांच करता है:

 object = property: 1 'property' of object # true 'toString' of object # true 

.AsOwnProperty () विधि लूप के लिए के साथ संयोजन के रूप में विशेष रूप से उपयोगी है :

 Object::inherited = 0 object = property: 1 (i for i of object) # [inherited, property] for i of object i if object.hasOwnProperty i # property 

जैसा कि आप देख सकते हैं, hasOwnProperty () विधि गारंटी दे सकती है कि विरासत में मिली संपत्तियों को शामिल नहीं किया गया है।
हालांकि, एक संभावना है कि hasOwnProperty नाम की एक संपत्ति पहले से ही एनुमरेटेड ऑब्जेक्ट में मौजूद हो सकती है :

 Object::inherited = -> object = own: 1 hasOwnProperty: -> @ for i of object i if object.hasOwnProperty i # inherited, own, hasOwnProperty 

बेशक, यह वह परिणाम नहीं है जो हम पाना चाहते थे। तो क्या करें?

इस स्थिति को बहुत ही सरलता से हल किया जा सकता है, केवल आवश्यक आदेश के संदर्भ में Object.prototype पर hasOwnProperty पद्धति को कॉल करें :

 Object::inherited = -> object = own: 1 hasOwnProperty: -> @ for i of object i if Object::hasOwnProperty.call object, i # own, hasOwnProperty 

.HasOwnProperty पद्धति को कॉल करने की यह विधि सबसे अधिक पसंद की जाती है। सबसे पहले, यह एक संभावित नाम संघर्ष को हल करता है, और दूसरी बात, यह विधि के सीधे संदर्भ के कारण तेजी से फ़िल्टरिंग प्रदान करता है।

जैसा कि पहले उल्लेख किया गया है, यदि किसी वस्तु की संपत्ति को अपने बीच नहीं पाया जा सकता है, तो खोज आगे प्रोटोटाइप श्रृंखला के साथ जारी रहती है।
इसका मतलब है कि विरासत में मिली संपत्तियों को भी अनुमानित रूप से शामिल किया जाएगा। और कब सेhasOwnProperty () विधि विरासत में मिली है, इसे निम्न गुणों में से कम से कम खोजा जाएगा:

 Object.getOwnPropertyNames Object.prototype [ 'toString', 'toLocaleString', 'hasOwnProperty', 'valueOf', 'constructor', 'propertyIsEnumerable', 'isPrototypeOf', ] 

कार्यान्वयन के आधार पर, इस सूची का विस्तार किया जा सकता है। उदाहरण के लिए, वी 8 , प्रेस्टो , गेको इंजनों के लिए , ये निम्नलिखित गुण होंगे:

  '__lookupGetter__', '__defineGetter__', '__defineSetter__', '__lookupSetter__' 

में छिपकली अभी भी आगे गुण होगा घड़ी और unwatch ।

इसलिए, वांछित संपत्ति की खोज करने वाले संसाधनों को बर्बाद न करने के लिए, हमेशा अपने स्थान को स्पष्ट रूप से इंगित करने का प्रयास करें और लूप बॉडी के बाहर की वस्तुओं के लिए चर और संदर्भों की परिभाषा बनाएं:

 object = {} own = Object::hasOwnProperty for i of object i if own.call object, i 

चूंकि विधि hasOwnProperty () अक्सर निर्देश के साथ संयोजन के रूप में प्रयोग किया जाता है के लिए-की , में CoffeeScript एक विशेष ऑपरेटर है खुद :

 alert i for own i of object 

प्रसारण परिणाम:

 var i, __hasProp = {}.hasOwnProperty; for (i in object) { if (!__hasProp.call(object, i)) continue; alert(i); } 

ऑपरेटर की की एक अधिक विस्तृत विवरण खुद और निर्देश के लिए-की : आलेख देखें CoffeeScript: एक गाइड चक्र विस्तृत ।

आपको याद दिलाता हूं कि ऑब्जेक्ट के स्वयं के गुणों को प्राप्त करने के लिए Object.keys () और Object.getOwnPropertyNames () विधियां हैं , जो कि इस कार्य के लिए फॉर- स्टेटमेंट की तुलना में अधिक उपयुक्त हैं ।

Object.prototype.isPrototypOf (ऑब्जेक्ट)

यदि दी गई वस्तु प्रोटोटाइप श्रृंखला में है तो जांचें। एक बूलियन मान लौटाता है।

 object = {} Object::isPrototypeOf object # true Object.isPrototypeOf object # false Function::isPrototypeOf Object # true Function::isPrototypeOf (new ->).constructor # true fn = -> instance = new fn fn::.isPrototypeOf instance # true 

Object.prototype.propertyIsEnumerable (ऑब्जेक्ट)

यह निर्दिष्ट करता है कि क्या निर्दिष्ट संपत्ति पर्याप्त है। एक बूलियन मान लौटाता है।

 object = property: 1 object.propertyIsEnumerable 'property' # true object.propertyIsEnumerable 'toString' # false object.propertyIsEnumerable 'prototype' # false object.propertyIsEnumerable 'constructor' # false list = [''] list.propertyIsEnumerable 0 # true list.propertyIsEnumerable 'length' # false 

निष्कर्ष:

हमने विनिर्देश के अनुसार ऑब्जेक्ट के सभी तरीकों और उनके आंतरिक कार्यान्वयन की पूरी तरह से जांच की । दुर्भाग्य से, ब्राउज़रों के लिए ECMAScript 5 से कई तरीके लागू करना जो उनका समर्थन नहीं करते हैं, काफी समस्याग्रस्त है। एक आंशिक कार्यान्वयन मेरे githab ई पर या यहां पाया जा सकता है

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