Promise.try()

Syntax

Promise.try(func)
Promise.try(func, arg1)
Promise.try(func, arg1, arg2)
Promise.try(func, arg1, arg2, /* , */ argN)

Parameter

func

Eine Funktion, die synchron mit den bereitgestellten Argumenten (arg1, arg2, , argN) aufgerufen wird. Sie kann alles tun entweder einen Wert zurckgeben, einen Fehler werfen oder ein Promise zurckgeben.

arg1, arg2, , argN

Argumente, die an func bergeben werden.

Rckgabewert

Ein Promise, das:

• Bereits erfllt ist, wenn func synchron einen Wert zurckgibt.
• Bereits abgelehnt ist, wenn func synchron einen Fehler wirft.
• Asynchron erfllt oder abgelehnt ist, wenn func ein Promise zurckgibt.

Beschreibung

Mglicherweise haben Sie eine API, die einen Rckruf entgegennimmt. Der Rckruf kann synchron oder asynchron sein. Sie mchten alles einheitlich behandeln, indem Sie das Ergebnis in einem Promise verpacken. Der einfachste Weg wre mglicherweise Promise.resolve(func()). Das Problem ist, dass wenn func() synchron einen Fehler wirft, dieser Fehler nicht abgefangen und in ein abgelehntes Promise umgewandelt wird.

Der bliche Ansatz (das Heben eines Funktionsaufrufergebnisses in ein erflltes oder abgelehntes Promise) sieht oft so aus:

new Promise((resolve) => resolve(func()));

Aber Promise.try() ist hier hilfreicher:

Promise.try(func);

Fr den eingebauten Promise()-Konstruktor werden vom Executor geworfene Fehler automatisch abgefangen und in Ablehnungen umgewandelt, sodass diese beiden Anstze weitgehend gleichwertig sind, auer dass Promise.try() prgnanter und lesbarer ist.

Beachten Sie, dass Promise.try() nicht gleich diesem Ansatz ist, obwohl es ihm sehr hnlich ist:

Promise.resolve().then(func);

Der Unterschied besteht darin, dass der Rckruf, der an then() bergeben wird, immer asynchron aufgerufen wird, whrend der Executor des Promise()-Konstruktors synchron aufgerufen wird. Promise.try ruft die Funktion ebenfalls synchron auf und lst das Promise sofort auf, wenn mglich.

Promise.try(), kombiniert mit catch() und finally(), kann verwendet werden, um sowohl synchrone als auch asynchrone Fehler in einer einzigen Kette zu behandeln und das Fehlerhandling von Versprechen fast wie ein synchrones Fehlerhandling erscheinen zu lassen.

hnlich wie setTimeout() akzeptiert Promise.try() zustzliche Argumente, die an den Rckruf bergeben werden. Das bedeutet, dass anstatt dies zu tun:

Promise.try(() => func(arg1, arg2));

Sie knnen dies tun:

Promise.try(func, arg1, arg2);

Die sind gleichwertig, aber letzteres vermeidet die Erstellung eines zustzlichen Closures und ist effizienter.

Beispiele

Nutzung von Promise.try()

Das folgende Beispiel nimmt einen Rckruf entgegen, hebt ihn in ein Promise, behandelt das Ergebnis und fhrt etwas Fehlerbehandlung durch:

function doSomething(action) {
  return Promise.try(action)
    .then((result) => console.log(result))
    .catch((error) => console.error(error))
    .finally(() => console.log("Done"));
}

doSomething(() => "Sync result");

doSomething(() => {
  throw new Error("Sync error");
});

doSomething(async () => "Async result");

doSomething(async () => {
  throw new Error("Async error");
});

Bei async/await wrde derselbe Code so aussehen:

async function doSomething(action) {
  try {
    const result = await action();
    console.log(result);
  } catch (error) {
    console.error(error);
  } finally {
    console.log("Done");
  }
}

Aufruf von try() bei einem Nicht-Promise-Konstruktor

Promise.try() ist eine generische Methode. Sie kann auf einen beliebigen Konstruktor aufgerufen werden, der dieselbe Signatur wie der Promise()-Konstruktor implementiert.

Das folgende Beispiel ist eine etwas genauere Annherung an das tatschliche Promise.try() (es sollte dennoch nicht als Polyfill verwendet werden):

Promise.try = function (func) {
  return new this((resolve, reject) => {
    try {
      resolve(func());
    } catch (error) {
      reject(error);
    }
  });
};

Aufgrund der Implementierung von Promise.try() (d.h. durch try...catch) knnen wir Promise.try() sicher mit seinem this auf einen beliebigen benutzerdefinierten Konstruktor aufrufen, und es wird niemals synchron einen Fehler werfen.

class NotPromise {
  constructor(executor) {
    // The "resolve" and "reject" functions behave nothing like the native
    // promise's, but Promise.try() just calls resolve
    executor(
      (value) => console.log("Resolved", value),
      (reason) => console.log("Rejected", reason),
    );
  }
}

const p = Promise.try.call(NotPromise, () => "hello");
// Logs: Resolved hello

const p2 = Promise.try.call(NotPromise, () => {
  throw new Error("oops");
});
// Logs: Rejected Error: oops

Im Gegensatz zu Promise() behandelt dieser NotPromise()-Konstruktor nicht elegant Ausnahmen, whrend er den Executor ausfhrt. Aber trotz des throw fngt Promise.try() die Ausnahme immer noch ab und bergibt sie an reject(), um sie zu protokollieren.

Spezifikationen

Browser-Kompatibilitt

Siehe auch

• Polyfill von Promise.try in core-js
• es-shims Polyfill von Promise.try
• Verwendung von Versprechen Leitfaden
• Promise
• Promise()-Konstruktor