Kündigen Sie eine Vanilla ECMAScript 6 Promise-Kette

In ES6 gibt es keine Standardmethode, aber es gibt eine Bibliothek namens Bluebird , um dies zu handhaben.

Es gibt auch einen empfohlenen Weg, der als Teil der Reaktordokumentation beschrieben wird. Es sieht ähnlich aus, was Sie in Ihren 2. und 3. Updates haben.

const makeCancelable = (promise) => {
  let hasCanceled_ = false;

  const wrappedPromise = new Promise((resolve, reject) => {
    promise.then((val) =>
      hasCanceled_ ? reject({isCanceled: true}) : resolve(val)
    );
    promise.catch((error) =>
      hasCanceled_ ? reject({isCanceled: true}) : reject(error)
    );
  });

  return {
    promise: wrappedPromise,
    cancel() {
      hasCanceled_ = true;
    },
  };
};

const cancelablePromise = makeCancelable(
  new Promise(r => component.setState({...}}))
);

cancelablePromise
  .promise
  .then(() => console.log('resolved'))
  .catch((reason) => console.log('isCanceled', reason.isCanceled));

cancelablePromise.cancel(); // Cancel the promise

Entnommen aus: https://facebook.github.io/react/blog/2015/12/16/ismounted-antipattern.html

const makeCancelable = promise => {
    let rejectFn;

    const wrappedPromise = new Promise((resolve, reject) => {
        rejectFn = reject;

        Promise.resolve(promise)
            .then(resolve)
            .catch(reject);
    });

    wrappedPromise.cancel = () => {
        rejectFn({ canceled: true });
    };

    return wrappedPromise;
};

Verwendungszweck:

const cancelablePromise = makeCancelable(myPromise);
// ...
cancelablePromise.cancel();

Ich bin wirklich überrascht, dass niemand Promise.race als Kandidaten für dieses Thema erwähnt:

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 });

Es gibt ein paar npm-Bibliotheken für kündbare Versprechen.

1. p-cancelablehttps://github.com/sindresorhus/p-cancelable

2. cancelable-promisehttps://github.com/alkemics/CancelablePromise

Es ist tatsächlich unmöglich, die Ausführung des Versprechens zu stoppen, aber Sie können die Ablehnung entführen und sie aus dem Versprechen selbst aufrufen.

class CancelablePromise {
  constructor(executor) {
    let _reject = null;
    const cancelablePromise = new Promise((resolve, reject) => {
      _reject = reject;
      return executor(resolve, reject);
    });
    cancelablePromise.cancel = _reject;

    return cancelablePromise;
  }
}

Verwendungszweck:

const p = new CancelablePromise((resolve, reject) => {
  setTimeout(() => {
    console.log('resolved!');
    resolve();
  }, 2000);
})

p.catch(console.log);

setTimeout(() => {
  p.cancel(new Error('Fucked up!'));
}, 1000);

einfache Version :

geben Sie einfach die Ablehnungsfunktion aus.

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();} 
 })
}

eine Wrapperlösung (Fabrik)

die Lösung, die ich gefunden habe, besteht darin, ein cancel_holder-Objekt zu übergeben. es wird eine Abbruchfunktion haben. Wenn es eine Abbruchfunktion hat, kann es abgebrochen werden.

Diese Abbruchfunktion lehnt das Versprechen mit Fehler ab ('storniert').

Bevor auflösen, ablehnen oder on_cancel verhindern, dass die Abbruchfunktion ohne Grund aufgerufen wird.

Ich habe es als zweckmäßig erachtet, die Abbruchaktion durch Injektion zu übergeben

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')
})

Hier ist unsere Implementierung https://github.com/permettez-moi-de-construire/cancellable-promise

Verwendet wie

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
})

welche :

• Berührt die Promise-API nicht
• Lassen Sie uns eine weitere Kündigung innerhalb des Aufrufs catch vornehmen
• Verlassen Sie sich darauf, dass die Annullierung abgelehnt statt gelöst ist, anders als bei anderen Vorschlägen oder Implementierungen

Zieht und kommentiert willkommen

Versuchen Sie Promise-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();
});

Wenn Sie verhindern möchten, dass alle Zwischenfälle/Fänge ausgeführt werden, können Sie dies tun, indem Sie ein Versprechen einreichen, das niemals gelöst wird. Es hat wahrscheinlich Speicherlecks, aber das Problem wird dadurch behoben, und es sollte in den meisten Anwendungen nicht zu viel Speicherplatz verschwendet werden.

new Promise((resolve, reject) => {
    console.log('first chain link executed')
    resolve('daniel');
}).then(name => {
    console.log('second chain link executed')
    if (name === 'daniel') {
        // I don't want to continue the chain, return a new promise
        // that never calls its resolve function
        return new Promise((resolve, reject) => {
            console.log('unresolved promise executed')
        });
    }
}).then(() => console.log('last chain link executed'))

// VM492:2 first chain link executed
// VM492:5 second chain link executed
// VM492:8 unresolved promise executed

@Michael Yagudaevs Antwort funktioniert für mich.

Aber die ursprüngliche Antwort verkettete das umwickelte Versprechen nicht mit .catch (), um die Zurückweisung zu behandeln. Hier ist meine Verbesserung zusätzlich zu @Michael Yagudaevs Antwort:

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();

Legen Sie im Promise eine "stornierte" Eigenschaft fest, um zu signalisieren, dass then() und catch() vorzeitig beendet werden. Dies ist besonders effektiv bei Web Workern, bei denen bereits vorhandene Mikrotasks in Promises von onmessage-Handlern in die Warteschlange gestellt werden.

// Queue task to resolve Promise after the end of this script
const promise = new Promise(resolve => setTimeout(resolve))

promise.then(_ => {
  if (promise.canceled) {
    log('Promise cancelled.  Exiting early...');
    return;
  }

  log('No cancelation signaled.  Continue...');
})

promise.canceled = true;

function log(msg) {
  document.body.innerHTML = msg;
}

Wenn p eine Variable ist, die ein Versprechen enthält, sollte p.then(empty); das Versprechen verwerfen, wenn es eventuell abgeschlossen ist oder bereits abgeschlossen ist (ja, ich weiß, dass dies nicht die ursprüngliche Frage ist, aber es ist meine Frage). "leer" ist function empty() {}. Ich bin nur ein Anfänger und wahrscheinlich falsch, aber diese anderen Antworten erscheinen zu kompliziert. Versprechen sollen einfach sein.