A polyfill is code that adds a standard feature to an environment that doesn't have it yet, such as Promise.any or Array.prototype.flat in an older browser. It's written in plain JavaScript that the old environment can already run, and it follows the specification, the document that defines how the feature behaves, as closely as it can. Code written for new browsers then works in old ones too. The name comes from Polyfilla, a paste for filling cracks in walls: a polyfill fills the gaps in a browser.
A real polyfill checks for the feature first, as in if (!Promise.any), and defines it only when it's missing, so a browser that has the built-in keeps its own version:
if (!Array.prototype.flat) {
Array.prototype.flat = function flat(depth) {
// the steps the specification lists, written in plain JavaScript
};
}
Every array gets its methods from one shared object, Array.prototype, and every function from Function.prototype. So a method added there appears on every array or function in the program, even ones created before it was added, and inside it this is the array or function it was called on. Careful polyfills add it with Object.defineProperty rather than = as above, so that, like the built-ins, it isn't enumerable and doesn't show up in a for...in loop.
When an interviewer asks you to write a polyfill, they mean: reproduce a built-in's behaviour yourself, without calling it. It shows you know exactly what the built-in does, beyond its everyday use. The details are the point, because code written against the standard relies on them too:
| Built-in | Everyday use | Details a polyfill must match too |
|---|---|---|
Array.prototype.map | [1, 2].map((n) => n * 2) is [2, 4] | thisArg, holes, and the TypeError for a callback that isn't a function, thrown even when the array is empty |
Function.prototype.bind | A function with a fixed this | Preset arguments, and calling the result with new |
Promise.all | Waits for several promises | Plain values among them, an empty input, and an argument that isn't iterable |
Object.create | An object that inherits from the one you pass | null as the prototype, and a TypeError for one that's neither an object nor null |
JSON.stringify | Turns data into text | undefined and functions, toJSON, and a TypeError on cycles |
These tasks give your version its own name, such as Array.prototype.myMap, Object.myCreate, or JSON.myStringify, or make it a stand-alone function, such as promiseAll(iterable) or objectIs(a, b). Replacing the real method would change it for every other piece of code on the page, and leave you no built-in to compare yours with.
In production you rarely write polyfills by hand: libraries such as core-js provide them, and Babel can add the ones your target browsers need. A polyfill can only add missing objects, functions, and methods. New syntax, such as ?. or class, can't be added that way: a compiler has to rewrite it as older syntax, which is called transpiling.
Write Promise.prototype.myFinally(onFinally), which works like the built-in finally without calling it. It returns a new promise, and once the original promise settles, fulfilled or rejected, it calls onFinally with no arguments.
The new promise settles the same way as the original: with the same value, or rejected with the same reason. What onFinally returns is ignored, with one exception: if it returns a promise, the new promise waits for that promise before settling. If onFinally throws, or returns a promise that rejects, the new promise rejects with that error instead.
If onFinally isn't a function, the result passes through unchanged.
Promise.resolve("data")
.myFinally(() => "ignored")
.then((value) => console.log(value)); // "data"
Promise.reject(new Error("offline"))
.myFinally(() => console.log("hide spinner"))
.catch((error) => console.log(error.message)); // "hide spinner", then "offline"
const original = Promise.resolve(1);
const result = original.myFinally(() => {});
expect(result).toBeInstanceOf(Promise);
expect(result).not.toBe(original);
const onFinally = spy();
await Promise.resolve("value").myFinally(onFinally);
expect(onFinally).toHaveBeenCalledTimes(1);
expect(onFinally.calls[0].args).toEqual([]);
const failed = Promise.reject(new Error("failed"));
failed.catch(() => {}); // so a broken myFinally can't leave it unhandled
const onFinally = spy();
await failed.myFinally(onFinally).catch(() => {});
expect(onFinally).toHaveBeenCalledTimes(1);
expect(onFinally.calls[0].args).toEqual([]);
await expect(Promise.resolve("value").myFinally(() => "ignored")).resolves.toBe("value");
const error = new Error("original");
const failed = Promise.reject(error);
failed.catch(() => {}); // so a broken myFinally can't leave it unhandled
await expect(failed.myFinally(() => "ignored")).rejects.toBe(error);
const clock = useFakeTimers();
let settled = false;
const result = Promise.resolve("done").myFinally(() => new Promise((resolve) => setTimeout(resolve, 100)));
const markSettled = () => {
settled = true;
};
result.then(markSettled, markSettled);
await clock.tickAsync(99);
expect(settled).toBe(false);
await clock.tickAsync(1);
expect(settled).toBe(true);
await expect(result).resolves.toBe("done");
const thrown = new Error("cleanup threw");
await expect(
Promise.resolve(1).myFinally(() => {
throw thrown;
}),
).rejects.toBe(thrown);
const rejected = new Error("cleanup rejected");
const cleanup = Promise.reject(rejected);
cleanup.catch(() => {}); // so a myFinally that ignores it can't leave it unhandled
await expect(Promise.resolve(1).myFinally(() => cleanup)).rejects.toBe(rejected);
const failed = Promise.reject(new Error("first"));
failed.catch(() => {}); // so a broken myFinally can't leave it unhandled
await expect(
failed.myFinally(() => {
throw thrown;
}),
).rejects.toBe(thrown);
await expect(Promise.resolve(1).myFinally()).resolves.toBe(1);
await expect(Promise.resolve(2).myFinally("not a function")).resolves.toBe(2);
const error = new Error("kept");
const failed = Promise.reject(error);
failed.catch(() => {}); // so a broken myFinally can't leave it unhandled
await expect(failed.myFinally(null)).rejects.toBe(error);
const builtIn = Promise.prototype.finally;
Promise.prototype.finally = function () {
throw new Error("myFinally called the built-in finally");
};
let result;
try {
result = Promise.resolve("value").myFinally(() => {});
} finally {
Promise.prototype.finally = builtIn;
}
await expect(result).resolves.toBe("value");
Run tests runs every test on your code, here in your browser. The problem is solved when they all pass.
Ctrl + Enter runs the tests (⌘ + Enter on a Mac).
I'm here to help with Promise.prototype.finally. I give hints, never the solution, so you get to solve it yourself. Ask for a hint, select code to ask about it, or press Ask Tuto why on a failing test.
Your first 3 answers need no account. for free to keep asking.