I am doing some exercises on async/await and I am completely blank on this one:
The
opA function must be called before opB, and opBmust be called beforeopC. Call functions such a way thatC thenB thenA is printed out.
const print = (err, contents) => {
if (err) console.error(err)
else console.log(contents )
}
const opA = (cb) => {
setTimeout(() => {
cb(null, 'A')
}, 500)
}
const opB = (cb) => {
setTimeout(() => {
cb(null, 'B')
}, 250)
}
const opC = (cb) => {
setTimeout(() => {
cb(null, 'C')
}, 125)
}
My guess is there is a typo in the question, so I should just have the functions print out A B C and not C B A?
My attempt is this:
(async function () {
await print(opA());
await print(opB());
await print(opC());
}());
but I get
cb(null, 'C')
^
TypeError: cb is not a function
Question
I have literally no idea how to solve this one, and don't understand the usage of the print function.
Any help on how to get me going will be much appreciated =)
You said this is an async/await exercise but the code you show is the complete antithesis of async/await - it uses the callback paradigm.
To make your code print C B A you would need to pass callbacks to the opX functions in such an order to make them print their results:
const print = (err, contents) => {
if (err) console.error(err)
else console.log(contents )
}
const opA = (cb) => {
setTimeout(() => {
cb(null, 'A')
}, 500)
}
const opB = (cb) => {
setTimeout(() => {
cb(null, 'B')
}, 250)
}
const opC = (cb) => {
setTimeout(() => {
cb(null, 'C')
}, 125)
}
opA(print);
opB(print);
opC(print);The function stored in optA, opB, opC accept a callback function cb that is called in the timeout, with the first argument set to null and the second to A, B, C.
print holds a function that accepts an error (err) as first argument and the thing to print as the second argument (contents).
So you would combine the opt function with print that way: optA(print).
In the current form of the question, it would just be:
opA(print)
opB(print)
opC(print)
const print = (err, contents) => {
if (err) console.error(err)
else console.log(contents )
}
const opA = (cb) => {
setTimeout(() => {
cb(null, 'A')
}, 500)
}
const opB = (cb) => {
setTimeout(() => {
cb(null, 'B')
}, 250)
}
const opC = (cb) => {
setTimeout(() => {
cb(null, 'C')
}, 125)
}
opA(print)
opB(print)
opC(print)To get the result: C, B, A (due to the delays used for the setTimeouts).
But there might be something missing in the question.
The order in which you call these functions is almost irrelevant for the desired result. The timers are set to run in that specific order, first C, then B then A.
So you can just call them:
opA(print);
opB(print);
opC(print);
Or even:
opB(print);
opA(print);
opC(print);
Or even:
opC(print);
opB(print);
opA(print);
However, there are ways in which you can switch the order in which would give you a wrong result. For example:
opA((err, a) => (
print(err, a),
opB((err,b) => (
print(err, b),
opC(print)
))
))
Which will call opB after the timer set by opA is ran and opC is also called after opB timer is ran.
I believe the purpose of the exercise might be so you can observe that the order in which you call your functions doesn't always reflect the order you might intuitively expect.