नोड-सिंक - फाइबर का उपयोग करके नोडज पर छद्म-तुल्यकालिक प्रोग्रामिंग

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

फाइबर द्वारा प्रदान किए जाने वाले अवसरों से प्रेरित होकर, मैंने एक नोड-सिंक लाइब्रेरी लिखी, जो नोड्ज के अतुल्यकालिक वातावरण में विकास को और अधिक सुविधाजनक बनाता है, और कोड अधिक दृश्य।

सार

//   ,  callback    1  function someAsyncFunction(a, b, callback) { setTimeout(function(){ callback(null, a + b); }, 1000) } //    ,  Function.prototype.sync(), //     ,   call() //      ""  ,      var result = someAsyncFunction.sync(null, 2, 3); console.log(result); // "5"  1  

दर्शन

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

नोड-सिंक मेरे लिए तीन महत्वपूर्ण प्रश्न हल करता है:
1. कॉलबैक के साथ अंतहीन इंडेंटेशन से छूट ("स्पेगेटी कोड" को समाप्त करता है)
2. सही त्रुटि से निपटने
3. रिफैक्टरिंग की आवश्यकता के बिना मौजूदा कोड / पुस्तकालयों के साथ एकीकरण

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

ताला

"फाइबर" की सुंदरता यह है कि जब प्रतीक्षा (उपज) होती है, तो केवल वर्तमान धागा अवरुद्ध होता है, न कि पूरी प्रक्रिया। संपूर्ण प्रक्रिया को लॉक करने का एक अच्छा उदाहरण fs.readFileSync और अन्य छद्म-तुल्यकालिक फ़ंक्शन हैं।

"फाइबर" का उपयोग करके आप वैश्विक अवरोधन से बच सकते हैं और, उसी समय, फ़ाइल को सिंक्रोनाइज़ करें:

 var fs = require('fs'), Sync = require('sync'); //    Sync(function(){ //   --> //   ,  Function.prototype.sync() var source = fs.readFile.sync(null, __filename); //     console.log(String(source)); }) 

इस कोड के बीच का अंतर यह है कि जब हम fs.readFile.sync () से प्रतिक्रिया की प्रतीक्षा कर रहे हैं, तो एप्लिकेशन शांतिपूर्वक अन्य संचालन करना जारी रखता है।

हैंडलिंग में त्रुटि

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

सही त्रुटि से निपटने के लिए बहुत वास्तविक नोडज कोड:

 //   -    , //  ,       function asyncFunction(callback) { var p_client = new Db('test', new Server("127.0.0.1", 27017, {})); p_client.open(function(err, p_client) { if (err) return callback(err); // <--  p_client.createCollection('test_custom_key', function(err, collection) { if (err) return callback(err); // <--  collection.insert({'a':1}, function(err, docs) { if (err) return callback(err); // <--  collection.find({'_id':new ObjectID("aaaaaaaaaaaa")}, function(err, cursor) { if (err) return callback(err); // <--  cursor.toArray(function(err, items) { if (err) return callback(err); // <--  //  = items callback(null, items); }); }); }); }); }); } 

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

 function syncFunction(callback) { //   Sync(function(){ var p_client = new Db('test', new Server("127.0.0.1", 27017, {})); p_client.open.sync(p_client); var collection = p_client.createCollection.sync(p_client, 'test'); collection.insert.sync(collection, {'a' : 1}); var cursor = collection.find.sync(collection, {'_id':new ObjectID("aaaaaaaaaaaa")) var items = cursor.toArray.sync(cursor); //  = items return items; }, callback) // <--    callback } 

विशेष फ़ंक्शन .prototyp.async () पद्धति का उपयोग करके, यह फ़ंक्शन और भी सरल हो सकता है (ऊपर दिए गए फ़ंक्शन के समान कार्य करता है):

 var syncFunction = function() { var p_client = new Db('test', new Server("127.0.0.1", 27017, {})); p_client.open.sync(p_client); var collection = p_client.createCollection.sync(p_client, 'test'); collection.insert.sync(collection, {'a' : 1}); var cursor = collection.find.sync(collection, {'_id':new ObjectID("aaaaaaaaaaaa")) var items = cursor.toArray.sync(cursor); //  = items return items; }.async() // <--          

समानता

कभी-कभी, हमें सभी परिणामों की प्रतीक्षा करते हुए, समानांतर में कई कार्य करने की आवश्यकता होती है, और उसके बाद ही जारी रहती है। इसके लिए Sync.Parallel है:

 var Sync = require('sync'); // -  ,     function someAsyncFunction(a, b, callback) { setTimeout(function(){ callback(null, a + b); }, 1000) } //   Sync(function(){ //       //      ,       var results = Sync.Parallel(function(callback){ someAsyncFunction(2, 2, callback()); someAsyncFunction(5, 5, callback()); }); console.log(results); // [ 4, 10 ] //   var results = Sync.Parallel(function(callback){ someAsyncFunction(2, 2, callback('foo')); // assign the result to 'foo' someAsyncFunction(5, 5, callback('bar')); // assign the result to 'bar' }); console.log(results); // { foo: 4, bar: 10 } }) 

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

 //   Sync(function(){ //  someAsyncFunction,     var foo = someAsyncFunction.future(null, 2, 2); var bar = someAsyncFunction.future(null, 5, 5); // foo, bar -     console.log(foo); // { [Function: Future] result: [Getter], error: [Getter] } //   ,    foo  bar console.log(foo.result, bar.result); // 4 10 -    ( ) }) 

स्थापना

$ npm install sync
$ node-fibers my_file.js

ध्यान रखें कि फाइबर का समर्थन करने के लिए आपको "नोड" के बजाय "नोड-फाइबर" स्क्रिप्ट का उपयोग करने की आवश्यकता है।

एपीआई

 var Sync = require('sync'); //  , fn - -,    Sync(fn) //  , fn - -, /   callback Sync(fn, callback) //    callback() Sync.Parallel(function(callback){ callback() //   ( ) callback('foo') //    }) //      / // obj - ,        Function.prototype.sync(obj, arg1, arg2) //       ,     //  / Future,    getter 'result' //    Future.result,      ,      // obj - ,        Function.prototype.future(obj, arg1, arg2) //      -  //  ,     // obj -  Function.prototype.async(obj) 

सारांश

मैं नोडज में इस दिशा को और विकसित करने का इरादा रखता हूं, क्योंकि यह मुझे बहुत सही लगता है। मुझे खुशी होगी अगर आप में से कोई इस विचार से प्रेरित है और इसके विकास में योगदान दे रहा है।

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

मैं बुद्धिशीलता के लिए, और इस तथ्य के लिए धन्यवाद देना चाहता हूं कि इसने मुझे विषय तंतुओं से संक्रमित किया :)

आपको नोड-फाइबर के आधार पर अन्य पुस्तकालयों में भी रुचि हो सकती है।