如何通过Timeout提前终止函数执行？现有方案求评估

问题背景 #

我需要在异步函数完成前提前终止并返回结果，尝试了以下三种方案均未达到预期：

方案1：使用setTimeout返回值，最终返回100 #

async function Later() {
    setTimeout(() => { return 10 }, 1_000)
    await new Promise((resolve) => setTimeout(resolve, 2_000))
    return 100
}

console.log(await Later())

问题：setTimeout的回调是独立的宏任务，不会改变外层async函数的执行流程，函数会等待2秒后返回100。

方案2：在setTimeout中抛出异常，try/catch无法捕获 #

async function Later() {
    try {
        setTimeout(() => { throw 10 }, 1_000)
        await new Promise((resolve) => setTimeout(resolve, 2_000))
        return 100
    } catch (error) {
        return error.message
    }
}

console.log(await Later())

问题：setTimeout的回调运行在独立的执行上下文，不在当前try/catch的捕获范围内，因此异常无法被捕获。

方案3：使用Promise.race，但无法终止第二个函数执行 #

async function Later() {
    for (let i = 0; i < 10; i++) {
        await new Promise((res) => setTimeout(res, 100))
        console.log(i)
    }
    return 'Later'
}

const data = await Promise.race([
    new Promise((res) => setTimeout(() => res('First promise'), 100)),
    Later()
])
console.log(data)

执行日志：

First promise
0
1
2
3
4
5
6
7
8
9

问题：Promise.race仅会返回第一个完成的Promise结果，但不会终止其他Promise的执行逻辑，因此Later函数的循环会继续执行完毕。

实际场景中我用getBlockWeb3.eth.getTransaction替代示例中的Promise，需要避免函数阻塞等待的解决方案。自行编写了如下函数，请问该方案是否可行？

const GetTransaction = (hash) => {
    return new Promise(async (resolve, reject) => {
        const timeout = setTimeout(() => reject(new Error(hash)), 3_000)
        let data
        for (let i = 0; i < 3; i++) {
            try {
                await new Promise((resolve) => setTimeout(resolve, 1_000))
                data = await getBlockWeb3.eth.getTransaction(hash)
                if (data) {
                    clearTimeout(timeout)
                    resolve(data)
                }
            } catch (error) {
                console.log(`${new Date().toLocaleString()} :: Error fetching transaction:`, error.message)
                await new Promise((resolve) => setTimeout(resolve, 1000))
            }
        }
        clearTimeout(timeout)
        resolve(null)
    })
}

方案可行性评估与优化建议 #

你的GetTransaction方案整体可行，核心逻辑满足需求，但有几个细节可以优化：

可行点分析 #

• 全局3秒超时机制：超时后主动reject，避免无限等待API响应
• 重试逻辑：循环重试3次，失败后间隔1秒再尝试，符合API调用的容错场景
• 提前终止：拿到有效数据后立即清除定时器并resolve，让上层代码及时获取结果
• 边界处理：重试全部失败后清除定时器并返回null，覆盖所有异常情况

优化建议 #

1. 移除Promise构造器中的async关键字
   Promise构造器的回调如果是async函数，内部抛出的异常会被async函数自行捕获，无法触发Promise的reject，可能导致部分错误无法被外部感知。可以将逻辑拆分为内部async函数：

   const GetTransaction = (hash) => {
       return new Promise((resolve, reject) => {
           const timeout = setTimeout(() => reject(new Error(`Timeout fetching transaction: ${hash}`)), 3_000)
           
           const fetchTask = async () => {
               let data
               for (let i = 0; i < 3; i++) {
                   try {
                       await new Promise(res => setTimeout(res, 1_000))
                       data = await getBlockWeb3.eth.getTransaction(hash)
                       if (data) {
                           clearTimeout(timeout)
                           resolve(data)
                           return
                       }
                   } catch (error) {
                       console.log(`${new Date().toLocaleString()} :: Error fetching transaction:`, error.message)
                       await new Promise(res => setTimeout(res, 1000))
                   }
               }
               clearTimeout(timeout)
               resolve(null)
           }
           
           // 捕获内部async函数的未处理异常
           fetchTask().catch(err => {
               clearTimeout(timeout)
               reject(err)
           })
       })
   }
   

2. 优化超时错误信息
   原代码仅将hash作为错误信息，改为带描述的文本，便于后续排查问题。

3. 调整重试间隔逻辑
   原代码每次重试前先等待1秒，失败后再等待1秒，两次请求间隔为2秒，可根据目标API的速率限制调整间隔时长，避免触发限流机制。

4. 补充空结果日志
   如果getBlockWeb3.eth.getTransaction返回空但未抛出异常，当前逻辑会继续重试，但可以添加日志记录这种情况，方便调试：

   // 在data = await ...之后添加
   if (!data) {
       console.log(`${new Date().toLocaleString()} :: Transaction ${hash} returned empty`)
   }
   

关于异步任务终止的补充说明 #

对于getBlockWeb3.eth.getTransaction这类第三方API调用，多数情况下无法强制终止正在进行的网络请求（除非API本身支持取消机制）。你的方案通过超时和提前resolve的方式，虽然无法终止底层请求，但能让上层代码及时拿到结果，避免阻塞，这已是实际开发中常用的折中解决方案。

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