// ? 無法捕獲 setTimeout 內的錯誤
try {
  setTimeout(() => {
    throw new Error('定時器錯誤');
  }, 100);
} catch (err) {
  console.log('捕獲到錯誤：', err); // 永遠不會執(zhí)行
}
// ? Promise.catch 也抓不到
Promise.resolve()
  .then(() => {
    setTimeout(() => {
      throw new Error('定時器錯誤');
    }, 100);
  })
  .catch(err => console.log('捕獲到錯誤：', err)); // 同樣無效

function delayTask(fn, ms) {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      try {
        const result = fn(); // 執(zhí)行任務
        resolve(result);
      } catch (err) {
        reject(err); // 手動捕獲錯誤并 reject
      }
    }, ms);
  });
}

// 使用示例
delayTask(() => {
  throw new Error('定時器內的錯誤');
}, 100)
.then(res => console.log(res))
.catch(err => console.log('捕獲到錯誤：', err)); // 生效！

// 問題代碼：同步錯誤無法被 catch 捕獲
function getUser(id) {
  if (!id) throw new Error('id 不能為空'); // 同步錯誤
  return fetch(`/api/user/${id}`); // 異步 Promise
}

// 使用時
getUser() // 直接拋出錯誤，不會進入 catch
  .then(res => res.json())
  .catch(err => console.log('錯誤：', err));

// 修復：用 Promise.try 包裹
function getUser(id) {
  return Promise.try(() => {
    if (!id) throw new Error('id 不能為空'); // 同步錯誤
    return fetch(`/api/user/${id}`); // 異步 Promise
  });
}

// 使用時
getUser()
  .then(res => res.json())
  .catch(err => console.log('錯誤：', err)); // 同步/異步錯誤都能捕獲！

Promise.try(async () => {
  const userId = await getUserId(); // 異步獲取 ID
  if (!userId) throw new Error('無用戶 ID'); // 同步判斷
  const user = await fetchUser(userId); // 異步請求
  return user;
})
.catch(err => console.log('所有錯誤都能捕獲：', err));

// 語法 1：基礎用法
Promise.try(executor)
  .then(result => { /* 處理成功結果 */ })
  .catch(error => { /* 處理所有錯誤（同步+異步） */ });
// 語法 2：結合 async/await
Promise.try(async () => {
  // 混合同步/異步邏輯
  const data = await fetchData();
  if (data.length === 0) throw new Error('無數據');
  return data;
})
.catch(err => console.error(err));

// 封裝工具函數：統(tǒng)一錯誤處理
function getCache(key) {
  return Promise.try(() => {
    // 同步：先查內存緩存
    const cacheData = localStorage.getItem(key);
    if (cacheData) return JSON.parse(cacheData); // 同步返回
    
    // 異步：緩存不存在則請求接口
    return fetch(`/api/cache/${key}`).then(res => res.json());
  });
}

// 使用：同步/異步錯誤都能 catch
getCache('user_123')
  .then(data => console.log('數據：', data))
  .catch(err => console.log('錯誤：', err));

// 傳統(tǒng)寫法（繁瑣）
function doTask() {
  return new Promise((resolve, reject) => {
    try {
      const result = syncOperation(); // 同步操作
      resolve(result);
    } catch (err) {
      reject(err);
    }
  });
}

// Promise.try 寫法（簡潔）
function doTask() {
  return Promise.try(() => {
    return syncOperation(); // 自動處理同步錯誤
  });
}

// 同步函數可能拋錯
function parseJSON(str) {
  return JSON.parse(str); // 無效 JSON 會同步拋錯
}

// 用 Promise.try 包裝，轉為 Promise 錯誤
Promise.try(() => parseJSON('{invalid json}'))
  .catch(err => console.log('JSON 解析錯誤：', err)); // 生效

// 兼容所有環(huán)境的 Promise.try 實現
if (!Promise.try) {
  Promise.try = function (executor) {
    return new Promise((resolve, reject) => {
      try {
        // 執(zhí)行回調，獲取返回值
        const result = executor();
        // 如果返回的是 Promise，直接 resolve；否則包裝為 Promise
        resolve(result);
      } catch (err) {
        // 同步錯誤直接 reject
        reject(err);
      }
    });
  };
}

// 測試：完全兼容原生用法
Promise.try(() => {
  throw new Error('同步錯誤');
})
.catch(err => console.log('捕獲到：', err)); // 生效

// 等價于 Promise.try 的 async/await 寫法
async function wrapFn(fn) {
  try {
    return await fn(); // await 會處理同步值/Promise
  } catch (err) {
    return Promise.reject(err);
  }
}

// 使用
wrapFn(() => {
  throw new Error('同步錯誤');
})
.catch(err => console.log('捕獲到：', err));

// ? 錯誤認知：Promise.try 無法直接捕獲定時器錯誤
Promise.try(() => {
  setTimeout(() => {
    throw new Error('定時器錯誤');
  }, 100);
})
.catch(err => console.log('捕獲到：', err)); // 無效

// ? 正確：Promise.try 會自動包裝同步返回值為 Promise
const res = Promise.try(() => 123);
console.log(res instanceof Promise); // true
res.then(num => console.log(num)); // 123

// ? Promise.resolve 無法捕獲同步錯誤
Promise.resolve(() => {
  throw new Error('同步錯誤');
})
.catch(err => console.log('捕獲到：', err)); // 無效

// ? Promise.try 能捕獲
Promise.try(() => {
  throw new Error('同步錯誤');
})
.catch(err => console.log('捕獲到：', err)); // 生效