在 JavaScript 的世界里，Promise 一直是处理异步操作的神器。

而现在，随着 ES2025 的发布，Promise 又迎来了一个超实用的新成员——Promise.try()！

这个新方法简直是对异步编程的一次“革命”，让我们来看看它是怎么让代码变得更简单、更优雅的！

什么是 Promise.try()？

简单来说，Promise.try() 是一个静态方法，它能把任何函数（同步的、异步的、返回值的、抛异常的）包装成一个 Promise。无论这个函数是同步还是异步，Promise.try() 都能轻松搞定，还能自动捕获同步异常，避免错误遗漏。

语法

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

参数

• func：要包装的函数，可以是同步的，也可以是异步的。
• arg1、arg2、…、argN：传给 func 的参数。

返回值

一个 Promise，可能的状态有：

• 如果 func 同步返回一个值，Promise 就是已兑现的。
• 如果 func 同步抛出一个错误，Promise 就是已拒绝的。
• 如果 func 返回一个 Promise，那就按这个 Promise 的状态来。

为什么需要 Promise.try()？

在实际开发中，我们经常遇到一种情况：不知道或者不想区分函数是同步还是异步，但又想用 Promise 来处理它。

以前，我们可能会用 Promise.resolve().then(f)，但这会让同步函数变成异步执行，有点不太理想。

const f = () => console.log('now');
Promise.resolve().then(f);
console.log('next');
// next
// now

上面的代码中，函数 f 是同步的，但用 Promise 包装后，它变成了异步执行。

有没有一种方法，让同步函数同步执行，异步函数异步执行，并且让它们具有统一的 API 呢？

答案是可以的，并且 Promise.try() 就是这个方法！

怎么用 Promise.try()？

示例 1：处理同步函数

const syncFunction = () => {
  console.log('同步函数执行中');
  return '同步的结果';
};

Promise.try(syncFunction)
  .then(result => console.log(result)) // 输出：同步的结果
  .catch(error => console.error(error));

示例 2：处理异步函数

const asyncFunction = () => {
returnnewPromise(resolve => {
    setTimeout(() => {
      resolve('异步的结果');
    }, 1000);
  });
};

Promise.try(asyncFunction)
  .then(result =>console.log(result)) // 1秒后输出：异步的结果
  .catch(error =>console.error(error));

示例 3：处理可能抛出异常的函数

const errorFunction = () => {
  throw new Error('同步的错误');
};

Promise.try(errorFunction)
  .then(result => console.log(result))
  .catch(error => console.error(error.message)); // 输出：同步的错误

Promise.try()的优势

1. 统一处理同步和异步函数：不管函数是同步还是异步，Promise.try() 都能轻松搞定，代码更简洁。
2. 异常处理：自动捕获同步异常，错误处理更直观，避免遗漏。
3. 代码简洁：相比传统方法，Promise.try() 让代码更易读易维护。

实际应用场景

场景 1：统一处理 API 请求

function fetchData(url) {
  return Promise.try(() => fetch(url))
    .then(response => response.json())
    .catch(error => console.error('请求失败:', error));
}

fetchData('https://api.example.com/data')
  .then(data => console.log('数据:', data));

场景 2：混合同步和异步操作

const syncTask = () => '同步任务完成';
const asyncTask = () => new Promise(resolve => setTimeout(() => resolve('异步任务完成'), 1000));

Promise.try(syncTask)
  .then(result => console.log(result)) // 输出：同步任务完成
  .then(() => Promise.try(asyncTask))
  .then(result => console.log(result)) // 1秒后输出：异步任务完成
  .catch(error => console.error(error));

场景 3：处理数据库查询

function getUser(userId) {
  return Promise.try(() => database.users.get({ id: userId }))
    .then(user => user.name)
    .catch(error => console.error('数据库查询失败:', error));
}

getUser('123')
  .then(name => console.log('用户名称:', name));

场景 4：处理文件读取

function readFile(path) {
  return Promise.try(() => fs.readFileSync(path, 'utf8'))
    .catch(error => console.error('文件读取失败:', error));
}

readFile('example.txt')
  .then(content => console.log('文件内容:', content));

总结

Promise.try() 的引入让异步编程变得更加简单和优雅。

它统一了同步和异步函数的处理方式，简化了错误处理，让代码更易读易维护。ES2025 的这个新特性，绝对值得你去尝试！快去试试吧，你的代码会变得更清晰、更强大！