5个 JavaScript 开发中难以发现的隐蔽错误

JavaScript 的动态性和复杂性意味着，虽然代码在表面上可以正常运行，但一些深层次、隐蔽的错误往往让人意想不到，今天梳理了几个 JavaScript 开发中难以发现的隐蔽错误，帮助大家写出更健壮、更可预测的代码。

来看下那些潜伏在代码中的“恶魔细节”。

1. async/await 的隐式陷阱：忘记 try…catch

async/await极大地改善了异步代码的可读性，但它也带来了一个隐蔽的风险：未被捕获的Promise reject会变成一个静默的、未处理的异常。

错误场景：

async function fetchData() {
  // 如果 API 返回 404 或 500，这个 Promise 会被 reject
  const data = await fetch('https://api.example.com/data');
  console.log('数据处理完成', data); // 这一行永远不会执行
}

// 调用函数，但没有处理潜在的错误
fetchData(); 
console.log('程序继续执行'); // 程序会继续，但错误被“吞掉”了

问题根源：

await 只是一个语法糖，它会暂停 async 函数的执行，等待 Promise 解决。如果 Promise 被 reject，await 会将其作为异常抛出。如果没有try...catch块来捕获这个异常，它就会沿着调用栈向上传播，最终成为一个 unhandledrejection。

正确姿势：

始终用 try…catch 包裹 await 表达式，或者在调用链的更高层级进行捕获。

async function fetchData() {
 try {
    const response = await fetch('https://api.example.com/data');
    if (!response.ok) {
      throw new Error(`HTTP error! status: ${response.status}`);
    }
    const data = await response.json();
    console.log('数据处理完成', data);
  } catch (error) {
    console.error('获取数据失败:', error);
  }
}

fetchData();

2. Promise.all 的“一荣俱荣，一损俱损”

当需要并行处理多个 Promise 时，Promise.all是首选。但高手有时会忘记它的“快速失败”（Fail-Fast）特性。

错误场景：

假设我们需要获取用户详情和他的帖子列表，即使获取帖子失败，也希望看到用户详情。

async function getUserProfile(userId) {
  try {
    const [user, posts] = await Promise.all([
      api.fetchUser(userId),       // 这个成功了
      api.fetchPosts(userId)       // 但这个因为网络问题失败了
    ]);
    renderProfile(user, posts);
  } catch (error) {
    // 整个 block 都失败了，我们连 user 数据都拿不到
    console.error('获取用户 Profile 失败', error);
  }
}

问题根源：

Promise.all的设计是，只要其中任何一个 Promise 被 reject，整个Promise.all就会立即 reject，并返回那个失败的原因，而不会等待其他 Promise 完成。

正确姿势：

使用Promise.allSettled。它会等待所有 Promise 都有结果（无论是 fulfilled 还是 rejected），然后返回一个包含每个 Promise 状态和结果（或原因）的对象数组。

async function getUserProfile(userId) {
 const results = await Promise.allSettled([
    api.fetchUser(userId),
    api.fetchPosts(userId)
  ]);

 const userResult = results[0];
 const postsResult = results[1];

 if (userResult.status === 'fulfilled') {
    // 即使帖子失败，我们依然可以渲染用户信息
    renderUser(userResult.value);
  } else {
    console.error('获取用户失败:', userResult.reason);
  }

 if (postsResult.status === 'fulfilled') {
    renderPosts(postsResult.value);
  } else {
    console.error('获取帖子失败:', postsResult.reason);
  }
}

3. 数组迭代中的意外突变

在forEach或for...of循环中直接修改（增加或删除）数组本身，是导致不可预测行为的常见原因。

错误场景：

从数组中移除所有偶数。

let numbers=[1, 2, 3, 4, 5, 6];
numbers.forEach((num, index) => {
    if (num2 === 0) {
        numbers.splice(index, 1); // 灾难的开始!
    }
});
console.log(numbers); // 输出:[1, 3, 5, 6] <--6 被跳过了!

问题根源：

当你使用 splice 删除一个元素时，数组的长度和后续元素的索引都会发生变化。但 forEach 的迭代过程并不会根据这个变化来调整它的内部计数器，导致它跳过紧跟在被删除元素后面的那个元素。

正确姿势：

不要在迭代中修改原数组。最好的方法是创建一个新数组。

let numbers=[1, 2, 3, 4, 5, 6];
// 使用 filter，函数式编程的最佳实践
const oddNumbers = numbers.filter(num => num % 2 !== 0);
console.log(oddNumbers);// 输出:[1, 3, 5]

如果确实需要在原地修改，请使用反向循环。

for (let i = numbers.length - 1; i >= 0; i--){
    if ( numbers[i] % 2 === 0) {
        numbers.splice(i, 1);
    }
}

4. 闭包的记忆陷阱与内存泄漏

闭包是 JavaScript 的强大特性，但也是内存泄漏的主要来源之一，尤其是在处理 DOM 事件监听时。

错误场景：

function setupHeavyObjectListener() {
    const heavyObject ={ /*一个包含大量数据的对象 */ };
    const element = document.getElementById('my-element');
    element.addEventListener('click', () => {
        // 这个匿名函数形成了一个闭包，持有了 heavyObject 的引用
        console.log('Clicked!', heavyObject.someProperty);
    });
    // 假设之后 element:被从 DOM 中移除了
    // element = null;
}

setupHeavyobjectListener();

问题根源：

即使 element 从 DOM 中移除，只要事件监听器没有被显式地移除（removeEventListener），这个监听器（闭包）就依然存在，并且它会一直引用着 heavyObject。这导致 heavyObject 和 element 都无法被垃圾回收器回收。

正确姿势：

在组件卸载或元素销毁时，务必清理事件监听器。

function setupHeavyObjectListener(){
    const heavyObject = { /* ... */ };
    const element = document.getElementById('my-element');
    const handleclick = () => {
        console.log('Clicked!', heavyObject.someProperty);
    };
    element.addEventListener('click', handleClick);
    // 返回一个清理函数
    return() => {
        element.removeEventListener('click', handleClick);
        console.log('Listener cleaned up!');
    };
}
const cleanup = setupHeavyObjectListener();
// 在未来的某个时刻，比如组件卸载时
// cleanup();

5. 对象的深拷贝与浅拷贝之谜

这是一个永恒的话题。即使是资深开发者，也可能在不经意间对嵌套对象进行了浅拷贝，导致了意想不到的副作用。

错误场景：

const userProfile = {
    name: 'Alex',
    settings: {
        theme: 'dark',
        notifications: true
    }
};
// 使用展开语法进行“拷贝”
const updatedProfile = { ...userProfile };
// 修改新对象的嵌套属性
updatedProfile.settings.theme = 'light';
// 原对象也被修改了!
console.log(userProfile.settings.theme); // 输出:'light'

问题根源：
Object.assign()和展开语法...都只执行浅拷贝。它们会创建一个新的顶层对象，但如果属性值是对象或数组，它们只会复制引用，而不是值。

正确姿势：
对于深层嵌套的对象，需要使用深拷贝。

• 简单场景 (无函数、undefined、Symbol 等):

  const deepCopiedProfile = structuredClone(userProfile); // JSON.parse(JSON.stringify(userProfile));

• 复杂场景: 使用成熟的库，如 Lodash 的 _.cloneDeep()。

JavaScript 是一门看似简单实则充满细节的语言，当我们开始对这些“小问题”变得敏感时，代码质量和开发效率必将迈上一个新的台阶。

以上关于5个 JavaScript 开发中难以发现的隐蔽错误的文章就介绍到这了，更多相关内容请搜索码云笔记以前的文章或继续浏览下面的相关文章，希望大家以后多多支持码云笔记。