Promise.all बेबेल ES6 कार्यान्वयन

Question

में स्थापित किया गया है, मैं babel का उपयोग कर रहा हूं ताकि मैं node.js@0.10.x कोड को पार कर सकूं और मैं वादे के साथ अटक गया हूं।

मुझे लगता है कि मैं उदाहरण के लिए q और bluebird या angular.$q में इस्तेमाल कर सकते हैं allSettled प्रकार कार्यक्षमता की जरूरत है।

बेबेल के कोर-जेएस Promise पर, allSettled विधि नहीं है।

वर्तमान में मैं एक समाधान के रूप q.allSettled उपयोग कर रहा हूँ:

import { allSettled } from 'q';

उस कोलाहल polyfill में की तरह कुछ है? वैकल्पिक रूप से, जो मेरे लिए लागू करने की कोशिश करने के लिए एक अच्छा एल्गोरिदम है?

Answer 1

वैकल्पिक रूप से, जो मेरे लिए लागू करने का प्रयास करने के लिए एक अच्छा एल्गोरिदम है?

1. एक executor function
2. के साथ एक नया वादा बनाने निष्पादक
3. के दायरे में एक काउंटर/परिणाम सरणी का प्रयोग हर माता-पिता वादा सरणी
में परिणाम की बचत के साथ रजिस्टर एक तो() कॉलबैक
4. संकल्प/चरण 1 से वादा अस्वीकार जब काउंटर इंगित करता है कि सभी माता-पिता का वादा किया जाता है

Answer 2

यहाँ कुछ पर मेरे प्रयास समान, मैं हवलदार है ई न्यूज़लेटर सेवा और मेरे मामले में मैं अपने allSettled आदेश में सभी परिणाम (अस्वीकृत कर दिया और प्रस्तावों), की एक सरणी के साथ हल करने के लिए वादा करता हूँ, एक बार सभी email_promises निपटाया जाता है (सभी ईमेल बाहर चला गया था) चाहता था:

Newsletter.prototype.allSettled = function(email_promises) { 
    var allSettledPromise = new Promise(function(resolve, reject) { 
     // Keep Count 
     var counter = email_promises.length; 

     // Keep Individual Results in Order 
     var settlements = []; 
     settlements[counter - 1] = undefined; 

     function checkResolve() { 
      counter--; 
      if (counter == 0) { 
       resolve(settlements); 
      } 
     } 

     function recordResolution(index, data) { 
      settlements[index] = { 
       success: true, 
       data: data 
      }; 
      checkResolve(); 
     } 

     function recordRejection(index, error) { 
      settlements[index] = { 
       success: false, 
       error: error 
      }; 
      checkResolve(); 
     } 

     // Attach to all promises in array 
     email_promises.forEach(function(email_promise, index) { 
      email_promise.then(recordResolution.bind(null, index)) 
       .catch(recordRejection.bind(null, index)); 
     }); 
    }); 
    return allSettledPromise; 
} 

Answer 3

यहाँ ही कार्यक्षमता में एक और ले रहा है: spex.batch

source code फिर से पोस्ट करने के लिए यहाँ बहुत ज्यादा होगा, इसलिए यह इस प्रकार का उपयोग करने के batch processing से सिर्फ एक उदाहरण है:

var spex = require('spex')(Promise); 

// function that returns a promise; 
function getWord() { 
    return Promise.resolve("World"); 
} 

// function that returns a value; 
function getExcl() { 
    return '!'; 
} 

// function that returns another function; 
function nested() { 
    return getExcl; 
} 

var values = [ 
    123, 
    "Hello", 
    getWord, 
    Promise.resolve(nested) 
]; 

spex.batch(values) 
    .then(function (data) { 
     console.log("DATA:", data); 
    }, function (reason) { 
     console.log("REASON:", reason); 
    }); 

यह आउटपुट:

DATA: [ 123, 'Hello', 'World', '!' ] 

अब यह यह करने के लिए getWord बदलकर असफल बनाते हैं:

function getWord() { 
    return Promise.reject("World"); 
} 

अब उत्पादन होता है:

REASON: [ { success: true, result: 123 }, 
    { success: true, result: 'Hello' }, 
    { success: false, result: 'World' }, 
    { success: true, result: '!' } ] 

यानी पूरे सरणी बसे है, रिपोर्टिंग सूचकांक बाध्य परिणाम।

और अगर बजाय पूरे कारण है कि हम फोन getErrors() रिपोर्टिंग की:

console.log("REASON:", reason.getErrors()); 

तो उत्पादन होगा:

REASON: [ 'World' ] 

यह हुआ त्रुटियों की सूची के लिए त्वरित पहुँच आसान बनाने के लिए सिर्फ है ।

Answer 4

आप implementation of q.allSettled पर एक नज़र डालें, तो आप इसे वास्तव में लागू करने के लिए काफी सरल है या नहीं। यहां बताया गया है कि आप ES6 वादे का उपयोग करके इसे कैसे कार्यान्वित कर सकते हैं:

function allSettled(promises) { 
    let wrappedPromises = promises.map(p => Promise.resolve(p) 
     .then(
      val => ({ state: 'fulfilled', value: val }), 
      err => ({ state: 'rejected', reason: err }))); 
    return Promise.all(wrappedPromises); 
}