Detaillierte Erläuterung mehrerer Lösungen für JavaScript-Unterbrechungsanforderungen

neues Versprechen((lösen, ablehnen) => {
    setzeTimeout(() => {
        lösen('Ergebnis');
    });
}).dann(res => {
    // Wenn eine bestimmte Bedingung erfüllt ist, gib eine ausstehende Promise-Instanz zurück, um die Aufrufkette zu unterbrechen, if (res === 'result') {
        gib ein neues Promise zurück(() => {});
    }
    console.log(res); // kein Drucken }).then(() => {
    console.log('dann wird es nicht ausgeführt'); // kein Drucken}).catch(() => {
    console.log('catch nicht ausgeführt'); // kein Drucken}).finally(() => {
    console.log('schließlich nicht ausgeführt'); // kein Drucken});

const request = neues Versprechen((lösen, ablehnen) => {
  setzeTimeout(() => {
    resolve('Serverdaten empfangen')
  }, Math.random() * 3000)
})

const timeoutReject = (p1, timeout = 2000) => {
    const p2 = neues Versprechen((lösen, ablehnen) => {
        setzeTimeout(() => {
            ablehnen('Netzwerk-Timeout');
        }, Zeitüberschreitung);
    });
    gibt Promise.race([p1, p2]) zurück;
};

timeoutReject(Anfrage).dann(res => {
    konsole.log(res);
}).catch(err => {
    console.log(fehler);
});

Funktion abortWrapper(p1) {
    abbrechen lassen;
    const p2 = neues Versprechen((lösen, ablehnen) => {
        Abbrechen = ablehnen;
    });
    // Wenn keine Lösung oder Ablehnung erfolgt, ist der Status von p2 immer „Ausstehend“
    const p = Promise.race([p1, p2]);
    p.abort = abbrechen;
    Rückgabe p;
}

const req = abortWrapper(Anfrage);
req.then(res => {
    konsole.log(res);
}).catch(err => {
    console.log(fehler);
});

setzeTimeout(() => {
    // Rufen Sie req.abort manuell auf, um den Status von p2 auf „abgelehnt“ zu ändern
    req.abort('manuelle Abbruchanforderung');
}, 2000);

let stream1$ = neues Observable(Beobachter => {
    let timeout = setTimeout(() => {
        Beobachter.next('beobachtbares Timeout');
    }, 2000);

    zurückgeben () => {
        Zeitüberschreitung löschen (Zeitüberschreitung);
    }
});
let disposable = stream1$.subscribe(Wert => console.log(Wert));
setzeTimeout(() => {
    Einweg.Abbestellen();
}, 1000);

importiere Axios von „Axios“;
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
  } 
});

source.cancel('Vorgang vom Benutzer abgebrochen.');

importiere Axios von „Axios“;
const CancelToken = axios.CancelToken;

// Erstellen Sie eine Variable wie „cancel“, um die Methode zum Unterbrechen einer Anforderung zu speichern. let cancel;

axios.get('/Benutzer/12345', {
  cancelToken: neues CancelToken(Funktion Executor(c) {
    cancel = c; // Parameter c zum Abbrechen zuweisen
  })
});

// Bestimmen Sie, ob „Abbrechen“ eine Funktion ist und stellen Sie sicher, dass Axios ein CancelToken instanziiert hat.
wenn (Typ von Abbrechen === 'Funktion') {
    stornieren();
    abbrechen = null;
}

„streng verwenden“;

var Abbrechen = erfordern('./Abbrechen');

/**
 * Ein „CancelToken“ ist ein Objekt, mit dem die Stornierung einer Operation angefordert werden kann.
 *
 * @Klasse
 * @param {Function} executor Die Executor-Funktion.
 */
Funktion CancelToken(Executor) {
  wenn (Typ des Executors !== 'Funktion') {
    throw new TypeError('Executor muss eine Funktion sein.');
  }

  var lösenPromise;
  this.promise = neues Versprechen (Funktion promiseExecutor(resolve) {
    resolvePromise = lösen;
  });

  var token = dies;
  Executor (Funktion Abbrechen (Nachricht) {
    wenn (Token.Grund) {
      // Stornierung wurde bereits beantragt
      zurückkehren;
    }

    token.reason = neue Abbrechen(Nachricht);
    Versprechen auflösen(token.reason);
  });
}

/**
 * Löst eine „Abbrechen“-Meldung aus, wenn eine Stornierung angefordert wurde.
 */
CancelToken.prototype.throwIfRequested = Funktion throwIfRequested() {
  wenn (dieser.Grund) {
    wirf diesen.Grund;
  }
};

/**
 * Gibt ein Objekt zurück, das ein neues „CancelToken“ und eine Funktion enthält, die, wenn sie aufgerufen wird,
 * storniert den „CancelToken“.
 */
CancelToken.source = Funktion Quelle() {
  var abbrechen;
  var token = neues CancelToken(Funktion Executor(c) {
    abbrechen = c;
  });
  zurückkehren {
    Zeichen: Zeichen,
    abbrechen: abbrechen
  };
};

module.exports = Token abbrechen;

wenn (config.cancelToken) {
  // Abbruch behandeln
  config.cancelToken.promise.then(Funktion beiAbgebrochen(Abbrechen) {
    wenn (!Anfrage) {
      zurückkehren;
    }

    Anfrage.Abbrechen();
    ablehnen (abbrechen);
    // Anfrage bereinigen
    Anfrage = null;
  });
}