आखिर अतुल्यकालिक कॉल

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

लेकिन अतुल्यकालिक अनुरोधों की ख़ासियत यह है कि हम नहीं जानते कि कौन सा पहले आएगा और कौन सा अंतिम होगा। वे इसे अलग-अलग तरीकों से हल करते हैं, लेकिन मैंने अभी तक एक सुंदर और सुरुचिपूर्ण नहीं देखा है। विषय में मैं आपको बताऊंगा कि मैं इसे कैसे देखता हूं।

var process = processFsAndDb.after('fs', 'db'); asyncFsAccess( file, process.fs); asyncDbAccess(query, process.db);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

आमतौर पर निम्न में से एक करते हैं:

शायद भाग्यशाली हैं

आमतौर पर, जो लोग अतुल्यकालिक कॉल को नहीं समझते हैं, वे ऐसा कर सकते हैं। कुछ इस तरह:

 var fileData = null; asyncFsAccess( file, function (data) { fileData = data; }); asyncDbAccess(query, function (dbData) { processFsAndDb(fileData, dbData); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

कल्पना कीजिए कि फ़ाइल सिस्टम का संचालन थोड़ा धीमा हो गया और डेटाबेस से अनुरोध तेजी से आया। तब फ़ाइलडेटा में कुछ भी नहीं होगा, हालांकि हमने बस इस डेटा को विघटित नहीं किया है! यह दुखद है ...

उसके साथ अंजीर, मैं इंतजार करूँगा

एक अन्य विकल्प कम से कम विश्वसनीय है। हम एक अनुरोध करते हैं, यह पूरा होने तक प्रतीक्षा करें, हम दूसरा अनुरोध करते हैं।

 asyncFsAccess( file, function (fileData) { asyncDbAccess(query, function (dbData) { processFsAndDb(fileData, dbData); }); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

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

7 बार जांच

ध्वज प्रणाली या चर जाँच। प्रत्येक अनुरोध के बाद, हम ध्वज को उसके अनुरूप चिह्नित करते हैं और, यदि सभी झंडे की जांच की जाती है, तो हम इसे निष्पादित करते हैं। सबसे सही विकल्प।

 var fileData = dbData = null; asyncFsAccess( file, function (data) { fileData = data; if (fileData && dbData) processFsAndDb(fileData, dbData); }); asyncDbAccess(query, function (data) { dbData = data; if (fileData && dbData) processFsAndDb(fileData, dbData); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

लेकिन बहुत सुंदर नहीं। कोड दोहराया जाता है, झंडे को कई स्थानों पर जोड़ा जाना चाहिए। यदि आपको तीन एक साथ अनुरोध भेजने की आवश्यकता है - तो डॉफिगा पाठ होगा

7 बार ++ की जाँच करें

 var fileData = dbData = null; var process = function () { if (fileData && dbData) processFsAndDb(fileData, dbData); }; asyncFsAccess( file, function (data) { fileData = data; process(); }); asyncDbAccess(query, function (data) { dbData = data; process(); });
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

यह बेहतर है, लेकिन बहुत अच्छा नहीं है। झंडे 4 बार दोहराए जाते हैं (फ़ाइलडेटा चर की संख्या गिनें)

मेरा विकल्प, प्रोटोटाइप का विस्तार करें

परिणामस्वरूप, कोड है:

 var process = function (args) { processFsAndDb(args.fs, args.db); }.after('fs', 'db'); asyncFsAccess( file, process['fs']); asyncDbAccess(query, process['db']);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

या, यहां तक ​​कि:

 var process = processFsAndDb.after('fs', 'db'); asyncFsAccess( file, process.fs); asyncDbAccess(query, process.db);
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

वास्तव में, हम झंडे के साथ विकल्प का उपयोग करेंगे, लेकिन इसे विधि के तहत अमूर्त करेंगे, जिसे हम फ़ंक्शन प्रोटोटाइप में जोड़ देंगे:

 Function.prototype.after = function () { /** * @var onReady -   -,        * @var after -   ,    . *        (process.fs  process.db) * @var ready -           , *    after    - ,   onReady */ var onReady = this, after = {}, ready = {}; var checkReady = function () { for (var i in after) if (!(i in ready)) return; onReady(ready); }; for (var i = 0, l = arguments.length; i < l; i++) { (function (key) { after[key] = function () { ready[key] = arguments; checkReady(); }; })(arguments[i]); } return after; };
      
      

        
        
        
      

    
        
        
        
      
      

        
        
        
      

    
     

मुझे लगता है कि इस तरह के दुर्लभ, लेकिन महत्वपूर्ण कार्य के लिए यह काफी सुविधाजनक और सुंदर तरीका है।