Annuler la vanille, ECMAScript 6 Promesse de la chaîne d'

Est-il une méthode pour effacer le .thens de JavaScript Promesse exemple?

Pas. Pas dans ECMAScript 6 au moins. Promesses (et leurs then gestionnaires) sont uncancellable par défaut (malheureusement). Il y a un peu de discussion sur es-discuter (par exemple ici) sur la façon de faire de la bonne façon, mais quelle que soit l'approche va gagner, il ne sera pas terre dans l'ES6.

L'actuel point de vue est que sous-classement permettra de créer résiliable promesses à l'aide de votre propre mise en œuvre (je ne sais pas comment ça va marcher).

Jusqu'à ce que la langue comité a trouvé le meilleur moyen (ES7 heureusement?) vous pouvez toujours utiliser userland Promesse implémentations, dont beaucoup disposent d'annulation.

Discussion en cours est dans la https://github.com/domenic/cancelable-promise et https://github.com/bergus/promise-cancellation les courants d'air.

Je suis vraiment surpris que personne ne mentionne Promise.race comme un candidat pour cette:

const actualPromise = new Promise((resolve, reject) => { setTimeout(resolve, 10000) });
let cancel;
const cancelPromise = new Promise((resolve, reject) => {
cancel = reject.bind(null, { canceled: true })
})
const cancelablePromise = Object.assign(Promise.race([actualPromise, cancelPromise]), { cancel });

Il y a quelques mnp bibliothèques pour résiliable promesses.

1. p résiliables
   https://github.com/sindresorhus/p-cancelable

2. annulable-promesse
   https://github.com/alkemics/CancelablePromise

version simple:

juste donner le rejeter fonction.

function Sleep(ms,cancel_holder) {
return new Promise(function(resolve,reject){
var done=false; 
var t=setTimeout(function(){if(done)return;done=true;resolve();}, ms);
cancel_holder.cancel=function(){if(done)return;done=true;if(t)clearTimeout(t);reject();} 
})
}

un wraper solution (d'usine)

la solution que j'ai trouvé est de passer un cancel_holder objet. il aura une fonction de suppression. si il a une fonction de suppression puis il est annulable.

Cette fonction annuler rejette la promesse avec l'Erreur ("annulé").

Avant de résoudre, de rejeter ou d'on_cancel empêcher de la fonction annuler pour être appelé sans raison.

J'ai trouvé commode de passer à l'action d'annulation par injection

function cancelablePromise(cancel_holder,promise_fn,optional_external_cancel) {
if(!cancel_holder)cancel_holder={};
return new Promise( function(resolve,reject) {
var canceled=false;
var resolve2=function(){ if(canceled) return; canceled=true; delete cancel_holder.cancel; resolve.apply(this,arguments);}
var reject2=function(){ if(canceled) return; canceled=true; delete cancel_holder.cancel; reject.apply(this,arguments);}
var on_cancel={}
cancel_holder.cancel=function(){
if(canceled) return; canceled=true;
delete cancel_holder.cancel;
cancel_holder.canceled=true;
if(on_cancel.cancel)on_cancel.cancel();
if(optional_external_cancel)optional_external_cancel();
reject(new Error('canceled'));
};
return promise_fn.call(this,resolve2,reject2,on_cancel);        
});
}
function Sleep(ms,cancel_holder) {
return cancelablePromise(cancel_holder,function(resolve,reject,oncacnel){
var t=setTimeout(resolve, ms);
oncacnel.cancel=function(){if(t)clearTimeout(t);}     
})
}
let cancel_holder={};
//meanwhile in another place it can be canceled
setTimeout(function(){  if(cancel_holder.cancel)cancel_holder.cancel(); },500) 
Sleep(1000,cancel_holder).then(function() {
console.log('sleept well');
}, function(e) {
if(e.message!=='canceled') throw e;
console.log('sleep interrupted')
})

Voici notre mise en œuvre https://github.com/permettez-moi-de-construire/cancellable-promise

Utilisé comme

const {
cancellablePromise,
CancelToken,
CancelError
} = require('@permettezmoideconstruire/cancellable-promise')
const cancelToken = new CancelToken()
const initialPromise = SOMETHING_ASYNC()
const wrappedPromise = cancellablePromise(initialPromise, cancelToken)
//Somewhere, cancel the promise...
cancelToken.cancel()
//Then catch it
wrappedPromise
.then((res) => {
//Actual, usual fulfill
})
.catch((err) => {
if(err instanceOf CancelError) {
//Handle cancel error
}
//Handle actual, usual error
})

qui :

• Ne touche pas à la Promesse de l'API
• Laissez-nous faire davantage d'annulation à l'intérieur de catch appel
• Compter sur l'annulation rejeté au lieu de résolu contrairement à toute autre proposition ou la mise en œuvre

Tire et commentaires bienvenus

@Michael Yagudaev 's réponse qui fonctionne pour moi.

Mais la réponse originale à cette question n'est pas de la chaîne de la enveloppé promesse avec .catch() pour gérer les rejeter la manipulation, voici mon amélioration sur le dessus de @Michael Yagudaev réponse:

const makeCancelablePromise = promise => {
let hasCanceled = false;
const wrappedPromise = new Promise((resolve, reject) => {
promise
.then(val => (hasCanceled ? reject({ isCanceled: true }) : resolve(val)))
.catch(
error => (hasCanceled ? reject({ isCanceled: true }) : reject(error))
);
});
return {
promise: wrappedPromise,
cancel() {
hasCanceled = true;
}
};
};
//Example Usage:
const cancelablePromise = makeCancelable(
new Promise((rs, rj) => {
/*do something*/
})
);
cancelablePromise.promise.then(() => console.log('resolved')).catch(err => {
if (err.isCanceled) {
console.log('Wrapped promise canceled');
return;
}
console.log('Promise was not canceled but rejected due to errors: ', err);
});
cancelablePromise.cancel();

Essayer promesse-abortable: https://www.npmjs.com/package/promise-abortable

$ npm install promise-abortable

import AbortablePromise from "promise-abortable";
const timeout = new AbortablePromise((resolve, reject, signal) => {
setTimeout(reject, timeToLive, error);
signal.onabort = resolve;
});
Promise.resolve(fn()).then(() => {
timeout.abort();
});