वर्ग जावास्क्रिप्ट जावास्क्रिप्ट क्रमांकन समर्थन

प्रस्तावना

वर्तमान में, मैं एक जावास्क्रिप्ट स्कीमा संपादक विकसित कर रहा हूं, और इस काम की प्रक्रिया में, मुझे एक समस्या का सामना करना पड़ा है कि यह लेख जटिल डेटा ऑब्जेक्ट्स, अर्थात् क्रमबद्धता और डीरियलाइज़ेशन पर ध्यान केंद्रित करेगा।

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

1. क्रमांकन के दौरान वर्ग की जानकारी को बचाने और deserialization के दौरान इसे पुनर्स्थापित करने की क्षमता।
2. वस्तुओं को लिंक को सहेजने और पुनर्स्थापित करने की क्षमता, सहित चक्रीय।

कटौती के तहत समस्या के बयान और इसके समाधान के बारे में और पढ़ें।

जीथब सीरियल सीरियल प्रोजेक्ट

जीथब प्रोजेक्ट का लिंक : लिंक ।
जटिल उदाहरण परीक्षण-src फ़ोल्डर में भी हैं।

पुनरावर्ती धारावाहिक: लिंक ।
फ्लैट क्रमांकक: लिंक ।

समस्या का बयान

जैसा कि मैंने पहले ही नोट किया है, प्रारंभिक कार्य संपादक के लिए मनमाने सर्किट को क्रमबद्ध करना है। संपादक का वर्णन करने में समय बर्बाद न करने के लिए, हम कार्य को आसान बनाते हैं। मान लीजिए कि हम ES6 जावास्क्रिप्ट कक्षाओं का उपयोग करके एक सरल एल्गोरिथ्म योजना का औपचारिक विवरण बनाना चाहते हैं, और फिर इस योजना को क्रमबद्ध करें और उसका उपयोग करें।

इंटरनेट पर, मुझे अधिकतम दो मानों का निर्धारण करने के लिए सबसे सरल एल्गोरिथम की उपयुक्त तस्वीर मिली:

यहां मुझे यह कहना होगा कि मैं एक जावास्क्रिप्ट डेवलपर नहीं हूं, और मेरी "मूल" भाषा C # है, इसलिए समस्या को हल करने का दृष्टिकोण C # में ऑब्जेक्ट-ओरिएंटेड डेवलपमेंट के अनुभव से तय होता है। इस आरेख को देखते हुए, मैं निम्नलिखित प्रकारों के सिरों को देखता हूं (सशर्त नाम और विशेष भूमिका नहीं निभाते हैं):

• प्रारंभ शीर्ष (प्रारंभ)
• अंतिम शिखर (समाप्त)
• टीम टॉप (कमांड)
• असाइनमेंट वर्टेक्स (लेट)
• सत्यापन सत्यापन शीर्ष (यदि)

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

आइए उस कोड को लिखें जो चित्र से सर्किट को इकट्ठा करता है, और परिणाम को क्रमबद्ध करने का प्रयास करता है।

//   let start = new Schema.Start(); let input = new Schema.Command(' A, B'); let check = new Schema.If('A > B'); let maxIsA = new Schema.Let('Max', 'A'); let maxIsB = new Schema.Let('Max', 'B'); let output = new Schema.Command(' Max'); let finish = new Schema.Finish(); //   start.addLink(input); input.addLink(check); check.addLink(maxIsA, { condition: 'true' }); check.addLink(maxIsB, { condition: 'false' }); maxIsA.addLink(output); maxIsB.addLink(output); output.addLink(finish); //    ( ) let schema = [ start, input, check, maxIsA, maxIsB, output, finish ]; 

यदि हम JSON.stringify का उपयोग करके इस स्कीमा को क्रमबद्ध करते हैं, तो हमें कुछ भयानक मिलता है। मैं परिणाम की पहली कुछ पंक्तियाँ दूंगा, जिसमें मैंने अपनी टिप्पणियाँ जोड़ीं:

 [ /*    */ { "id": "d9c8ab69-e4fa-4433-80bb-1cc7173024d6", "name": "Start", "links": { "2e3d482b-187f-4c96-95cd-b3cde9e55a43": { "id": "2e3d482b-187f-4c96-95cd-b3cde9e55a43", "target": /*    */ { "id": "f87a3913-84b0-4b70-8927-6111c6628a1f", "name": "Command", "links": { "4f623116-1b70-42bf-8a47-da1e9be5e4b2": { "id": "4f623116-1b70-42bf-8a47-da1e9be5e4b2", "target": /*     */ { "id": "94a47403-13ab-4c83-98fe-3b201744c8f2", "name": "If", "links": { ... 

क्योंकि पहले शीर्ष में दूसरे के लिए एक लिंक था, और उसके बाद वाले लोगों के लिए, फिर इसके क्रमांकन के परिणामस्वरूप पूरे सर्किट को क्रमबद्ध किया गया था। फिर दूसरी चोटी को क्रमबद्ध किया गया और सब कुछ जो उस पर निर्भर था, और इसी तरह। आप पहचानकर्ताओं द्वारा केवल इस हैश से मूल लिंक को पुनर्स्थापित कर सकते हैं, लेकिन वे मदद नहीं करेंगे यदि किसी भी कोने में सीधे या अन्य कोने के माध्यम से खुद को संदर्भित करता है। इस स्थिति में, धारावाहिक एक अनकैप्ड टाइप टाइप: थ्रो को: JSON त्रुटि के लिए सर्कुलर स्ट्रक्चर को परिवर्तित करेगा। यदि यह स्पष्ट नहीं है, तो यहां सबसे सरल उदाहरण है जो इस त्रुटि को उत्पन्न करता है: https://jsfiddle.net/L4guo863/ ।

इसके अलावा, JSON में स्रोत वर्गों के बारे में कोई जानकारी नहीं है, इसलिए यह समझने का कोई तरीका नहीं है कि क्रमांकन से पहले प्रत्येक शीर्ष किस प्रकार का था।

इन समस्याओं को महसूस करते हुए, मैं ऑनलाइन गया और तैयार समाधानों की तलाश करने लगा। कई थे, लेकिन अधिकांश बहुत भारी थे या क्रमबद्ध कक्षाओं के विशेष विवरण की आवश्यकता थी, इसलिए अपनी बाइक बनाने का निर्णय लिया गया था। और हां, मुझे साइकिल से प्यार है।

सीरियल की अवधारणा

यह खंड उन लोगों के लिए है जो वस्तुतः मेरे साथ क्रमबद्ध एल्गोरिथ्म बनाने में भाग लेना चाहते हैं।

डेटा प्रकार की जानकारी सहेजना

जावास्क्रिप्ट के साथ समस्याओं में से एक मेटाडेटा की कमी है जो सी # या जावा (विशेषताओं और प्रतिबिंब) जैसी भाषाओं में अद्भुत काम कर सकती है। दूसरी ओर, मुझे अनुक्रमिक क्षेत्र, सत्यापन और अन्य चिप्स की सूची को परिभाषित करने की क्षमता के साथ सुपर जटिल क्रमांकन की आवश्यकता नहीं है। इसलिए, मुख्य विचार वस्तु के प्रकार के बारे में जानकारी जोड़ना और साधारण JSON.stringify के साथ इसे क्रमांकित करना है।

समाधान खोजते समय, मुझे एक दिलचस्प लेख मिला, जिसका शीर्षक "JSON में टाइप जानकारी जोड़ने के लिए 6 गलत तरीके" के रूप में अनुवादित है। वास्तव में, तरीके बहुत अच्छे हैं, और मैंने नंबर 5 पर एक को चुना। यदि आप लेख पढ़ने के लिए बहुत आलसी हैं, लेकिन मैं इसे करने की अत्यधिक सलाह देता हूं, तो मैं संक्षेप में इस विधि का वर्णन करूंगा: जब किसी वस्तु को क्रमबद्ध करते हैं, तो हम उसे केवल किसी अन्य वस्तु में लपेटते हैं। एक फ़ील्ड जिसका नाम "@<type>" प्रारूप में है और मान ऑब्जेक्ट का डेटा है। डिसेरिएलाइज़ेशन के दौरान, हम टाइप नाम निकालते हैं, कंस्ट्रक्टर से ऑब्जेक्ट को फिर से बनाते हैं, और इसके फील्ड के डेटा को पढ़ते हैं।

यदि हम उपरोक्त उदाहरण से लिंक हटाते हैं, तो मानक JSON.stringify इस तरह के डेटा को क्रमबद्ध करता है:

 [ { "id": "d04d6a58-7215-4102-aed0-32122e331cf4", "name": "Start", "links": {} }, { "id": "5c58c3fc-8ce1-45a5-9e44-90d5cebe11d3", "name": "Command", "links": {}, "command": " A, B" }, ... } 

और हमारे धारावाहिक इसे इस तरह लपेटेंगे:

 [ { "@Schema.Start": { "id": "d04d6a58-7215-4102-aed0-32122e331cf4", "name": "Start", "links": {} } }, { "@Schema.Command": { "id": "5c58c3fc-8ce1-45a5-9e44-90d5cebe11d3", "name": "Command", "links": {}, "command": " A, B" } }, ... } 

बेशक, एक खामी है: धारावाहिक निर्माता को उन प्रकारों के बारे में पता होना चाहिए जो इसे क्रमबद्ध कर सकते हैं, और वस्तुओं को स्वयं उन क्षेत्रों को शामिल नहीं करना चाहिए जिनका नाम कुत्ते से शुरू होता है। हालांकि, दूसरी समस्या डेवलपर्स के साथ समझौते से या कुत्ते के प्रतीक को किसी और चीज़ से बदलकर हल की जाती है, और पहली समस्या कोड की एक पंक्ति में हल की जाती है (नीचे एक उदाहरण होगा)। हम ठीक-ठीक जानते हैं कि हम क्या करेंगे?

लिंक समस्या का समाधान

यह एल्गोरिथम के संदर्भ में अभी भी सरल है, लेकिन इसे लागू करना अधिक कठिन है।

जब धारावाहिक में पंजीकृत कक्षाओं के क्रमांकन को क्रमबद्ध करते हैं, तो हम उन्हें कैश में संग्रहीत करेंगे और उन्हें एक सीरियल नंबर असाइन करेंगे। अगर भविष्य में हम इस उदाहरण को फिर से मिलते हैं, तो पहली परिभाषा में हम इस संख्या को जोड़ेंगे (फ़ील्ड नाम "@<type>|<index>" ) का रूप लेगा, और क्रमांकन के स्थान पर हम एक ऑब्जेक्ट के रूप में लिंक डालेंगे;

  { "@<type>": <index> } 

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

आइए योजना के पहले शीर्ष से दूसरे तक लिंक वापस करें और परिणाम देखें:

 [ { "@Schema.Start": { "id": "a26a3a29-9462-4c92-8d24-6a93dd5c819a", "name": "Start", "links": { "25fa2c44-0446-4471-a013-8b24ffb33bac": { "@Schema.Link": { "id": "25fa2c44-0446-4471-a013-8b24ffb33bac", "target": { "@Schema.Command|1": { "id": "4f4f5521-a2ee-4576-8aec-f61a08ed38dc", "name": "Command", "links": {}, "command": " A, B" } } } } } } }, { "@Schema.Command": 1 }, ... } 

यह पहली नज़र में बहुत स्पष्ट नहीं दिखता है, क्योंकि दूसरे शीर्ष को पहले लिंक संचार ऑब्जेक्ट में पहले के अंदर परिभाषित किया गया है, लेकिन यह महत्वपूर्ण है कि यह दृष्टिकोण काम करता है। इसके अलावा, मैंने धारावाहिक का दूसरा संस्करण बनाया, जो पेड़ को गहराई से नहीं, बल्कि चौड़ाई में दरकिनार करता है, जो इस तरह के "सीढ़ी" से बचा जाता है।

सीरियल बनाने वाला

यह खंड उन लोगों के लिए है जो ऊपर वर्णित विचारों को लागू करने में रुचि रखते हैं।

धारावाहिक रिक्त

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

 /** *  */ export default class Serializer { /** *  */ constructor() { this._nameToCtor = []; //    this._ctorToName = []; //    this._ignore = [Element]; //    } /** *   * @param {string} alias  * @param {Function} ctor  */ register(alias, ctor) { if (typeof ctor === 'undefined' && typeof alias === 'function') { //    -  ctor = alias; alias = ctor.name; } this._nameToCtor[alias] = ctor; this._ctorToName[ctor] = alias; } /** *     * @param {Function} ctor  */ ignore(ctor) { if (this._ignore.indexOf(ctor) < 0) { this._ignore.push(ctor); } } /** *   * @param {any} val  * @param {Function} [replacer]       * @param {string} [space]   * @returns {string}  */ serialize(val, replacer, space) { return JSON.stringify(new SerializationContext(this).serialize(val), replacer, space); } /** *     json * @param {any} val    json * @returns {any}  */ deserialize(val) { //     if (isString(val)) val = JSON.parse(val); return new DeserializationContext(this).deserialize(val); } } 

स्पष्टीकरण।

कक्षा को पंजीकृत करने के लिए, आपको इसके निर्माता को दो तरीकों में से एक में रजिस्टर विधि पास करनी होगी:

1. रजिस्टर (MyClass)
2. रजिस्टर ('MyNamespace.MyClass', MyClass)

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

हमारे उदाहरण के लिए, धारावाहिक का आरंभ इस प्रकार है:

 import Schema from './schema'; ... //   let serializer = new Serializer(); //   Object.keys(Schema).forEach(key => serializer.register(`Schema.${key}`, Schema[key])); 

स्कीमा ऑब्जेक्ट में सभी वर्टेक्स कक्षाओं का वर्णन होता है, इसलिए क्लास पंजीकरण कोड एक पंक्ति में फिट बैठता है।

क्रमबद्धता और निर्जनता का प्रसंग

आपने क्रिप्टिक SerializationContext और DeserializationContext वर्गों पर ध्यान दिया होगा। यह वह है जो सभी काम करते हैं, और मुख्य रूप से अलग-अलग क्रमांकन / deserialization प्रक्रियाओं से डेटा को अलग करने के लिए आवश्यक हैं, क्योंकि प्रत्येक कॉल के लिए उन्हें मध्यवर्ती जानकारी संग्रहीत करने की आवश्यकता होती है - अनुक्रमित वस्तुओं का एक कैश और लिंक के लिए एक सीरियल नंबर।

SerializationContext

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

निर्माता के साथ शुरू करते हैं:

 /** *  * @param {Serializer} ser  */ constructor(ser) { this.__proto__.__proto__ = ser; this.cache = []; //    this.index = 0; //     } 

मैं this.__proto__.__proto__ = ser; रहस्यमय रेखा समझाने की this.__proto__.__proto__ = ser;
कंस्ट्रक्टर के इनपुट पर, हम धारावाहिक के ऑब्जेक्ट को स्वयं स्वीकार करते हैं, और यह लाइन इसमें से हमारी क्लास को इनहेरिट करती है। यह इसके माध्यम से क्रमिक डेटा तक पहुंच की अनुमति देता है।
उदाहरण के लिए, this._ignore स्वयं को सीरियलाइज़र की अनदेखी कक्षाओं की सूची ("ब्लैक लिस्ट") को संदर्भित करता है, जो बहुत उपयोगी है। अन्यथा, हमें कुछ इस तरह this._serializer._ignore ।

मुख्य क्रमांकन विधि:

 /** *   * @param {any} val  * @returns {string}  */ serialize(val) { if (Array.isArray(val)) { //  return this.serializeArray(val); } else if (isObject(val)) { //  if (this._ignore.some(e => val instanceof e)) { //   return undefined; } else { return this.serializeObject(val); } } else { //   return val; } } 

यह ध्यान दिया जाना चाहिए कि तीन बुनियादी प्रकार के डेटा हैं जो हम संसाधित करते हैं: सरणियाँ, ऑब्जेक्ट और सरल मान। यदि किसी वस्तु का निर्माता "ब्लैक लिस्ट" में है, तो यह ऑब्जेक्ट क्रमबद्ध नहीं है।

सरणी क्रमांकन:

 /** *   * @param {Array} val  * @returns {Array}  */ serializeArray(val) { let res = []; for (let item of val) { let e = this.serialize(item); if (typeof e !== 'undefined') res.push(e); } return res; } 

आप मानचित्र के माध्यम से कम लिख सकते हैं, लेकिन यह महत्वपूर्ण नहीं है। केवल एक चीज महत्वपूर्ण है - अपरिभाषित के लिए मूल्य की जांच करना। यदि सरणी में एक गैर-धारावाहिक श्रेणी है, तो इस जांच के बिना यह सरणी में अपरिभाषित के रूप में गिर जाएगी, जो बहुत अच्छा नहीं है। मेरे कार्यान्वयन में भी, सरणियों को बिना चाबी के क्रमबद्ध किया जाता है। सैद्धांतिक रूप से, आप साहचर्य सरणियों को क्रमबद्ध करने के लिए एल्गोरिथ्म को परिष्कृत कर सकते हैं, लेकिन इन उद्देश्यों के लिए मैं वस्तुओं का उपयोग करना पसंद करता हूं। इसके अलावा, JSON.stringify को साहचर्य सरणियाँ भी पसंद नहीं हैं।

ऑब्जेक्ट क्रमांकन:

 /** *   * @param {Object} val  * @returns {Object}  */ serializeObject(val) { let name = this._ctorToName[val.constructor]; if (name) { //     if (!val.__uuid) val.__uuid = ++uuid; let cached = this.cache[val.__uuid]; if (cached) { //     if (!cached.index) { //     cached.index = ++this.index; let key = Object.keys(cached.ref)[0]; let old = cached.ref[key]; cached.ref[`@${name}|${cached.index}`] = old; delete cached.ref[key]; } //     return { [`@${name}`]: cached.index }; } else { let res; let cached = { ref: { [`@${name}`]: {} } }; this.cache[val.__uuid] = cached; if (typeof val.serialize === 'function') { //     res = val.serialize(); } else { //   res = this.serializeObjectInner(val); } cached.ref[Object.keys(cached.ref)[0]] = res; return cached.ref; } } else { //   return this.serializeObjectInner(val); } } 

जाहिर है, यह धारावाहिक का सबसे कठिन हिस्सा है, इसका दिल है। चलो इसे अलग ले जाओ।

शुरू करने के लिए, हम जाँचते हैं कि क्या क्लास कंस्ट्रक्टर को धारावाहिक में पंजीकृत है। यदि नहीं, तो यह एक साधारण वस्तु है, जिसके लिए serializeObjectInner यूटिलिटी मेथड कहा जाता है।

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

अगला, __uuid के मान से , हम एक ऐसी वस्तु की तलाश करते हैं जो कैश ( कैश्ड ) में वर्ग के उदाहरण का वर्णन करती है।

यदि ऐसी कोई वस्तु मौजूद है, तो मूल्य पहले ही धारावाहिक हो चुका है। इस मामले में, हम ऑब्जेक्ट को एक सीरियल नंबर असाइन करते हैं, अगर यह पहले नहीं किया गया है:

 if (!cached.index) { //     cached.index = ++this.index; let key = Object.keys(cached.ref)[0]; let old = cached.ref[key]; cached.ref[`@${name}|${cached.index}`] = old; delete cached.ref[key]; } 

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

जब नंबर सौंपा जाता है, तो हम एल्गोरिथ्म के अनुसार लिंक लौटाते हैं:

 //     return { [`@${name}`]: cached.index }; 

यदि पहली बार ऑब्जेक्ट को सीरियल किया जाता है, तो हम इसके कैश का एक उदाहरण बनाते हैं:

 let res; let cached = { ref: { [`@${name}`]: {} } }; this.cache[val.__uuid] = cached; 

और फिर इसे क्रमबद्ध करें:

 if (typeof val.serialize === 'function') { //     res = val.serialize(); } else { //   res = this.serializeObjectInner(val); } cached.ref[Object.keys(cached.ref)[0]] = res; 

वर्ग द्वारा क्रमांकन इंटरफ़ेस के कार्यान्वयन के लिए एक जांच है (जिस पर बाद में चर्चा की जाएगी), साथ ही Object.keys(cached.ref)[0] । Object.keys(cached.ref)[0] का निर्माण Object.keys(cached.ref)[0] । तथ्य यह है कि caked.ref रैपर ऑब्जेक्ट के लिए एक लिंक संग्रहीत करता है { "@<type>[|<index>]": <> } , लेकिन ऑब्जेक्ट फ़ील्ड का नाम हमारे लिए अज्ञात है, क्योंकि इस स्तर पर, हम अभी तक नहीं जानते हैं कि नाम में ऑब्जेक्ट नंबर (इंडेक्स) होगा या नहीं। यह निर्माण केवल वस्तु के पहले और एकमात्र क्षेत्र को निकालता है।

अंत में, ऑब्जेक्ट इंटर्नल को क्रमबद्ध करने की उपयोगिता विधि:

 /** *   * @param {Object} val  * @returns {Object}  */ serializeObjectInner(val) { let res = {}; for (let key of Object.getOwnPropertyNames(val)) { if (!(isString(key) && key.startsWith('__'))) { //  ,      res[key] = this.serialize(val[key]); } } return res; } 

हम एक नई वस्तु बनाते हैं और पुराने से फ़ील्ड को उसमें कॉपी करते हैं।

DeserializationContext

Deserialization प्रक्रिया रिवर्स ऑर्डर में काम करती है और विशेष टिप्पणियों की आवश्यकता नहीं होती है।

 /** *   */ class DeserializationContext { /** *  * @param {Serializer} ser  */ constructor(ser) { this.__proto__.__proto__ = ser; this.cache = []; //    } /** *   json * @param {any} val  json * @returns {any}  */ deserialize(val) { if (Array.isArray(val)) { //  return this.deserializeArray(val); } else if (isObject(val)) { //  return this.deserializeObject(val); } else { //   return val; } } /** *   * @param {Object} val  * @returns {Object}  */ deserializeArray(val) { return val.map(item => this.deserialize(item)); } /** *   * @param {Array} val  * @returns {Array}  */ deserializeObject(val) { let res = {}; for (let key of Object.getOwnPropertyNames(val)) { let data = val[key]; if (isString(key) && key.startsWith('@')) { //   if (isInteger(data)) { //  res = this.cache[data]; if (res) { return res; } else { console.error(`     ${data}`); return data; } } else { //   let [name, id] = key.substr(1).split('|'); let ctor = this._nameToCtor[name]; if (ctor) { //     res = new ctor(); //   ,    if (id) this.cache[id] = res; if (typeof res.deserialize === 'function') { //     res.deserialize(data); } else { //    for (let key of Object.getOwnPropertyNames(data)) { res[key] = this.deserialize(data[key]); } } return res; } else { //    console.error(`  "${name}"  .`); return val[key]; } } } else { //   res[key] = this.deserialize(val[key]); } } return res; } } 

अतिरिक्त सुविधाएँ

सरलीकरण इंटरफ़ेस

जावास्क्रिप्ट में कोई इंटरफ़ेस समर्थन नहीं है, लेकिन हम इस बात से सहमत हो सकते हैं कि यदि वर्ग क्रमबद्ध और डिसेरिएलाइज़ तरीकों को लागू करता है, तो इन तरीकों का उपयोग क्रमशः क्रमांकन / डीसर्विलाइज़ेशन के लिए किया जाएगा।

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

 Date.prototype.serialize = function () { return this.toISOString(); }; Date.prototype.deserialize = function (val) { let date = new Date(val); this.setDate(date.getDate()); this.setTime(date.getTime()); }; 

मुख्य बात यह है कि दिनांक प्रकार को पंजीकृत करना याद रखें: serializer.register(Date); ।

परिणाम:

 { "@Date": "2018-06-02T20:41:06.861Z" } 

केवल सीमा: क्रमांकन का परिणाम पूर्णांक नहीं होना चाहिए, क्योंकि इस मामले में, इसे ऑब्जेक्ट के संदर्भ के रूप में व्याख्या किया जाएगा।

इसी तरह, आप साधारण कक्षाओं को तार में अनुक्रमित कर सकते हैं। रंग वर्ग को क्रमबद्ध करने का एक उदाहरण, जो रंग का वर्णन करता है, लाइन पर #rrggbb पर है।

सपाट धारावाहिक

विशेष रूप से आपके लिए, प्रिय पाठकों, मैंने धारावाहिक का दूसरा संस्करण लिखा है, जो वस्तुओं के पेड़ को गहराई से पुनरावृत्ति नहीं करता है, लेकिन एक कतार का उपयोग करके चौड़ाई में पुनरावृत्ति करता है।

तुलना के लिए, मैं दोनों मामलों में हमारी योजना के पहले दो शीर्षों के क्रमांकन का एक उदाहरण दूंगा।

 [ { "@Schema.Start": { "id": "5ec74f26-9515-4789-b852-12feeb258949", "name": "Start", "links": { "102c3dca-8e08-4389-bc7f-68862f2061ef": { "@Schema.Link": { "id": "102c3dca-8e08-4389-bc7f-68862f2061ef", "target": { "@Schema.Command|1": { "id": "447f6299-4bd4-48e4-b271-016a0d47fc0e", "name": "Command", "links": {}, "command": " A, B" } } } } } } }, { "@Schema.Command": 1 } ] 

 [ { "@Schema.Start": { "id": "1412603f-24c2-4513-836e-f2b0c0392483", "name": "Start", "links": { "b94ac7e5-d75f-44c1-960f-a02f52c994da": { "@Schema.Link": { "id": "b94ac7e5-d75f-44c1-960f-a02f52c994da", "target": { "@Schema.Command": 1 } } } } } }, { "@Schema.Command|1": { "id": "a93e452e-4276-4d6a-86a1-0681226d79f0", "name": "Command", "links": {}, "command": " A, B" } } ] 

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

धारावाहिक के पेशेवरों और विपक्ष

पेशेवरों:

• धारावाहिक कोड काफी सरल और कॉम्पैक्ट है (लगभग 300 लाइनें, जिनमें से आधी टिप्पणियाँ हैं)।
• धारावाहिक का उपयोग करने के लिए आसान है और तीसरे पक्ष के पुस्तकालयों की आवश्यकता नहीं है।
• कक्षाओं के मनमाने ढंग से क्रमांकन के लिए क्रमिक इंटरफ़ेस के लिए अंतर्निहित समर्थन है।
• परिणाम सुखद आंख (IMHO) को भाता है।
• अन्य भाषाओं में एक समान धारावाहिक / डेसिरिलाइज़र विकसित करना कोई समस्या नहीं है। यदि सीरियलाइजेशन के परिणाम को पीठ पर संसाधित किया जाता है, तो इसकी आवश्यकता हो सकती है।

विपक्ष:

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

इसके अलावा एक ऋण यह है कि कोड ES6 में लिखा गया है। बेशक, जावास्क्रिप्ट के पुराने संस्करणों में परिवर्तित करना संभव है, लेकिन मैंने विभिन्न ब्राउज़रों के साथ परिणामी कोड की संगतता की जांच नहीं की।

मेरे अन्य प्रकाशन

1. .NET पर प्रोजेक्ट्स का स्थानीयकरण एक फंक्शन दुभाषिया के साथ
2. मॉडल-आधारित डेटा के साथ पाठ टेम्पलेट भरना। .NET कार्यान्वयन गतिशील बाइटकोड (आईएल) कार्यों का उपयोग करते हुए