So fügen Sie in JS eine Abbruchfunktion zu einem Versprechen hinzu

let PromiseWithAbort = Funktion(Versprechen){
    lass _abort = null;
    lass Pabort = neues Versprechen((res,rej)=>{
      _abort = Funktion(Grund ='abbrechen !'){
        konsole.warnen(Grund);
        rej (Grund);
      }
    });

    lass Rennen = Promise.race([Versprechen,Pabort]);
    Rennen.abbrechen = _abbrechen;
    console.log(Versprechen,Pabort);
    Rückrennen;
  }

lass p1 = neues Versprechen(res=>{
   setzeTimeout(()=>{
      res('p1 Erfolg');
   },2000)
})

Lassen Sie testP = PromiseWithAbort(p1);

testP.dann(res=>{
  console.log('Erfolg:',res);
},Fehler=>{
  console.log('Fehler:',Fehler);
})

testP.abort();

// Ergebnis: Ablehnen: Abbrechen!

Klasse PromiseWithAbort {
    Konstruktor(fn){
      lass _abort = null;
      lass _p = neues Versprechen((res,rej)=>{
        fn.call(null,res,rej);
        _abort = Funktion(Fehler='abort'){ rej(Fehler); }
      })

      _p.abort = _abort;
      gibt _p zurück;
    }
  } 


lass testP = neues PromiseWithAbort((res,rej)=>{
    setzeTimeout(() => {
      Ergebnis(1);
    },1000);
  });

 testP.dann(r=>{
    Konsole.log('res:',r);
  },r=>{
    Konsole.log('rej:',r);
  });

  testP.abort();
//Ergebnis: rej: Abbruch

// Abrufanforderung unterbrechen let controller = new AbortController();
  lass signal = controller.signal;

 holen('https://developer.mozilla.org/zh-CN/docs/Web/JavaScript/Reference/Global_Objects/Promise/finally',{signal}).dann(r=>{
    konsole.log(r);
  });

  controller.abort();
// Ergebnis: Nicht abgefangene (im Versprechen) DOMException: Der Benutzer hat eine Anfrage abgebrochen.
//Ein Versprechen unterbrechen
Klasse PromiseWithAbortController {
  Konstruktor(fn,{signal}){
    wenn (Signal && Signal.abgebrochen) {
      return Promise.reject(neue DOMException('Abgebrochen','AbortError'));
    }

    let _p = neues Versprechen((lösen,ablehnen)=>{
      fn.call(null,auflösen,ablehnen);
      wenn(Signal){
        signal.addEventListener('abbrechen',()=>{
          ablehnen(neue DOMException('Abgebrochen','Abbruchfehler'));
        })
      }
    });

    gibt _p zurück;
  }
}
let controller = neuer AbortController();
  lass signal = controller.signal;
lass testP2 = neuer PromiseWithAbortController((r,j)=>{
  setzeTimeout(() => {
    r('Erfolg');
  }, 1000);
},{Signal});

testP2.then(r=>{
    Konsole.log('res:',r);
  },r=>{
    Konsole.log('rej:',r);
  });

  controller.abort();
  // Ergebnis: rej: DOMException: Abgebrochen

//1. Quelltoken verwenden
const CancelToken = axios.CancelToken;
const Quelle = CancelToken.source();

axios.get('/Benutzer/12345', {
  cancelToken: Quelle.Token
}).catch(Funktion (geworfen) {
  wenn (axios.isCancel(geworfen)) {
    console.log('Anfrage abgebrochen', thrown.message);
  } anders {
    // Fehler behandeln
  }
});

axios.post('/Benutzer/12345', {
  Name: „Neuer Name“
}, {
  cancelToken: Quelle.Token
})

// Anfrage abbrechen (der Nachrichtenparameter ist optional)
source.cancel('Vorgang vom Benutzer abgebrochen.');

//2. Durch die ausgehende Funktion
const CancelToken = axios.CancelToken;
abbrechen lassen;

axios.get('/Benutzer/12345', {
  cancelToken: neues CancelToken(Funktion Executor(c) {
    // Eine Executor-Funktion erhält eine Abbruchfunktion als Parameter
    abbrechen = c;
  })
});

// die Anfrage abbrechen
stornieren();

//Main: Anfragen mit demselben Token können gemeinsam storniert werden