JavaScript 垃圾回收机制面试题全解析

一、核心要点速览

💡 核心考点

内存生命周期: 分配 → 使用 → 释放
引用计数: 追踪对象被引用的次数（存在循环引用问题）
标记清除: 从根对象出发标记可达对象，清除未标记对象（主流算法）
标记整理: 标记后整理内存空间，减少碎片
分代回收: 新生代 + 老生代，不同代采用不同策略
V8 引擎: Chrome/Node.js 使用的 JS 引擎，采用分代回收

二、内存管理基础

1. 内存生命周期

javascript

// ========== 内存管理的三个阶段 ==========

// 1. 分配内存
let obj = { name: 'Vue' }  // 为对象分配内存
let arr = [1, 2, 3]        // 为数组分配内存
let str = 'Hello'          // 为字符串分配内存

// 2. 使用内存
console.log(obj.name)      // 访问对象属性
arr.push(4)                // 操作数组
str.length                 // 读取字符串长度

// 3. 释放内存
obj = null                 // 解除引用，等待 GC
arr = null                 // 解除引用
str = null                 // 当没有引用时，GC 会自动回收


// ========== 自动内存管理 ==========
// JavaScript 不需要手动释放内存
// 垃圾回收器（Garbage Collector, GC）自动处理

// C/C++ 需要手动管理：
// malloc() / free()
// new / delete

// JavaScript 自动管理：
// 创建变量 → 自动分配
// 不再使用 → 自动回收 ✓

2. 内存泄漏示例

javascript

// ========== 常见的内存泄漏 ==========

// 1. 全局变量
function leak1() {
  leakedVar = 'I am global'  // 忘记声明 let/const/var
}
leak1()
// leakedVar 成为全局变量，永远不会被回收

// 2. 定时器未清除
const timer = setInterval(() => {
  console.log('running...')
}, 1000)
// 如果不清除，timer 和回调函数永远不会被回收
// clearInterval(timer) // 应该清除

// 3. 闭包引用
function createClosure() {
  const largeData = new Array(1000000).fill('data')
  
  return function() {
    console.log(largeData.length)  // 引用了 largeData
  }
}

const closure = createClosure()
// largeData 无法被回收，因为闭包仍然引用它

// 4. DOM 引用
const elements = []

function addElement() {
  const div = document.createElement('div')
  div.innerHTML = 'Content'
  document.body.appendChild(div)
  elements.push(div)
}

addElement()
// 即使从 DOM 移除，elements 数组仍持有引用
// document.body.removeChild(div)
// elements = [] // 需要清空数组

// 5. 事件监听器未移除
const button = document.getElementById('myButton')
button.addEventListener('click', function handler() {
  console.log('clicked')
})
// 如果不 removeEventListener，handler 不会被回收
// button.removeEventListener('click', handler)

三、垃圾回收算法

1. 引用计数法（Reference Counting）

┌──────────────────────────────────────────────────────────┐
│                  引用计数法原理                          │
└──────────────────────────────────────────────────────────┘

核心思想:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
每个对象维护一个引用计数器
记录有多少个引用指向该对象

当引用计数为 0 时，立即回收

工作流程:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
创建对象:
  let obj = { name: 'Vue' }
  
  引用计数:
  ┌─────────────┐
  │ {name:Vue}  │ ← count: 1 (obj 引用)
  └─────────────┘

增加引用:
  let ref = obj
  
  引用计数:
  ┌─────────────┐
  │ {name:Vue}  │ ← count: 2 (obj, ref)
  └─────────────┘

解除引用:
  obj = null
  
  引用计数:
  ┌─────────────┐
  │ {name:Vue}  │ ← count: 1 (ref)
  └─────────────┘

ref = null
  
  引用计数:
  ┌─────────────┐
  │ {name:Vue}  │ ← count: 0 → 回收! ✓
  └─────────────┘
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

致命缺陷 - 循环引用:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
function createCycle() {
  const obj1 = {}
  const obj2 = {}
  
  obj1.ref = obj2  // obj1 → obj2
  obj2.ref = obj1  // obj2 → obj1
  
  return 'done'
}

createCycle()

引用计数:
  ┌──────────┐       ┌──────────┐
  │   obj1   │──────▶│   obj2   │
  │ count: 1 │◀──────│ count: 1 │
  └──────────┘       └──────────┘

问题:
✗ 两个对象互相引用
✗ 计数永远不为 0
✗ 无法被回收 → 内存泄漏!

解决方案:
✓ 现代浏览器已不使用纯引用计数
✓ IE6/7 曾使用，存在严重问题
✓ 现在主要使用标记清除算法
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

2. 标记清除法（Mark-and-Sweep）

┌──────────────────────────────────────────────────────────┐
│                  标记清除法原理                           │
└──────────────────────────────────────────────────────────┘

核心思想:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
从根对象（Global/Stack）出发
遍历所有可达对象并标记
清除未被标记的对象

执行流程:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
初始状态:
  
  Root (Global)
     │
     ├── obj1 ──→ obj2
     │
     └── obj3

Step 1 - 标记阶段 (Mark):
  
  Root (Global) ✓
     │
     ├── obj1 ✓ ──→ obj2 ✓
     │
     └── obj3 ✓
  
  从根开始，递归标记所有可达对象

Step 2 - 清除阶段 (Sweep):
  
  保留: obj1, obj2, obj3 (已标记)
  清除: obj4, obj5 (未标记，不可达)
  
  ┌──────────────┐
  │  obj4, obj5  │ → 释放内存 ✓
  └──────────────┘

优势:
✓ 解决循环引用问题
✓ 实现相对简单
✓ 现代浏览器广泛使用

劣势:
✗ 需要暂停程序执行（Stop-the-world）
✗ 产生内存碎片
✗ 标记和清除都需要遍历堆
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

3. 标记整理法（Mark-and-Compact）

┌──────────────────────────────────────────────────────────┐
│                  标记整理法原理                           │
└──────────────────────────────────────────────────────────┘

核心思想:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
在标记清除的基础上
将存活对象向一端移动
消除内存碎片

执行流程:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
初始状态（有碎片）:
  
  [obj1][空闲][obj2][空闲][obj3][空闲]
   ✓           ✓           ✓

Step 1 - 标记阶段:
  
  [obj1✓][空闲][obj2✓][空闲][obj3✓][空闲]

Step 2 - 整理阶段 (Compact):
  
  [obj1][obj2][obj3][空闲][空闲][空闲]
   ✓     ✓     ✓

Step 3 - 更新指针:
  
  所有指向 obj1, obj2, obj3 的引用
  更新为新地址

优势:
✓ 消除内存碎片
✓ 提高内存利用率
✓ 分配新对象更快（连续空间）

劣势:
✗ 整理过程开销大
✗ 需要更新所有引用指针
✗ 暂停时间更长
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

4. 三种算法对比

算法	优点	缺点	使用场景
引用计数	实时回收、实现简单	循环引用、性能开销	早期浏览器（IE6/7）
标记清除	解决循环引用、实现较简单	内存碎片、暂停时间长	现代浏览器主流
标记整理	无碎片、内存利用率高	整理开销大、暂停更长	老生代回收

四、V8 引擎的分代回收

1. 内存分代结构

┌──────────────────────────────────────────────────────────┐
│              V8 引擎内存分代结构                         │
└──────────────────────────────────────────────────────────┘

V8 内存布局:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
┌────────────────────────────────────────────┐
│         V8 Heap Memory                     │
├────────────────────────────────────────────┤
│                                            │
│  ┌──────────────────────────────────┐     │
│  │     New Space (新生代)            │     │
│  │     ~1-8 MB                      │     │
│  │                                  │     │
│  │  • From Space                    │     │
│  │  • To Space                      │     │
│  │                                  │     │
│  │  特点:                            │     │
│  │  ✓ 对象存活时间短                 │     │
│  │  ✓ 频繁 GC (Scavenge)            │     │
│  │  ✓ 快速回收                       │     │
│  └──────────────────────────────────┘     │
│                                            │
│  ┌──────────────────────────────────┐     │
│  │    Old Space (老生代)             │     │
│  │    ~几百 MB - 几 GB               │     │
│  │                                  │     │
│  │  • Old Pointer Space             │     │
│  │  • Old Data Space                │     │
│  │  • Code Space                    │     │
│  │  • Map Space                     │     │
│  │  • Large Object Space            │     │
│  │                                  │     │
│  │  特点:                            │     │
│  │  ✓ 对象存活时间长                 │     │
│  │  ✓ 较少 GC (Mark-Sweep/Compact)  │     │
│  │  ✓ 完整标记清除                   │     │
│  └──────────────────────────────────┘     │
│                                            │
└────────────────────────────────────────────┘

分代依据 - 弱分代假说:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
大多数对象都是"朝生夕死"的
✓ 新创建的对象很快会变成垃圾
✓ 存活久的对象倾向于继续存活

因此:
• 新生代: 小空间、频繁回收
• 老生代: 大空间、较少回收
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

2. 新生代回收（Scavenge 算法）

javascript

// ========== Scavenge 算法流程 ==========

/*
新生区分为两个半区:
- From Space: 当前使用
- To Space: 空闲

回收流程:
*/

// Step 1: 新对象分配到 From Space
let obj1 = { a: 1 }  // From Space
let obj2 = { b: 2 }  // From Space

// From Space: [obj1][obj2][...]
// To Space:   [空闲]

// Step 2: From Space 快满时触发 GC
// 检查 From Space 中的对象

// Step 3: 存活对象复制到 To Space
// From Space: [obj1✓][obj2][obj3✓][...]
// To Space:   [obj1'][obj3'][空闲]

// Step 4: 翻转两个空间
// From Space ← To Space (现在包含存活对象)
// To Space ← 原来的 From Space (清空)

// Step 5: 晋升到老生代
// 如果对象经历过一次 Scavenge 还存活
// 或者 To Space 使用超过 25%
// 则晋升到 Old Space

// 优势:
// ✓ 只复制存活对象（通常很少）
// ✓ 速度快（~1-5ms）
// ✓ 适合短命对象


// ========== 对象晋升条件 ==========

// 条件 1: 经历过一次 Scavenge
let obj = { data: 'test' }
// 第一次 GC: From → To (存活)
// 第二次 GC: 晋升到老生代 ✓

// 条件 2: To Space 使用率 > 25%
// 避免 To Space 溢出

3. 老生代回收（Mark-Sweep-Compact）

javascript

// ========== 老生代回收策略 ==========

/*
老生代采用标记清除 + 标记整理

触发条件:
1. 新生代晋升导致老生代空间不足
2. 显式调用 global.gc()（需 --expose-gc 参数）
3. 内存达到阈值

回收流程:
*/

// Step 1: 标记阶段
// 从根对象出发，标记所有可达对象

// Global/Stack
//   ↓
// 标记 obj1, obj2, obj3... (可达)

// Step 2: 清除阶段
// 清除未标记的对象
// 释放内存

// Step 3: 整理阶段（可选）
// 如果碎片化严重
// 整理存活对象，消除碎片

// 优化策略:
// ✓ 增量标记（Incremental Marking）
//   - 将标记过程分解为小步骤
//   - 与 JS 执行交替进行
//   - 减少单次暂停时间

// ✓ 并发标记（Concurrent Marking）
//   - V8 Orinoco 项目
//   - 标记阶段与 JS 并行执行
//   - 进一步减少停顿


// ========== 查看 GC 信息 ==========

// Node.js 中启用 GC 日志
// node --trace-gc app.js

// 输出示例:
// [28933:0x55a7b8c0e000]    12345 ms: Mark-sweep 100.5 (150.2) -> 80.3 (150.2) MB, 15.2 / 0.0 ms  (average mu = 0.850, current mu = 0.850) allocation failure scavenge might not succeed

// 解读:
// 12345 ms: 运行时间
// Mark-sweep: GC 类型
// 100.5 -> 80.3 MB: GC 前后内存
// 15.2 ms: GC 耗时

五、性能优化实践

1. 避免内存泄漏

javascript

// ========== 最佳实践 ==========

// ✓ 1. 及时清除定时器
const timer = setInterval(updateData, 1000)

function cleanup() {
  clearInterval(timer)  // 组件销毁时清除
}

// ✓ 2. 移除事件监听器
class Component {
  constructor() {
    this.handler = () => console.log('click')
    document.addEventListener('click', this.handler)
  }
  
  destroy() {
    document.removeEventListener('click', this.handler)
  }
}

// ✓ 3. 避免不必要的全局变量
function processData() {
  const data = fetchData()  // 局部变量，函数结束后自动回收
  return transform(data)
}

// ✗ 避免
window.cachedData = fetchData()  // 全局变量，永不回收

// ✓ 更好的缓存方案
const cache = new Map()

function getDataWithCache(key) {
  if (cache.has(key)) {
    return cache.get(key)
  }
  
  const data = fetchData(key)
  cache.set(key, data)
  
  // 限制缓存大小
  if (cache.size > 100) {
    const firstKey = cache.keys().next().value
    cache.delete(firstKey)
  }
  
  return data
}

// ✓ 4. 使用 WeakMap/WeakSet
const weakCache = new WeakMap()

function setObjectData(obj, data) {
  weakCache.set(obj, data)
  // 当 obj 被回收时，data 也会被回收
}

// ✓ 5. 及时解除 DOM 引用
function removeElement(element) {
  element.parentNode.removeChild(element)
  element = null  // 解除引用
}

// ✓ 6. 避免大型闭包
// ✗ 不好的做法
function createHandler() {
  const largeData = new Array(1000000).fill('x')
  
  return function() {
    // 只需要 smallData，但保留了整个 largeData
    console.log('handled')
  }
}

// ✓ 更好的做法
function createHandler() {
  const smallData = 'needed'
  
  return function() {
    console.log(smallData)  // 只保留必要的数据
  }
}

2. 监控内存使用

javascript

// ========== Node.js 内存监控 ==========

// 查看内存使用情况
const used = process.memoryUsage()
console.log({
  rss: Math.round(used.rss / 1024 / 1024) + ' MB',      // 常驻集大小
  heapTotal: Math.round(used.heapTotal / 1024 / 1024) + ' MB',  // V8 堆总量
  heapUsed: Math.round(used.heapUsed / 1024 / 1024) + ' MB',    // V8 堆已用
  external: Math.round(used.external / 1024 / 1024) + ' MB'     // C++ 对象绑定
})

// 定期监控
setInterval(() => {
  const used = process.memoryUsage()
  console.log(`Heap Used: ${Math.round(used.heapUsed / 1024 / 1024)} MB`)
}, 5000)

// 手动触发 GC（调试用）
// node --expose-gc app.js
if (global.gc) {
  global.gc()
  console.log('GC executed')
}


// ========== 浏览器内存监控 ==========

// Chrome DevTools
// 1. Performance 面板 - 录制内存快照
// 2. Memory 面板 - 堆快照分析
// 3. Performance Monitor - 实时监控

// 代码中检测
if (performance && performance.memory) {
  const memory = performance.memory
  console.log({
    jsHeapSizeLimit: memory.jsHeapSizeLimit,
    totalJSHeapSize: memory.totalJSHeapSize,
    usedJSHeapSize: memory.usedJSHeapSize
  })
}

3. 大数据处理优化

javascript

// ========== 分批处理避免内存峰值 ==========

// ✗ 一次性加载所有数据
async function loadAllData() {
  const response = await fetch('/api/large-data')
  const data = await response.json()  // 可能占用大量内存
  return data
}

// ✓ 流式处理
async function loadDataStream() {
  const response = await fetch('/api/large-data')
  const reader = response.body.getReader()
  
  while (true) {
    const { done, value } = await reader.read()
    if (done) break
    
    // 逐块处理，避免全部加载到内存
    processChunk(value)
  }
}

// ✓ 分页加载
async function loadPaginatedData() {
  const allData = []
  let page = 1
  const pageSize = 100
  
  while (true) {
    const response = await fetch(`/api/data?page=${page}&size=${pageSize}`)
    const data = await response.json()
    
    if (data.length === 0) break
    
    allData.push(...data)
    page++
    
    // 定期清理不需要的数据
    if (allData.length > 1000) {
      // 只保留最近的数据
      allData.splice(0, allData.length - 1000)
    }
  }
  
  return allData
}

// ✓ 使用 Generator 惰性求值
function* generateLargeSequence() {
  for (let i = 0; i < 1000000; i++) {
    yield i * 2  // 每次只生成一个值
  }
}

// 使用时不会一次性占用内存
for (const value of generateLargeSequence()) {
  if (value > 1000) break  // 可以提前终止
  console.log(value)
}

六、常见面试题

题目 1：解释 JavaScript 的垃圾回收机制

javascript

// 标准回答要点:

/*
JavaScript 采用自动垃圾回收机制，主要算法包括:

1. 引用计数法（早期使用）
   - 追踪对象引用次数
   - 计数为 0 时回收
   - 问题: 无法处理循环引用

2. 标记清除法（现代主流）
   - 从根对象标记可达对象
   - 清除未标记对象
   - 解决循环引用问题

3. 标记整理法
   - 标记后整理内存
   - 消除内存碎片

V8 引擎采用分代回收:
- 新生代: Scavenge 算法，快速回收短命对象
- 老生代: Mark-Sweep-Compact，处理长寿对象

优势:
✓ 自动化，开发者无需手动管理
✓ 分代回收提高效率
✓ 增量/并发标记减少停顿
*/

题目 2：什么是内存泄漏？如何避免？

javascript

// 标准回答要点:

/*
内存泄漏是指不再使用的内存没有被及时释放。

常见原因:
1. 意外的全局变量
2. 未清除的定时器
3. 闭包引用
4. 未移除的事件监听器
5. DOM 引用

避免方法:
✓ 使用严格模式 ('use strict')
✓ 及时清除定时器和事件监听
✓ 避免不必要的全局变量
✓ 使用 WeakMap/WeakSet
✓ 及时解除 DOM 引用
✓ 限制缓存大小
✓ 使用工具检测（Chrome DevTools）
*/

题目 3：WeakMap 和普通 Map 的区别？

javascript

// ========== 普通 Map ==========
const map = new Map()
const obj = { key: 'value' }

map.set(obj, 'data')
console.log(map.get(obj)) // 'data'

obj = null  // obj 引用断开
// 但 Map 中仍然持有对象的引用
// 对象无法被回收 → 内存泄漏风险


// ========== WeakMap ==========
const weakMap = new WeakMap()
const obj2 = { key: 'value' }

weakMap.set(obj2, 'data')
console.log(weakMap.get(obj2)) // 'data'

obj2 = null  // obj2 引用断开
// WeakMap 是弱引用，不影响 GC
// 对象可以被正常回收 ✓


// ========== 特性对比 ==========

// WeakMap 的限制:
// ✗ 键必须是对象
// ✗ 不能遍历（keys/values/entries）
// ✗ 没有 size 属性
// ✗ 不能清空（clear）

// WeakMap 的优势:
// ✓ 不会阻止键对象被回收
// ✓ 适合缓存、私有数据存储

// 实际应用: 私有数据
const privateData = new WeakMap()

class User {
  constructor(name) {
    privateData.set(this, { name, createdAt: Date.now() })
  }
  
  getName() {
    return privateData.get(this).name
  }
}

const user = new User('Vue')
console.log(user.getName()) // 'Vue'
// 当 user 被回收时，私有数据也会被回收 ✓

题目 4：V8 为什么要分代回收？

javascript

// 标准回答要点:

/*
基于弱分代假说（Weak Generational Hypothesis）:

1. 大多数对象都是"朝生夕死"的
   - 新创建的对象很快变成垃圾
   - 例如: 临时变量、函数返回值

2. 存活久的对象倾向于继续存活
   - 例如: 全局配置、单例对象

分代回收的优势:

新生代（New Space）:
- 空间小（1-8 MB）
- 频繁回收（Scavenge 算法）
- 只复制存活对象（通常很少）
- 速度快（1-5ms）

老生代（Old Space）:
- 空间大（几百 MB - 几 GB）
- 较少回收（Mark-Sweep-Compact）
- 完整标记清除
- 处理长寿对象

整体效果:
✓ 提高回收效率
✓ 减少暂停时间
✓ 优化内存使用
*/

七、面试标准回答

JavaScript 垃圾回收（GC）是自动内存管理机制，负责分配和回收不再使用的内存，避免内存泄漏。
主要算法包括：
引用计数法：追踪对象的引用次数，计数为 0 时回收。优点是实时性好，缺点是存在循环引用问题，现代浏览器已不再使用。
标记清除法：从根对象（Global/Stack）出发，标记所有可达对象，然后清除未标记的对象。这是现代浏览器的主要算法，解决了循环引用问题。
标记整理法：在标记清除的基础上，将存活对象向一端移动，消除内存碎片，提高内存利用率。
V8 引擎采用分代回收策略，基于"弱分代假说"：
新生代（New Space）：存放短命对象，使用 Scavenge 算法，频繁快速回收
老生代（Old Space）：存放长寿对象，使用 Mark-Sweep-Compact 算法，较少回收
常见的内存泄漏场景包括：意外的全局变量、未清除的定时器、闭包引用、未移除的事件监听器、DOM 引用等。
避免内存泄漏的最佳实践：
使用严格模式防止意外全局变量
及时清除定时器和事件监听器
避免不必要的大闭包
使用 WeakMap/WeakSet 存储关联数据
及时解除 DOM 引用
使用 Chrome DevTools 监控内存使用
在实际项目中，我会通过 Performance 和 Memory 面板分析内存快照，识别内存泄漏点，并使用上述最佳实践预防问题。

八、记忆口诀

垃圾回收歌诀：

JS 内存自动管，
垃圾回收来帮忙。
引用计数有缺陷，
循环引用会泄漏！

标记清除是主流，
从根出发标可达。
未标对象全清除，
循环引用没问题！

V8 分代效率高，
新生代里 Scavenge。
老生代用 Mark-Sweep，
分而治之速度快！

内存泄漏要警惕，
全局变量定时器。
闭包监听 DOM 引用，
及时清理别忘记！

WeakMap 是弱引用，
不挡 GC 回收路。
缓存私有好帮手，
内存管理更安心！

九、推荐资源

十、总结一句话

垃圾回收: 自动管理 + 多种算法 = 无需手动释放内存 🎯
分代回收: 新生代快 + 老生代稳 = 高效的回收策略 ⚡
内存泄漏: 常见陷阱 + 最佳实践 = 持续监控预防 ✓

JavaScript 垃圾回收机制面试题全解析 ​

一、核心要点速览 ​

二、内存管理基础 ​

1. 内存生命周期 ​

2. 内存泄漏示例 ​

三、垃圾回收算法 ​

1. 引用计数法（Reference Counting） ​

2. 标记清除法（Mark-and-Sweep） ​

3. 标记整理法（Mark-and-Compact） ​

4. 三种算法对比 ​

四、V8 引擎的分代回收 ​

1. 内存分代结构 ​

2. 新生代回收（Scavenge 算法） ​

3. 老生代回收（Mark-Sweep-Compact） ​

五、性能优化实践 ​

1. 避免内存泄漏 ​

2. 监控内存使用 ​

3. 大数据处理优化 ​

六、常见面试题 ​

题目 1：解释 JavaScript 的垃圾回收机制 ​

题目 2：什么是内存泄漏？如何避免？ ​

题目 3：WeakMap 和普通 Map 的区别？ ​

题目 4：V8 为什么要分代回收？ ​

七、面试标准回答 ​

八、记忆口诀 ​

九、推荐资源 ​

十、总结一句话 ​

JavaScript 垃圾回收机制面试题全解析

一、核心要点速览

二、内存管理基础

1. 内存生命周期

2. 内存泄漏示例

三、垃圾回收算法

1. 引用计数法（Reference Counting）

2. 标记清除法（Mark-and-Sweep）

3. 标记整理法（Mark-and-Compact）

4. 三种算法对比

四、V8 引擎的分代回收

1. 内存分代结构

2. 新生代回收（Scavenge 算法）

3. 老生代回收（Mark-Sweep-Compact）

五、性能优化实践

1. 避免内存泄漏

2. 监控内存使用

3. 大数据处理优化

六、常见面试题

题目 1：解释 JavaScript 的垃圾回收机制

题目 2：什么是内存泄漏？如何避免？

题目 3：WeakMap 和普通 Map 的区别？

题目 4：V8 为什么要分代回收？

七、面试标准回答

八、记忆口诀

九、推荐资源

十、总结一句话