RX Patient Tools
Use these quick guides before reading the article, or return to them when you need help preparing questions for a doctor.
And note some fundamentals of Promise – When you create a new Promise, you’re really just creating a plain old JavaScript object. This object can invoke two methods, then, and catch. Both .then() and .catch() will return a new promise. That means that promises can be chained.
A promise is an object that may produce a single value some time in the future: either a resolved value, or a reason that it’s not resolved (e.g., a network error occurred). A promise may be in one of 3 possible states: fulfilled, rejected, or pending. Promise users can attach callbacks to handle the fulfilled value or the reason for rejection.
Below, the most generic way I declare a Promise
let genericPromise = new Promise((resolve, reject) => {
// First a condition
if (1 === 1) {
resolve()
} else {
reject()
}
})
The syntax for Javascript Promise.resolve() is the following.
Promise.resolve(value);
This Promise resolves with the value parameter.
VERY IMPORTANT – What is the difference between the below code of returning a Promise
new Promise(function(res, rej) {
res("aaa")
})
.then(function(result) {
return "bbb"
})
.then(function(result) {
console.log(result)
})
and the below way
new Promise(function(res, rej) {
res("aaa")
})
.then(function(result) {
return Promise.resolve("bbb")
})
.then(function(result) {
console.log(result)
})
Ans is –
A value returned inside a then() handler becomes the resolution value of the promise returned from that then().
The only difference is that you’re creating an unnecessary promise (by doing <return Promise.resolve(“bbb”)>) when you do return Promise.resolve(“bbb”).
So the following are all identical for a promise or plain value x:
Promise.resolve(x)
new Promise(function(resolve, reject) {
resolve(x)
})
Promise.resolve().then(function() {
return x
})
Promise.all([x]).then(function(arr) {
return arr[0]
})
In simple terms, inside a .then() handler function:
A) When x is a value (number, string, etc):
return x is equivalent to return Promise.resolve(x) throw x is equivalent to return Promise.reject(x)
B) When x is a Promise that is already settled (not pending anymore):
return x is equivalent to return Promise.resolve(x), if the Promise was already resolved. return x is equivalent to return Promise.reject(x), if the Promise was already rejected.
C) When x is a Promise that is pending:
return x will return a pending Promise, and it will be evaluated on the subsequent then. Read more on this topic on the Promise.prototype.then() docs.
Another super basic implementation of Promise function, returning the resolve() immediately. Of note here how if a single string is passed to resolve() – then that would be returned
const a3 = new Promise(resolve => {
resolve("Resolved Immediately")
})
console.log(a3)
Output of above :- Promise { ‘Resolved Immediately’ }
EXPLANATION – Promise resolve() method:
Promise.resolve() method in JS returns a Promise object that is resolved with a given value. Any of the following three things can happen:
-
- If the value is a promise – then promise is returned.
-
- If the value has a “then” attached to the promise – then the returned promise will follow that “then” to till the final state.
-
- If the promise is fulfilled with its value, then that value will be returned.
First note the first-principle constructor of a Promise – How to create and make a function that returns a Promise
const createdPromise = new Promise((resolve, reject) => {
// do a thing, possibly async, then…
if (/* everything turned out fine */) {
resolve("Stuff worked!");
}
else {
reject(Error("It broke"));
}
});
Now first Implementation – When Success case need to be returned
const promise = new Promise((resolve, reject) => {
// do a thing, possibly async, then…
if (1 === 1) {
resolve("Stuff worked!");
} else {
reject(Error("It broke"));
}
});
Will output the below
Stuff worked!
Now Second Implementation – When Error need to be returned
const promise = new Promise((resolve, reject) => {
// do a thing, possibly async, then…
if (1 === 2) {
resolve("Stuff worked!");
} else {
reject(Error("It broke"));
}
});
promise.then(
result => {
console.log(result); // "Stuff worked!"
},
function(err) {
console.log(err); // Error: "It broke"
}
);
The above will output the below
Error: It broke
at Promise (/home/rohan/codeLap/js/challenges/challenges-May-19/JS-Python_Challenges/test-code-1.js:19:12)
at new Promise (<anonymous>)
at Object.<anonymous> (/home/rohan/codeLap/js/challenges/challenges-May-19/JS-Python_Challenges/test-code-1.js:12:17)
at Module._compile (module.js:652:30)
at Object.Module._extensions..js (module.js:663:10)
at Module.load (module.js:565:32)
at tryModuleLoad (module.js:505:12)
at Function.Module._load (module.js:497:3)
at Function.Module.runMain (module.js:693:10)
at startup (bootstrap_node.js:188:16)
