JavaScript is getting a new Promise utility that makes handling potentially async functions cleaner and safer. Promise.try lets you wrap any function in a Promise, whether it’s async or not, while maintaining optimal execution timing.

The Core Problem

Handling functions that might be sync or async requires mixing different error handling patterns:

1
function getUserData(id) {
2
  // We need try/catch for sync errors
3
  try {
4
    validateId(id);
5

6
    // Might return cached data synchronously
7
    if (id in cache) {
8
      return cache[id];
9
    }
10

11
    // Might return a Promise
12
    return fetch(`/api/users/${id}`);
13
  } catch (syncError) {
14
    handleSyncError(syncError);
15
  }
16
}

The problem? You never know which behavior you’ll get. Currently, there are two common ways to handle this, but neither is ideal:

1
// Method 1: Using Promise.resolve().then()
2
Promise.resolve().then(() => getUserData(123));
3
// ❌ Forces everything to be async
4
// ❌ Even cached data waits for the next tick
5
// ✓ But at least it catches errors
6

7
// Method 2: Using new Promise
8
new Promise(resolve => resolve(getUserData(123)));
9
// ❌ Verbose and clunky
10
// ❌ Easy to get wrong
11
// ✓ Runs sync code immediately

We need a better way to:

• Run synchronous code immediately (for better performance)
• Handle asynchronous code when needed
• Catch any errors that might occur
• Do all this with clean, readable syntax

The Solution: Promise.try

Promise.try gives us one clean way to handle all cases:

1
// Clean, safe, and optimal timing
2
Promise.try(() => getUserData(123))
3
  .then(user => {
4
    // Gets called with:
5
    // - Immediate values (from cache)
6
    // - Resolved Promise values (from fetch)
7
  })
8
  .catch(error => {
9
    // Catches both:
10
    // - Synchronous throws
11
    // - Promise rejections
12
  });

Why It’s Better

Promise.try has three key advantages:

1
// 1. Runs synchronously when possible
2
Promise.try(() => "instant") // Executes immediately
3
  .then(x => console.log(x));
4

5
// 2. Catches all errors reliably
6
Promise.try(() => {
7
  throw new Error('boom');
8
})
9
  .catch(err => console.log('Caught:', err));
10

11
// 3. Handles both sync and async naturally
12
Promise.try(() => {
13
  if (Math.random() > 0.5) {
14
    return "sync value";
15
  }
16
  return fetch('/api/data');
17
});

Promise.try runs synchronous code immediately for better performance, while still handling async operations when needed. It catches every type of error through a single catch handler, and does it all with clean, readable syntax. Think of it as the Promise equivalent of a try-catch block - a safe way to execute code that might fail or might be async, without having to know which it is ahead of time.

This is particularly powerful when working with functions that might change their behavior over time. Your error handling remains consistent whether the function returns immediately or needs to make an API call. No more wrapping everything in try-catch blocks and then also handling Promise rejections separately.

References

• https://tc39.es/ecma262/#sec-promise.try
• https://tc39.es/proposal-promise-try/
• https://github.com/tc39/proposal-promise-try