वादा

Question

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

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

var Promise = require('bluebird'); 

function poll() { 
    var interval; 

    return new Promise(function(resolve, reject) { 
    // This interval never resolves. Actual implementation could resolve. 
    interval = setInterval(function() { 
     console.log('Polling...') 
    }, 1000).unref(); 
    }) 
    .cancellable() 
    .catch(function(e) { 
     console.log('poll error:', e.name); 
     clearInterval(interval); 
     // Bubble up error 
     throw e; 
    }); 
} 

function pollOrTimeout() { 
    return poll() 
    .then(function() { 
     return Promise.resolve('finished'); 
    }) 
    .timeout(5000) 
    .catch(Promise.TimeoutError, function(e) { 
     return Promise.resolve('timed out'); 
    }) 
    .catch(function(e) { 
     console.log('Got some other error'); 
     throw e; 
    }); 
} 

return pollOrTimeout() 
    .then(function(result) { 
    console.log('Result:', result); 
    }); 

आउटपुट:

Polling... 
Polling... 
Polling... 
Polling... 
poll error: TimeoutError 
Result: timed out 

Answer 1

मैं कुछ इस तरह करना होगा -

function poll() { 
    return Promise.resolve().then(function() { 
    console.log('Polling...'); 
    if (conditionA) { 
     return Promise.resolve(); 
    } else if (conditionB) { 
     return Promise.reject("poll error"); 
    } else { 
     return Promise.delay(1000).then(poll); 
    } 
    }) 
    .cancellable() 
} 

इसके अलावा Promise constructor anti-pattern के बारे में पता

Answer 2

रेने Wooller एक बहुत अच्छी बिंदु बनाता हो:

चेतावनी: दुर्भाग्य से, इस तरह जावास्क्रिप्ट में प्रत्यावर्तन अंत में कॉल स्टैक को परिपूर्ण और स्मृति अपवाद

यहां तक ​​कि अगर यह है अपवाद, इस अंतरिक्ष बर्बाद किया जाता है, और एक अपवाद के जोखिम से बाहर का परिणाम देगा अत्यधिक मतदान विलंब को प्रोत्साहित कर सकता है।

मुझे लगता है कि यह बहुत महत्वपूर्ण setInterval पसंद करते हैं करने के लिए है:

var myPromise = new Promise((resolve, reject) => { 
    var id = window.setInterval(() => { 
     try { 
      if (conditionA) { 
       window.clearInterval(id); 
       resolve("conditionA"); 
      } else if (conditionB) { 
       throw new Error("conditionB!"); 
      } 
     } catch(e) { 
      window.clearInterval(id); 
      reject(e); 
     } 
    }, 1000); 
}); 

कुछ NPM संकुल कि इस आवश्यकता को, जिनमें से मैं promise-waitfor सबसे ज्यादा पसंद को संबोधित कर रहे हैं। यह 38 लाइन लंबी है और नौकरी करता है।

var myPromise = waitFor(() => { 
    if(conditionA) return true; 
    if(conditionB) throw new Error("conditionB!"); 
    return false; 
});