es6-promise

As far as I know, there are two options about promise : promise.all() promise.race() Ok, I know what promise.all() does. It runs promises in parallel, and .then gives you the values if both resolved successfully. Here is an example: Promise.all([ $.ajax({ url: 'test1.php' }), $.ajax({ url: 'test2.php' }) ]) .then(([res1, res2]) => { // Both requests resolved }) .catch(error => { // Something went wrong }); But I don't understand what does promise.race() is supposed to do exactly? In other word, what's the difference with not using it? Assume this: $.ajax({ url: 'test1.php', async: true,

By default the Promise.All([]) function returns a number based index array that contains the results of each promise. var promises = []; promises.push(myFuncAsync1()); //returns 1 promises.push(myFuncAsync1()); //returns 2 Promise.all(promises).then((results)=>{ //results = [0,1] } What is the best vanilla way to return a named index of results with Promise.all()? I tried with a Map, but it returns results in an array this way: [key1, value1, key2, value2] UPDATE: My questions seems unclear, here is why i don't like ordered based index: it's crappy to maintain : if you add a promise in your

I am looking for a way, with Node v7.6 or above, to get a Bluebird Promise (or any non-native promise) when an async function is called. In the same way I can do: global.Promise = require('Bluebird'); // Or Q/When var getResolvedPromise = () => Promise.resolve('value'); getResolvedPromise .tap(...) // Bluebird method .then(...); See: May I use global.Promise=require("bluebird") I want to be able to do something like: global.Promise = require('Bluebird'); // Or Q/When var getResolvedAsyncAwaitPromise = async () => 'value'; getResolvedAsyncAwaitPromise() .tap(...) // Error ! Native Promises does

Let's say I am using the following code to run a couple of promises in series: let paramerterArr = ['a','b','c','d','e','f'] parameterArr.reduce(function(promise, item) { return promise.then(function(result) { return mySpecialFunction(item); }) }, Promise.resolve()) The code simply calls mySpecialFunction (which returns a promise), waits for the promise to be resolved and then calls mySpecialFunction again etc. So the function is called once for every element in the array, in the correct order. How could I make sure that there is a delay of at least 50 milliseconds between every call of

I have several promises that I need to resolve before going further. Promise.all(promises).then((results) => { // going further }); Is there any way I can have the progress of the Promise.all promise? From the doc, it appears that it is not possible . And this question doesn't answer it either. So: Don't you agree that this would be useful? Shouldn't we query for this feature? How can one implement it manually for now? I've knocked up a little helper function that you can re-use. Basically pass your promises as normal, and provide a callback to do what you want with the progress.. function

Similar to this question , but rather than asking about how promises work in general, I specifically want to know: What is the standard/best way to wrap setTimeout in something that returns a Promise ? I'm thinking something like Angular's $timeout function , but not Angular specific. In Browsers First of all no - there is no built in for this. Lots of libraries that enhance ES2015 promises like bluebird whip with it. I think the other answer conflates executing the function and a delay, it also creates timeouts that are impossible to cancel. I'd write it simply as: function delay(ms){ var ctr

I have some older Node.js code that I'm updating. In the process I'm designing new modules to work with the old code. I'm finding that now, as opposed to when I first wrote this, I rely more on using ES6 promises rather than callbacks. So now I have this mix of some functions returning promises and some taking callbacks - which is tedious. I think eventually it should be refactored to use promises. But before that is done... What are the situations where promises are preferred and where are callbacks preferred? Is there any type of situation that a callback can handle better than a promise and