What is the main concept of a promise?
The short question is: is a promise just a way to separate the code into different sections, so that when task 1 is done, do this task 2, 3, and 4. And when task 2 is done, do task 5, and so on? These tasks typically can take a long time, such as a fraction to a second to a few seconds, to even minutes or it may even fail. In other words, when something is done or has failed, how to continue?
The longer details are:
There seems to be an increasing use of promises. Is the main idea of promises about "being able to continue"? Or "continuable"?
It seems that in ES6 JavaScript, the promise is just a value, or a promised value (or a promised task), with a state. And then, a promise is "thenable", meaning that the programmer can specify, "what if the promise succeeded, then do " or "what if the promise failed, then do ". It is mainly about being able to control the continuity of code.
(the state of a promise above can be pending, fulfilled, or rejected, but it is somewhat implementation level details that we don't have to be concerned about.)
This seems especially important in a single threaded, single process environment, such as in JavaScript, when we fetch some network resource, and then when it is done, do something else. Since we don't have the ability to start a new thread to do that, and have the luxury to have the network data fetching "block" us (wait and wait until the complete data returns), so we need to say, "fetch data", and let me go on, and wake me up, and now, when waking me up, do this action action1, and this is exactly what promise.then(action1) does. (there really is no "wake me up", but just "do what I told you" but call me as a way to wake me up).
If we can have a thread, then we can do "fetch this data and then fill in table and graph" in a new thread. This thread can be "blocked" when fetching data from the network. And we don't have to worry about the main program being blocked.
Using a promise is almost like some lines of code:
if (doTask1() === statusSuccess)
then
...
else
...
except now, with promises, the "then" part and "else" part is like being chopped up into pieces, and they don't continue to run in one shot. 161
They run only when ready.
And the code becomes:
new Promise(function(...) {
// do something
})
.then(function() { ... })
.catch(function() { ... })
.finally(function() { ... });
But it also seems it is not strictly "single threaded", because if the network call cannot continue to fetch data, then what good is a promise? There are still extra processes or threads, but it is just system operations. (or perhaps user operations, if it is some kind of workers like Web Worker or Worker thread).
The above is with "chained promises", about do this, let me go on, and when done, let me know and continue with ___. And a series of these. There can also be this: do a few things in parallel, and let me go on, and let me know (1) when everything is done, or (2) when one of them is done.
The (1) above can be to get data from 3 computer servers to get something all needed, and don't wake me up until all tasks are done. The (2) above can be, if 3 computer servers do the same complicated computation, and sometimes server 2 is faster, sometimes server 1 or 3, and they come back with the exact same answer. So if any of them come back, wake me up and continue with what I told you to do.
The (1) above is done by ES6 JS .all():
Promise.all([promise1, promise2, promise3]).then(function(values) {
console.log(values);
// the values of all promises given as an array of items
});
The (2) above is done by .race():
Promise.race([promise1, promise2, promise3]).then(function(value) {
console.log(value);
// whatever is faster
});
And there really is no "wake me up". It merely is "continue with what I told you." (because we merely say: myPromise.then(task1, task2)).
There also is a subtle difference between an observable and a promise (or thenable). 125