Promise.try() — Methode · JavaScript-Referenz

Signatur

Promise.try(func, ...args)

Beschreibung

Promise.try() ruft die übergebene Funktion sofort und synchron auf und gibt immer ein Promise zurück. Gibt die Funktion einen normalen Wert zurück, wird das Promise damit erfüllt. Gibt sie ein Promise oder Thenable zurück, übernimmt das Ergebnis dessen Zustand. Wirft sie eine Ausnahme, wird das Promise damit abgelehnt. Die Ausnahme erreicht den Aufrufer also nicht direkt.

Die Methode ist nützlich, wenn nicht klar ist, ob eine Funktion synchron oder asynchron arbeitet, etwa bei Callbacks von außen, Plugin-Schnittstellen oder Funktionen, die vor ihrem ersten await Eingaben prüfen und dabei werfen können. Mit Promise.try() reicht eine einzige Fehlerbehandlung über .catch() bzw. try/catch mit await. Ein zusätzliches synchrones try/catch ist nicht nötig.

Im Unterschied zu Promise.resolve().then(func) läuft func nicht erst in einem späteren Mikrotask, sondern sofort. Anders als new Promise((resolve) => resolve(func())) ist der Code kürzer, und zusätzliche Argumente lassen sich direkt weitergeben: Promise.try(func, a, b).

Parameter

Name	Typ	Default	Beschreibung
$func Pflicht	Function		Die Funktion, die sofort mit den Argumenten aus `args` aufgerufen wird. Sie darf einen Wert oder ein Promise zurückgeben oder eine Ausnahme werfen.
$...args	any[]		Beliebig viele Argumente, die unverändert an `func` weitergegeben werden.

Rückgabewert

Typ

Promise<any>

Beschreibung

Ein Promise, das

mit dem Rückgabewert von func erfüllt wird,
den Zustand eines zurückgegebenen Promises bzw. Thenables übernimmt,
abgelehnt wird, wenn func synchron eine Ausnahme wirft.

Beispiele

Synchrone Ausnahmen in eine Ablehnung umwandeln

const parseConfig = (text) => JSON.parse(text); // wirft bei ungültigem JSON

Promise.try(parseConfig, '{"debug": true}')
  .then((cfg) => console.log('OK:', cfg.debug));

Promise.try(parseConfig, '{kaputt')
  .catch((err) => console.log('Fehler:', err.name));

OK: true Fehler: SyntaxError

Einheitliche Behandlung von synchronen und asynchronen Callbacks

// Ein Cache liefert synchron, das Netzwerk asynchron
const cache = new Map([['user:1', { id: 1, name: 'Anna' }]]);

const loadUser = (id) => {
  if (typeof id !== 'number') throw new TypeError('id muss eine Zahl sein');
  const key = `user:${id}`;
  if (cache.has(key)) return cache.get(key); // synchron
  return new Promise((resolve) =>
    setTimeout(() => resolve({ id, name: 'Aus dem Netz' }), 100)
  ); // asynchron
};

const run = async () => {
  for (const id of [1, 2, 'x']) {
    try {
      const user = await Promise.try(loadUser, id);
      console.log(user.name);
    } catch (err) {
      console.log('Abgelehnt:', err.message);
    }
  }
};

run();

Anna Aus dem Netz Abgelehnt: id muss eine Zahl sein

Callback läuft sofort – anders als Promise.resolve().then()

console.log('1: Start');

Promise.try(() => console.log('2: Promise.try läuft sofort'));
Promise.resolve().then(() => console.log('4: then läuft im Mikrotask'));

console.log('3: Ende des synchronen Codes');

1: Start 2: Promise.try läuft sofort 3: Ende des synchronen Codes 4: then läuft im Mikrotask

Plugin-Hooks sicher ausführen

const plugins = [
  { name: 'sync', init: () => 'bereit' },
  { name: 'async', init: async () => 'geladen' },
  { name: 'defekt', init: () => { throw new Error('Init fehlgeschlagen'); } },
];

const results = await Promise.allSettled(
  plugins.map((p) => Promise.try(p.init))
);

results.forEach((r, i) =>
  console.log(plugins[i].name, r.status, r.value ?? r.reason.message)
);

sync fulfilled bereit async fulfilled geladen defekt rejected Init fehlgeschlagen

// Wichtig · Fallstricke

Kompatibilität: Die Methode ist relativ neu (ES2025): Chrome/Edge 128+, Firefox 134+, Safari 18.2+, Node.js 23+ (in Node.js 22 nur mit einem Flag). Für ältere Umgebungen bietet sich ein Polyfill an (z. B. core-js) oder der Ersatz new Promise((resolve) => resolve(func(...args))).
Kein Zeitverzug: func läuft sofort und synchron. Wer die Ausführung bewusst in einen Mikrotask verschieben will, sollte Promise.resolve().then(func) oder queueMicrotask() verwenden.
Funktion übergeben, nicht ihren Aufruf: Promise.try(fn()) ist falsch. Dabei läuft fn schon vorher, und eine Ausnahme wird nicht abgefangen. Richtig ist Promise.try(fn) oder Promise.try(fn, arg).
this-Bindung: func wird ohne this aufgerufen. Bei Methoden also Promise.try(() => obj.method()) oder obj.method.bind(obj) verwenden.
Unbehandelte Ablehnungen lösen weiterhin unhandledrejection aus. Deshalb immer .catch() anhängen oder das Ergebnis mit await in einem try/catch abfangen.
Wie andere statische Promise-Methoden kann Promise.try auf Unterklassen aufgerufen werden (MyPromise.try()) und liefert dann eine Instanz dieser Unterklasse.

Siehe auch

Promise Promise.resolve() Promise.reject() Promise.prototype.then() Promise.prototype.catch() async function await