Hey there! Great question—you’re already on the right track using patterns like await-to-js to avoid cluttering your code with try/catch blocks. Let’s break down solutions for your specific pain points step by step:

First: A Quick Recap of the Error-Wrapping Pattern #

If you don’t want to rely on the await-to-js package, you can easily implement your own tiny wrapper function that does the same thing: converts a Promise’s resolve/reject into an [error, result] array. This is the core of avoiding try/catch:

const to = (promise) => {
  return promise
    .then(result => [null, result])
    .catch(error => [error, null]);
};

You’ll use this with await in async functions like so:

async function fetchData() {
  const [err, data] = await to(fetch("/api/data"));
  if (err) {
    console.error("Fetch failed:", err);
    return; // Exit early on error
  }
  console.log("Data received:", data);
}

Using the Pattern in Non-Async Functions #

The catch here is: await only works inside async functions. So if you’re stuck in a non-async context, you have two solid options:

Option 1: Wrap Your Logic in an Async Function (Recommended) #

Just encapsulate the async/await logic in an async function, then call it from your non-async code. You can add a top-level catch for any unhandled errors:

async function asyncWorkflow() {
  const [fetchErr, data] = await to(fetch("/api/data"));
  if (fetchErr) throw new Error(`Fetch failed: ${fetchErr}`);

  const [processErr, processedData] = await to(processData(data));
  if (processErr) throw new Error(`Processing failed: ${processErr}`);

  return processedData;
}

// Non-async function calling the async workflow
function nonAsyncWrapper() {
  asyncWorkflow()
    .then(result => console.log("Final result:", result))
    .catch(err => console.error("Workflow failed:", err));
}

Option 2: Use Promise Chaining (No await Needed) #

If you really don’t want to use an async function, you can chain .then() calls with the to function. It’s less readable than async/await, but it works:

function nonAsyncChain() {
  to(fetch("/api/data"))
    .then(([fetchErr, data]) => {
      if (fetchErr) {
        console.error("Fetch failed:", fetchErr);
        return Promise.reject(fetchErr); // Propagate error if needed
      }
      return to(processData(data)); // Pass to next async task
    })
    .then(([processErr, processedData]) => {
      if (processErr) {
        console.error("Processing failed:", processErr);
        return;
      }
      console.log("Final result:", processedData);
    })
    .catch(finalErr => console.error("Chain failed:", finalErr));
}

Chaining Multiple Async/Await Calls Gracefully #

The beauty of the [err, result] pattern is that it lets you handle errors at each step while keeping your code linear (no nested chains). Here’s how to chain multiple async tasks cleanly:

async function chainedTasks() {
  // Step 1: Fetch raw data
  const [fetchErr, rawData] = await to(fetch("/api/raw"));
  if (fetchErr) {
    console.error("Fetch raw failed:", fetchErr);
    return null;
  }

  // Step 2: Process the data
  const [processErr, processedData] = await to(transformData(rawData));
  if (processErr) {
    console.error("Transform failed:", processErr);
    return null;
  }

  // Step 3: Save the processed data
  const [saveErr, saveResult] = await to(saveToDB(processedData));
  if (saveErr) {
    console.error("Save failed:", saveErr);
    return null;
  }

  return saveResult; // Return final success result
}

If you want to handle errors in a centralized way instead of per-step, you could still wrap the entire chain in a single try/catch—but you said you want to avoid that, so per-step checks are the way to go.

What About "Without ES6 Promises"? #

Quick reality check: Async/await is built on top of ES6 Promises. You can’t use async/await without Promises. However, you don’t need to manually write new Promise() yourself. Most modern async APIs (like Node.js’s fs.promises, browser fetch, or libraries like Axios) already return Promises. If you’re working with old callback-based APIs, you can convert them to Promises using Node.js’s util.promisify or a simple wrapper:

// Convert a callback-based function to return a Promise
const callbackToPromise = (fn) => (...args) => {
  return new Promise((resolve, reject) => {
    fn(...args, (err, result) => {
      if (err) reject(err);
      else resolve(result);
    });
  });
};

// Example: Convert Node.js's old fs.readFile callback to Promise
const fs = require('fs');
const readFile = callbackToPromise(fs.readFile);

// Now use it with our `to` function
async function readMyFile() {
  const [err, content] = await to(readFile('./my-file.txt', 'utf8'));
  if (err) console.error("Read failed:", err);
  else console.log("File content:", content);
}

Final Tips #

• Stick with async functions wherever possible—they make async code far more readable than Promise chains.
• If you find yourself repeating error-handling logic, extract it into a reusable function (e.g., handleError(err)) to keep your code DRY.
• Remember that the [err, result] pattern is just a convention—you can adjust it to fit your needs (e.g., return an object like { error, data } if arrays feel awkward).

内容的提问来源于stack exchange，提问作者Ivan Drenjanin