Promisify — JavaScript Challenge | FineFrontend

Practice workspaceSign in

JavaScript/Promisifymedium

00:00

Read here. Code on desktop. The coding workspace opens on screens 1024px and wider.

JavaScript interview question

Promisify

medium15 min

Implement promisify(fn) to adapt an error-first, callback-last function into one that returns a Promise. The callback has the shape callback(error, value).

This lets callback-based operations work naturally with async/await while preserving the arguments and call-time context of the original operation.

Requirements

Export promisify as both a named and default export. Assume fn is a function using an error-first callback as its final argument.
Return a reusable function that creates a new Promise each time it is called. Do not call fn while constructing the wrapper.
Forward every supplied argument in order and append one callback. Preserve the wrapper invocation's this value when calling fn.
A truthy callback error rejects the Promise with the same error value. A falsy callback error means success and resolves with the second callback argument, including undefined.
Catch synchronous exceptions from fn as Promise rejections. Ignore fn's normal return value; completion is controlled by the callback.
The first settlement wins if the callback runs more than once or fn throws after a callback has already settled the Promise.
Support callbacks invoked immediately or later. No multiple-success-value aggregation, custom promisify symbols, cancellation, or Node-specific APIs are required.

Examples

Example 1

Input: const add = (a, b, callback) => callback(null, a + b);
const addAsync = promisify(add);

await addAsync(2, 5);
Output: 7

Example 2

Input: const fail = (callback) => callback(new Error("Unavailable"));

await promisify(fail)();
Output: Rejects with Error("Unavailable").

Example 3

Input: const task = (callback) => callback(null);

await promisify(task)();
Output: undefined

Use the same documented API in both language variants.

What the tests check

Returns a lazy wrapper and a Promise for synchronous callbacks
Forwards all arguments and appends the callback
Resolves asynchronously without using the original return value
Preserves call-time this for object methods
Rejects with the original callback error
Rejects asynchronous callback errors and non-Error reasons
Turns synchronous exceptions into rejections
Resolves falsy results and missing success values
Treats falsy error arguments as success
Uses the first callback settlement
Ignores a throw after an already settled callback
Keeps concurrent calls and Promise instances independent

References

Promise constructor Function.prototype.call()

PromisesCallbacksAsync JavaScriptFunction Context

Back

Preparing your workspace…