Skip to content

Instantly share code, notes, and snippets.

What would you like to do?
How to subclass a promise
// ES6
class AngularPromise extends Promise {
constructor(executor) {
super((resolve, reject) => {
// before
return executor(resolve, reject);
// after
then(onFulfilled, onRejected) {
// before
const returnValue = super.then(onFulfilled, onRejected);
// after
return returnValue;
// ES5
function AngularPromise(executor) {
var p = new Promise(function (resolve, reject) {
// before
return executor(resolve, reject);
// after
p.__proto__ = AngularPromise.prototype;
return p;
AngularPromise.__proto__ = Promise;
AngularPromise.prototype.__proto__ = Promise.prototype;
AngularPromise.prototype.then = function then(onFulfilled, onRejected) {
// before
var returnValue =, onFulfilled, onRejected);
// after
return returnValue;
Copy link

rektide commented Dec 19, 2017

The absurd painful unexpected way this breaks is that you MUST:

  • Accept a function in the constructor
  • Call the function during the lifecycle of the super()

You can not create a Promise that doesn't need an executor passed in. You can't not call the executor. Anyone reasonably versed in extending classes would expect this code to work fine, but it doesnt:

class LifeUniverseEverythingPromise extends Promise{ constructor(){ super(resolve=> resolve(42)) }}

Although you'd expect that you are passing an valid executor to the super (Promise), there's additional magic the runtime is doing & checking. Trying to call .then on an instance of LifeUniverseEverythingPromise would result in: TypeError: Promise resolve or reject function is not callable.

Why? There's super special magic in the Promise spec that this normal, OK looking javascript class-extending does not satisfy. Promise magically demands the runtime track & check information that would not normally be available to the inner Promise implementation if it were a regular Javascript object.

So there are caveats to this gist. Big ones. It's not a base to start from & modify, it's a minimum possible execution path guide that you must adhere to. You can not deviate from this gist (aside from omitting .then), only add to it. I'd really like to see implementations where executor above does not need to be passed in, but alas, the spec has other things in mind. I don't fully understand the spec, but it is that demands this out-of-band context, this sniffing of the original constructor & determinancy of whether it has been executed. Numerous Node.js users have run into this issue already, if anyone is looking for more discussion around this very anomalous irregular limitation in extending a Class.

Copy link

eKoopmans commented Jan 24, 2018

Hey @rektide, today's you're lucky day! I've got an implementation where executor isn't required (using ES5 syntax). Check out the basic and more advanced versions. Tested and working in Chrome and Node, haven't tried other browsers yet.

Copy link

rektide commented Apr 14, 2019

@eKoopmans: my hope would be that we could have some interesting ways to extend Promise that used the extends keyword & class syntax. Alas.

None the less, good job with your hackery of Promise.

Copy link

oliverfoster commented Nov 16, 2019

Here's an example of a deferred promise, the constructor leverages defaults and might be close to what you wanted? @rektide

Copy link

Hashbrown777 commented May 18, 2021

@rektide here you go;

class YourPromise extends Promise {
	init = (resolve, reject) => {
		this.resolve = resolve;
		this.reject  = reject;
		this.init    = null;
		return this;
	constructor(callback, ...yourArgs) {
	static async create(...yourArgs) {
		let output;
		const initArgs = await new Promise((resolve) => {
			output = new YourPromise(
				(...initArgs) => { resolve(initArgs); },
		//return an array because JS is a dick and unrolls all nested promises with a single `await` keyword
		//INCLUDING the one we're deliberately trying to return AS A PROMISE (YourPromise extends Promise)
		return [output.init(...initArgs)];

Instantiate via (await YourPromise.create('your', 'arguments'))[0]

Here's a useful example of creating a Queue (TypeScript)

Copy link

Aleksandras-Novikovas commented Aug 17, 2021

@rektide, here is an implementation for deferred promise with class syntax:

class Deferred extends Promise {
/** @type {Function} /
* @type {Function} */


  • Creates new deferred promise.
  • To create defered object DO NOT pass executor parameter!!!
  • Parameter is only needed for Promise to work correctly.
  • Somehow Promise calls constructor twice. First time when you
  • create Promise. Second time - during first .then() with
  • different executor.
  • @param {undefined|null|Function} executor - DO NOT pass anything.
    constructor(executor) {
    let res;
    let rej;
    executor = executor ?? ((resolve, reject) => {
    res = resolve;
    rej = reject;
    if (res && rej) {
    this.#resolve = res;
    this.#reject = rej;

resolve(value) {

reject(err) {

You can test it with:
const d = new Deferred();

.then((val) => {
console.log(Resolved with ${val});
}, (err) => {
console.log(Rejected with ${err});

// d.reject("REJ");


Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment