Can We Forcefully Cancel Promises in JavaScript?

Promises: Can We Really Force Cancellation?

Promises, introduced in ES6, have transformed our approach to asynchronous programming. However, there are situations where we may need to intervene and forcibly cancel a promise, such as in the case of type-ahead search scenarios.

So, Can We Cancel a Promise?

In modern JavaScript, the harsh reality is: no. Promises do not currently support cancellation.

What Can We Do Instead?

Since direct promise cancellation is not an option, alternative approaches have emerged.

Use a Cancellation Token

A cancellation token is a mechanism that allows you to pass a cancelable variable into a function. When the token is called, it aborts the operation and rejects the associated promise. Here's an example:

function getWithCancel(url) { // token for cancellation
  var xhr = new XMLHttpRequest();
  xhr.open("GET", url);
  return new Promise(function(resolve, reject) {
    xhr.onload = function() { resolve(xhr.responseText); };
    token.cancel = function() {
      xhr.abort();
      reject(new Error("Cancelled"));
    };
    xhr.onerror = reject;
  });
}

With this approach, you can:

var token = {};
var promise = getWithCancel("/someUrl", token);

// later on:
token.cancel();

Use a Third-Party Library

Promising,"excuse the pun," libraries like Bluebird provide support for promise cancellation, along with other advanced features.

Adopt a Last-Invoke Pattern

This pattern ensures that only the last invocation of a function executes. It employs a token approach to cancel previous invocations:

function last(fn) {
  var lastToken = { cancel: function(){} };
  return function() {
    lastToken.cancel();
    var args = Array.prototype.slice.call(arguments);
    args.push(lastToken);
    return fn.apply(this, args);
  };
}

Usage:

var synced = last(getWithCancel);
synced("/url1?q=a"); // canceled
synced("/url1?q=ab"); // canceled
synced("/url1?q=abc"); // canceled
synced("/url1?q=abcd").then(function() {
  // only this will run
});

Conclusion

While it's disappointing that promises do not inherently support cancellation, the aforementioned techniques provide viable workarounds. As the language evolves, true promise cancellation may become a reality in the future.

The above is the detailed content of Can We Forcefully Cancel Promises in JavaScript?. For more information, please follow other related articles on the PHP Chinese website!