Eliminate Nested try…catch: Go‑Style Error Handling for Async/Await

Problem with nested try…catch

When several asynchronous operations are chained—e.g., fetching a user, then their posts, then comments—each step typically requires its own try...catch. This leads to repetitive boilerplate, deep nesting, and mixes success logic with error handling.

async function loadPageData(userId) {
  try {
    const user = await fetchUserById(userId);
    console.log('用户信息:', user.name);
    try {
      const posts = await fetchPostsByUserId(user.id);
      console.log('用户文章:', posts);
      try {
        const comments = await fetchCommentsForPosts(posts[0].id);
        console.log('文章评论:', comments);
      } catch (commentError) {
        console.error('获取评论失败:', commentError);
      }
    } catch (postError) {
      console.error('获取文章失败:', postError);
    }
  } catch (userError) {
    console.error('获取用户失败:', userError);
  }
}

Go‑style error handling in JavaScript

Go functions return a result and an error. We can mimic this pattern by creating a helper to that accepts a promise and always resolves to a two‑element array [error, data]. If the promise fulfills, the array is [null, data]; if it rejects, the array is [error, null].

If the promise resolves: [null, data] If the promise rejects:

[error, null]

Implementation of to

async function to(promise) {
  try {
    const data = await promise;
    return [null, data];
  } catch (err) {
    return [err, null];
  }
}

Refactoring examples

Simple function using to:

async function displayUser(userId) {
  const [userError, user] = await to(fetchUserById(userId));
  if (userError) {
    console.error('获取用户失败:', userError);
    return;
  }
  console.log('用户信息:', user.name);
}

Complex data‑loading routine without nested try...catch:

async function loadPageData(userId) {
  const [userError, user] = await to(fetchUserById(userId));
  if (userError) { console.error('获取用户失败:', userError); return; }

  const [postsError, posts] = await to(fetchPostsByUserId(user.id));
  if (postsError) { console.error('获取文章失败:', postsError); return; }

  const [commentsError, comments] = await to(fetchCommentsForPosts(posts[0].id));
  if (commentsError) { console.error('获取评论失败:', commentsError); return; }

  console.log('用户信息:', user.name);
  console.log('用户文章:', posts);
  console.log('文章评论:', comments);
}

Combining with Promise.all

async function loadDashboard(userId) {
  const [userError, userData] = await to(fetchUser(userId));
  const [settingsError, settingsData] = await to(fetchUserSettings(userId));

  if (userError) console.error('加载用户数据失败');
  if (settingsError) console.error('加载用户设置失败');

  if (userData) { /* use userData */ }
  if (settingsData) { /* use settingsData */ }
}

Advantages

Flat, readable code : No more nested try...catch structures.

Reduced boilerplate : Error handling is centralized in the to helper.

Forced error awareness : Destructuring const [error, data] makes developers confront possible errors.

Separation of concerns : Guard clauses handle errors early, leaving the happy path unobstructed.