सद्भाव संग्रह अब

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

if (navigator.userAgent.indexOf('Firefox/') > -1) 

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

• डोम तत्व
• XHR अनुरोध
• फ़ाइल तत्व

यह हमें तत्वों के आईडी-तत्वों के बिना काम करने का अवसर देता है, कई बार तेजी से डेटा-बाइंडिंग करता है, वादों का एक पागल वैकल्पिक कार्यान्वयन बनाता है और इसी तरह।
हम WeakMap के बारे में बात करेंगे। ऐसा नहीं है कि, हम WeakMap के लिए मौजूदा पॉलीफ़िल के बारे में बात करेंगे।



बाकी तत्वों की तरह:
मानचित्र एक हैश है जिसकी कुंजी या तो आदिम या वस्तु हो सकती है।
सेट अद्वितीय तत्वों का एक संग्रह है। यह मानचित्र के शीर्ष पर बनाने के लिए काफी सरल है। इसका सबसे महत्वपूर्ण लाभ सरणियों का प्रसंस्करण है, जिसके कारण ओ (एन ^ 2) से ओ (एन) तक यूनीक समस्या की जटिलता को कम करना संभव है।

DBMS के साथ काम करने की कौन सी विशेषताएं नोड के साथ बैकएंड पर दिखाई देती हैं - मैं शायद चुप रहूंगा, क्योंकि मैं अभी तक नोड के साथ आधिकारिक रूप से कुछ भी सिफारिश करने के लिए अच्छी तरह से परिचित नहीं हूं।

सिंटैक्स एक क्लासिक ऑब्जेक्ट की तुलना में थोड़ा अधिक जटिल है, लेकिन यह काफी समझने योग्य और पठनीय भी है:

 var map = new WeakMap; map.set(someObject, 'someKey'); alert(map.get(someObject)); map.delete(someObject); 

कोनेजेएस के पिछले संस्करणों में से एक सहित कई परियोजनाओं में, इस तरह के समाधान को संक्षिप्तता और कोड की पठनीयता के संदर्भ में उचित ठहराया गया था, हालांकि, इस तथ्य के कारण कि पॉलीफ़िल में से एक का उपयोग किया गया था, मैंने इस समाधान को ध्यान देने योग्य स्मृति-खाने के लिए माना।

Ecmascript.org कार्यान्वयन एक विकल्प के रूप में एक समान कार्यान्वयन प्रदान करता है (कुछ हद तक कम निष्पादन योग्य, जीथब पर पूर्ण कार्यान्वयन ) से छद्म स्थानांतरण।

 window.WeakMap = function () { var keyList = []; var valueList = []; return Object.freeze({ 'get': function (key, defaultValue) { var index = keyList.indexOf(key); var value = valueList[index]; return index === -1 ? defaultValue : value; }, 'set': function (key, value) { var index = keyList.indexOf(key); if (index === -1) { keyList.push(key); valueList.push(value); } else { valueList[index] = value; } } //...( has, delete  clear) }); }; 

इस कार्यान्वयन में बहुत सारी समस्याएं हैं।
सबसे पहले, मेमोरी ध्यान से बहती है: यहां तक ​​कि जब कोई तत्व हटा दिया जाता है, तो यह की-लिस्ट में रहता है, और यदि इस तरह का एक वीकेप एक वास्तविक परियोजना पर काम करता है, तो स्मृति की एक बड़ी मात्रा अनिवार्य रूप से पहले से हटाए गए ऑब्जेक्ट के भंडारण पर लीक हो सकती है। GarbageCollector एक तत्व पर काम नहीं करता है, इसके लिए, यह अभी भी मौजूद माना जाता है।
इंजन स्तर पर, यह हल किया जा सकता है, लेकिन फिर भी, कुछ मामलों में गारबेजकलेक्टर ठीक से काम नहीं करेगा।
दूसरे, जब कीलिस्ट में बहुत सारे तत्व होते हैं, तो बाद वाले का चयन वास्तव में मैकबुक एयर 2013 में क्रोम में बहुत समय लेने लगता है। 1e9 वें तत्व की खोज में एक सेकंड से अधिक समय लगा। कार्य की जटिलता हे (n), जो कभी-कभी प्रदर्शन को काफी प्रभावित करती है।

एक वैकल्पिक कार्यान्वयन है जो नमूना दर के साथ समस्या को हल करता है, जिससे समस्या की जटिलता ओ (1) तक कम हो जाती है:

 window.WeakMap = (function(){ var counter = Date.now() % 1e9; return function(){ var name = '__st' + (Math.random() * 1e9 >>> 0) + (counter++ + '__'); return { set: function(key, value) { var entry = key[this.name]; if (entry && entry[0] === key) entry[1] = value; else defineProperty(key, this.name, {value: [key, value], writable: true}); }, get: function(key) { var entry; return (entry = key[this.name]) && entry[0] === key ? entry[1] : undefined; } } } })(); 

हालाँकि, यह मेमोरी समस्या को हल नहीं करता है, और यहां तक ​​कि इसे बदतर भी बनाता है। प्रत्येक तत्व की स्मृति में एक चक्रीय लिंक दिखाई देता है: कुंजी [नाम] [0] === कुंजी। यदि आप खुले प्रलेखन पर विश्वास करते हैं, तो कचरा कलेक्टर ऐसे परिदृश्यों को पकड़ने में सक्षम नहीं है, ताकि समय के साथ स्मृति ऊपर चढ़ जाए - हालांकि इसमें बहुत समय लगेगा।
यही कारण है कि यह पॉलिमर / एक्स-टैग सावधानी के साथ उपयोग करने के लायक है, जिनमें से बहुत सारे वीकेप पर भरोसा करते हैं (थोड़ा कम कार्यान्वयन ऊपर दिया गया है)। इसलिए, उदाहरण के लिए, MutationObserver के लिए पॉलीफिल उस पर आधारित है, जिसका उपयोग न केवल उनके द्वारा किया जाता है, बल्कि बड़ी संख्या में तीसरे पक्ष की परियोजनाओं में भी किया जाता है, जिनमें से कई को इसमें स्मृति समस्याओं के बारे में पता नहीं हो सकता है।
एक ईमानदार कार्यान्वयन की तुलना में कुछ और minuses जोड़े जाते हैं। उनमें से एक बहुमत के लिए नगण्य हो जाएगा: हम जमे हुए वस्तुओं से जुड़े होने की क्षमता खो देते हैं। कुछ के लिए दूसरा बहुत गंभीर होगा। यह कार्यान्वयन IE9 + बन जाता है। पहला विकल्प इतना सरल है कि यह IE6 + में काम कर सकता है यदि आप एक Array.prototype.indexOf पॉलीफ़िल (उदाहरण के लिए, मोज़िला से ) कनेक्ट करते हैं। Array.prototype.indexOf IE9 में भी दिखाई दिया, लेकिन कम से कम इसे लागू किया जा सकता है। Object.defineProperty (सख्ती से बोलने के विपरीत, IE8 में DOM तत्वों के लिए डिफ़रेंपर्टी के लिए समर्थन है, लेकिन आप इस पर भरोसा नहीं कर सकते हैं)।

नतीजतन, हमारे पास रिकॉर्ड के बड़े संस्करणों पर या तो धीमी गति से संचालन होता है, या मुख्य तत्व में एक अतिरिक्त संपत्ति (जिसका अर्थ है, शायद, यहां तक ​​कि बाहर से इसका उपयोग भी होता है), कुछ पुनरावृत्तियों के साथ समस्याएं, और किसी भी मामले में, अतिरिक्त विशेषताओं से भरी हुई स्मृति।

JQuery में WeakMaps का कार्यान्वयन भी है। जब आप jQuery.data (तत्व, कुंजी) का अनुरोध करते हैं, तो आप WeakMap कार्यान्वयन में से एक के साथ काम कर रहे हैं। यह थोड़ा आसान काम करता है।
शायद आपने कभी अपने कोड में ऐसा कुछ देखा हो:

 document.body.jQuery19104357186993584037 20 

अब आप जानते हैं कि यह jQuery के अपने WeakMap में तत्व की आईडी है।

जब कोई तत्व हटा दिया जाता है, तो उसे हटा दिया जाता है, लेकिन हम अभी भी:

• बाहरी डेटा परिवर्तनों से संरक्षित नहीं;
• मूल्यों के लिए मेमोरी लीक से संरक्षित नहीं - चाबियाँ हटा दी जाती हैं, लेकिन उनके साथ जुड़े मूल्य मेमोरी में संग्रहीत होते हैं।

यहाँ हम मुख्य भाग में आते हैं।

वीकपाइप को इस तरह नामित किया गया था क्योंकि वे एक कमजोर संदर्भ लागू करना चाहते थे - एक कमजोर कनेक्शन जिसे जीसी में ध्यान में नहीं लिया जाता है, क्रमशः, कुंजी और मूल्य दोनों को हटा दिया जाता है जब इस कुंजी के लिए कोई अन्य प्रविष्टियां नहीं होती हैं।
सही कार्यान्वयन में, कुंजी और मान दोनों को हटा दिया जाना चाहिए।
लेकिन मैंने यह भी नहीं सोचा था कि यह तब तक संभव था जब तक कि मैं एक वाक्यांश में जीथब पर रिपॉजिटरी में से एक में नहीं आया जो एक वाक्यांश है, लेकिन आश्चर्य नहीं हो सकता:

नॉन-लीकी ओ (1) लुकअप टाइम के साथ वीकएप के लिए शिम

यह Object.defineProperty पर निर्भर करता है - जिसका अर्थ है IE9 + और जमी हुई वस्तुओं को संदर्भित करने में असमर्थता, लेकिन तत्व में कोई नई विशेषता नहीं थी, जो आश्चर्यचकित नहीं कर सकती थी।
रिपॉजिटरी ही यहाँ है: https://github.com/Benvie/WeakMap/
मैं जाँच का विरोध नहीं कर सका कि यह कितना सही हो सकता है।

मेमोरी स्नैपशॉट के साथ एक सरल और त्वरित परीक्षण इसके लिए बनाया गया था।

• पहले एक खाली पृष्ठ ( नीला तीर ) पर शूट किया गया था
• पॉलीफ़िल ( पीला तीर ) के कार्यान्वयन में दूसरा तारांकित
• तत्वों को बनाने और स्मृति ( लाल तीर ) में प्रवेश करने के बाद तीसरे को हटा दिया गया था
• तत्वों को शेष लिंक हटा दिए जाने के बाद चौथा हटा दिया गया था ( हरा तीर )

पूरी तरह से परीक्षण कोड

 // ""  1 //  // ""  2 var someStorage = []; var map = new WeakMap; var length = 1e5; // ie    1e4,     1e5      10   . for (var i = 0; i < length; i++) { someStorage[i] = {randomValue: Math.random() * 1e9 >>> 0}; //     ,        -  garbage collector       map.set(someStorage[i], {otherRandomValue: Math.random() * 1e9 >>> 0}) } // ""  3 for (var i = 0; i < length; i++) { someStorage[i] = void 0; } // ""  4 

परिणाम इस प्रकार हैं:

क्रोम 30 (मैक 10.9)


फ़ायरफ़ॉक्स 24 (मैक 10.9)


IE 11 (विन 8.1)


मैं ईमानदारी से स्वीकार करता हूं - जब मैंने देखा कि एप्लिकेशन ने जो भी मेमोरी ली थी, वह सभी हैरान थी - चाबियाँ और मूल्यों के लिए मेमोरी दोनों।

उसके बाद, मैंने केवल यह सुनिश्चित करने के लिए निर्णय लिया कि खोज समय वास्तव में O (1) है। यह सच निकला।

क्रोम 30 (मैक 10.9)


फ़ायरफ़ॉक्स 24 (मैक 10.9)


अंत में, यह सब सच है। WeakMap वास्तव में बड़ी संख्या में परियोजनाओं में इस्तेमाल किया जा सकता है, यह डेटा-बाइंडिंग के लिए काफी संभावना देता है, ओस्प्रे के साथ काम करता है, बड़ी संख्या में प्लग-इन बनाता है, और यह आज किया जा सकता है, किसी भी मामले में हमारे पास केवल हर पांचवें IE8 + परियोजना और बाकी IE9 + है। उसी समय, WeakMap न केवल कुछ प्रकार के डेटा के साथ काम को सरल करता है, बल्कि आपको प्रदर्शन और अनुकूलन में सुधार करने की अनुमति देता है, और कुछ मामलों में, स्मृति के साथ काम करता है।
मुख्य बात सही पॉलीफ़िल चुनना है।

वैसे, आप एक डबल पॉलीफ़िल बना सकते हैं, जैसे कुछ:

 if (Object.defineProperty) { window.weakMap = //O(1)         } else { window.weakMap = //O(n)  ,     } 

बेशक, इस समाधान के बारे में सबसे दिलचस्प बात यह है कि यह कैसे काम करता है। समाधान इतना भ्रामक है कि इसे समझने के लिए, मुझे लेखक ( ब्रैंडन बेनवी ) से संपर्क करना होगा और सबसे भ्रमित करने वाले विवरणों को समझने के लिए उनसे कुछ सवाल पूछने चाहिए।

मैं किसी और के कोड में अच्छी तरह से शामिल नहीं होना चाहता, लेकिन यह एक अविश्वसनीय रूप से लागू करने के लिए दिलचस्प था, और यह पता चला कि यह अध्ययन के लायक था, फिर भी ब्रैंडन (लेखक) ने ES3 पर ES6 संकलक लिखा, app.js (नोड पर डेस्कटॉप अनुप्रयोगों के लिए एक मंच) बनाया और जेएस में कई और अधिक जटिल समाधानों को लागू किया।

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

यह पहली बार में भ्रमित हो सकता है कि सभी विधियाँ वापस आती हैं

 function toString() { [native code] } 

इस मामले में, बाँध कहीं भी नहीं किया जाता है, जो एक साधारण फ़ंक्शन को ऐसे फ़ंक्शन में बदल सकता है।
हालांकि, सब कुछ बहुत सरल हो गया: प्रस्तुत करने का तरीका, जो इस प्रकार सेट है:

 var prep = { __proto__: [] } instanceof Array ? function(f){ f.__proto__ = stringifier } : function(f){ define(f, stringifier) }; 

एक __proto__ ऑब्जेक्ट बनाता है जो एक विशेष तत्व को प्रोटोटाइप करता है।
स्ट्रिंगर एक और कार्य है:

 var stringifier = function toString(){ return src[0] + nameOf(this) + src[1]; }; 

यह अपने आप में एक स्टर्लिंग विधि के रूप में सेट है (जैसा कि मैं इसे समझता हूं - यह संक्षिप्तता के लिए किया जाता है)। परिणामस्वरूप, हमें वास्तव में कुछ ऐसा मिलता है:

 a.__proto__ = { toString: function(){ return "function "+this.name+"() { [native code] }" } } 

वैसे, यह विशेष कोड इस तथ्य के कारण विशेष रूप से अच्छी तरह से काम नहीं करेगा कि सभी जेएस कार्यान्वयन में फ़ंक्शन का नाम विशेषता उपलब्ध नहीं है, इसका उपयोग करने के लिए इसे बुरा अभ्यास माना जाता है। फ़ंक्शन को पर्यावरण (इसके नाम सहित) पर भरोसा नहीं करना चाहिए और किसी भी परिस्थिति में समान काम करना चाहिए।
सटीक रूप से क्योंकि फंक्शन .prototyp.name सभी कार्यान्वयन में उपलब्ध नहीं है, ब्रैंडन कोड में फ़ंक्शन का नाम इस प्रकार परिभाषित किया गया है:

 function nameOf(func){ return 'name' in func ? func.name : toSource.call(func).match(/^\n?function\s?(\w*)?_?\(/)[1]; } 

यह डिफाइन (स्ट्रिपिफ़ायर, स्ट्रिफ़ायर) को हटाने के लिए पर्याप्त था, ताकि कोड हमें भ्रमित करना बंद कर दे।

इसलिए, हमें यह समझने की आवश्यकता है कि चाबियाँ कहाँ संग्रहीत हैं। ऐसा करने के लिए, हम मान सेट करते हैं, और यह सेट फ़ंक्शन में आता है:

 function set(key, value){ unwrap(this).set(key, value); } function get(key){ return unwrap(this).get(key); } 

और यहाँ मज़ा शुरू होता है:

 var unwrap = function(weakMap){ return data.unlock(weakMap).value; } 

डेटा आंतरिक वर्ग डेटा का एक उदाहरण है, जो अपने आप में WeakMap के समान है, लेकिन इसकी केवल दो विधियां हैं, प्राप्त करें और सेट करें, जबकि सभी कमजोर मानचित्र स्वयं एक बड़ी डेटा ऑब्जेक्ट में संग्रहीत होते हैं, जो अभी भी प्रत्येक कमजोर मैप को संग्रहीत करता है। एक डेटा ऑब्जेक्ट।
हमारे पास एक मेटा-वीकपेज़ है (यदि आप एक कुदाल को कुदाल कहते हैं) जो इसमें सभी WeakMaps को संग्रहीत करता है, जिनमें से प्रत्येक में पहले से ही वस्तुओं के लिए कुंजी-मूल्य जोड़े हैं।

और अंत में, डेटा ऑब्जेक्ट में सबसे दिलचस्प बात।

पहली चाल: हम मान को कुंजी के सामान्य सेट से छिपाते हैं ताकि यह किसी भी पुनरावृत्तियों में न पड़े। ऐसा करने के लिए, हम getOwnPropertyNames को फिर से असाइन करते हैं

 Object.defineProperty(Object, 'getOwnPropertyNames', { value: function getOwnPropertyNames(obj){ var props = getProps(obj); if (Object.prototype.hasOwnProperty.call(obj, globalID)) //   hasOwnProperty,       - . props.splice(props.indexOf(globalID), 1); return props; } }); 

परिणामस्वरूप, क्रोमियम डिबगर को भी संपत्ति के अस्तित्व पर संदेह नहीं है:



दूसरी चाल:

 function storage(obj){ if (hasOwn.call(obj, globalID)) return obj[globalID]; //   Object.isExtensible var store = create(null); defProp(obj, globalID, { value: store }); return store; }; 

आउटपुट पर, हमें कुंजी मूल्य के साथ एक अनूठी वस्तु मिलती है।

 function Data(){ var puid = createUID(), //   16-  secret = {}; // -      WeakMap   ,             .      ,      ,     .     –   private    Data this.unlock = function(obj){ var store = storage(obj); if (hasOwn.call(store, puid)) return store[puid](secret); var data = Object.create(null, { value: { writable: true, value: undefined } }); Object.defineProperty(store, puid, { value: (function(secret,data){ return function(key){ if(key===secret) return data } })(secret, data) }); return data; } } 

पहली बहुत ही रोचक पंक्ति है:

 Object.create(null, { value: { writable: true, value: undefined } }); 

हम ऑब्जेक्ट को शून्य से विरासत में बनाते हैं, जो हमें बिना किसी एक्सटेंशन के एक डमी ऑब्जेक्ट देता है, और फिर हम दूसरे तर्क के रूप में propertiesObject को पास करते हैं, जो हमें डिफाइनप्रोपर्टी के माध्यम से आवश्यक मान सेट करने की अनुमति देता है। हम स्पष्ट रूप से एक मूल्य बनाते हैं, लेकिन इसे अपरिभाषित पास करते हैं, केवल इसलिए कि यह पहले से मौजूद है और बाद में एक चेक (डेटा में "मूल्य") पास करता है।

दूसरी पागल दिलचस्प लाइन:

 Object.defineProperty(store, puid, { value: (function(secret,data){ return function(key){ if(key===secret) return data } })(secret, data) }); 

संक्षेप में, हमें एक ऐसा फ़ंक्शन मिलता है, जो एक विशिष्ट, विशिष्ट डमी ऑब्जेक्ट, प्रत्येक WeakMap के लिए अद्वितीय होता है, और संग्रहीत कुंजी देता है यदि यह गुप्त कुंजी से मेल खाता है।

वास्तव में, मूल कोड में यह और भी अधिक भ्रामक है:

 defProp(store, puid, { value: new Function('s', 'l', 'return function(k){if(k===s)return l}')(secret, data) }); 

ब्रैंडन ने इस तरह टिप्पणी की:

बस प्रदर्शन। शाब्दिक फ़ंक्शन को परिभाषित करके, आप सभी स्थानीय चर को भी दायरे में लेते हैं। `फंक्शन` का उपयोग करके कार्यक्षेत्र में एकमात्र वस्तु वैश्विक वस्तु है। लक्ष्य अनजाने में स्मृति को लीक करने से रोकना था। आपका संस्करण संभवत: ठीक काम करेगा, लेकिन ऐसे संदर्भों को लीक करने की क्षमता है जो अन्यथा बनाए नहीं रखी जाएगी, और इस तरह के रिसाव को रोकने के लिए एक WeakMap का उपयोग करने का अधिक लक्ष्य है।

रूसी में स्वतंत्र और विस्तारित अनुवाद में:

यह प्रदर्शन के लिए किया जाता है। फ़ंक्शन () {} के माध्यम से एक फ़ंक्शन बनाकर, आप इसमें स्थानीय ओस्प्रे को बांधते हैं - इस तथ्य के बावजूद कि यह किसी भी तरह से इसका उपयोग नहीं करता है। यदि आप डिबगर का उपयोग करते हैं, तो आप देख सकते हैं कि इस फ़ंक्शन के अंदर से वह पूरी सरणी जिसमें इसे बनाया गया था, उपलब्ध है।
नया फंक्शन एक ऐसा फंक्शन बनाता है जो ग्लोबल स्कोप में काम करता है, जो लोकल के लिए बाध्यकारी को हटा देता है। कार्यान्वयन का उद्देश्य स्मृति में लीक की अनुपस्थिति था, और वहां जो कुछ भी किया गया था वह मुख्य रूप से लीक की अनुपस्थिति के लिए किया गया था।

नतीजतन, वास्तव में, यह स्मृति में कुछ जैसा दिखता है:

 var map = new WeakMap; var a = {}; map.set(a, ['test']) console.log(a['2ql3g5ae6pcwstt9']['o6tnzx1xskf39pb9']) >function (k){if(k===s)return l} 

जहाँ ['2ql3g5ae6pcwstt9'] एक कीस्टॉर है, जो एक ऐसी डमी वस्तु है, जिसका नाम एक बेतरतीब ढंग से उत्पन्न वैशिवक से लेकर उन सभी तत्वों तक है, जो किसी भी कमजोर मानचित्र में आते हैं, और [2ql3g5ae6pcwstt9 '] [' o6tnzx1xskfxcb39s एक वस्तु जो एक क्लोजर को स्टोर करती है

 { value: '' } 

दूसरे तर्क के रूप में। मूल्य में बदलाव के मामले में, हम मूल्य को प्रतिस्थापित करते हैं, जबकि ऑब्जेक्ट बंद होने से पहले रहता है।

सभी कुंजी सभी संभव इंद्रियों में छिपी हुई हैं, उन्हें Object.getOwnPropertyNames से हटाने के लिए, इस वजह से हमें लगभग गैर-मौजूदा कुंजी मिलती हैं जो कोड के अंदर होने का संदेह नहीं किया जा सकता है - वे पुनरावृत्तियों में सूचीबद्ध नहीं हैं और किसी में नहीं दी गई हैं अनुरोध।
नतीजतन, हमें पूरी तरह से सुरक्षित (कोड के अंदर संशोधन के बिना पहुंच असंभव है) के साथ एक आईई 9 + कार्यान्वयन लागू होता है जिसमें कुंजियों के साथ एक कंटेनर खोलना होता है जिसे आसानी से बदला जा सकता है और जिसे हमेशा कुंजी के साथ हटा दिया जाता है, जो हमें वास्तव में गैर-लीकिंग वीकेप कार्यान्वयन के साथ देता है। O (1) की जटिलता और अव्यवहारिक और अपरिहार्य होने के कारण Object.defineProperty के साथ गुण विन्यास योग्य: असत्य, गणना योग्य: असत्य, गलत: असत्य (डिफ़ॉल्ट रूप से सेट) पहुंच कुंजियों के साथ।

बेशक, मैं इस तथ्य की तरह नहीं हूं कि कुंजी के लिए एक विशेषता बनाई गई है, लेकिन मुझे नहीं पता कि इसके लिए कौन सा समाधान अधिक आदर्श हो सकता है। यह केवल मानना ​​है कि ब्रैंडन ने स्मृति के साथ काम करने का एक बड़ा काम किया और एक निर्णय लिया जो उत्पादन में उपयोग किया जाना चाहिए।

मुझे टिप्पणियों के विचारों को सुनने में खुशी होगी कि आप अभी भी विशेष रूप से हार्मनी संग्रह और कमजोर मानचित्र का उपयोग क्यों कर सकते हैं, और सामान्य रूप से इसी तरह के एपीआई के लिए रवैया।

युपीडी। ब्रैंडन ने बताया कि क्यों (0, eval) ('यह') अंत में किया गया था। (0, eval) ("यह") लगभग var e = eval के बराबर है; ई ("यह")। तथ्य यह है कि eval हमेशा स्थानीय सरणी में काम करता है, हालांकि यदि आप किसी अन्य चर के लिए eval असाइन करते हैं और इसे चलाते हैं, तो इसे वैश्विक परिवेश में निष्पादित किया जाएगा।