JavaScript中的内存管理和值传递/引用传递是理解语言核心机制的重要概念。让我详细解释这些内容：

1. 内存管理基础

内存生命周期

JavaScript中的内存管理遵循以下生命周期：

1. 内存分配

   • 声明变量、函数、对象时自动分配内存
   • 自动确定所需内存大小

2. 内存使用

   • 读写已分配内存中的值

3. 内存回收

   • 垃圾回收器自动释放不再使用的内存

内存分配方式

// 基本类型 - 栈内存(stack)
let num = 42;
let str = "hello";
let bool = true;

// 引用类型 - 堆内存(heap)
let obj = { name: "张三" };
let arr = [1, 2, 3];
let func = function() {};

2. JavaScript垃圾回收机制

垃圾回收基本概念

什么是垃圾回收

垃圾回收（Garbage Collection, GC）是JavaScript引擎自动管理内存的机制，负责回收不再使用的内存空间。

// 内存分配示例
var obj1 = { name: "Object 1" };  // 在堆内存中分配对象
var obj2 = { name: "Object 2" };  // 在堆内存中分配对象

obj1 = obj2;  // obj1原来引用的对象成为垃圾，可被回收

// obj1原来引用的对象 { name: "Object 1" } 不再可达，成为垃圾

可达性概念

可达性是判断对象是否存活的关键标准：

// 可达性示例
// 1. 内置对象（全局对象、document、window等）
// 2. 函数调用栈中的变量
// 3. 被可达对象引用的对象

function example() {
    var localVar = { data: "local" };  // 函数执行期间可达
    
    if (true) {
        var innerObj = { value: "inner" };  // 块级作用域内可达
        globalReference = innerObj;  // 赋值给全局变量，保持可达
    }
    
    // 函数执行完毕后，localVar不可达，可被回收
    // innerObj由于被globalReference引用，仍然可达
}

var globalReference;  // 全局变量
example();
// 此时globalReference仍然可达，其引用的对象不会被回收

主要垃圾回收算法

1. 标记清除算法（Mark and Sweep）

这是现代JavaScript引擎最常用的垃圾回收算法：

// 标记清除算法工作原理演示

// 假设有以下内存结构
var root = {
    obj1: {
        data: "reachable",
        ref: null
    },
    obj2: {
        value: "also reachable"
    }
};

root.obj1.ref = root.obj2;  // 对象间引用

// 标记阶段：
// 1. 从根对象开始标记所有可达对象
// 2. root 标记为活跃
// 3. root.obj1 标记为活跃
// 4. root.obj2 标记为活跃

// 清除阶段：
// 1. 遍历所有对象
// 2. 未标记的对象被回收

// 创建不可达对象
function createUnreachableObject() {
    var tempObj = { temp: "temporary" };
    return "result";
}

var result = createUnreachableObject();
// tempObj在函数执行完毕后不可达，会被标记清除算法回收

2. 引用计数算法

早期垃圾回收算法，现在主要用于处理DOM对象：

// 引用计数算法原理
var obj = { name: "test" };  // 引用计数: 1

var ref1 = obj;  // 引用计数: 2
var ref2 = obj;  // 引用计数: 3

ref1 = null;  // 引用计数: 2
ref2 = null;  // 引用计数: 1
obj = null;   // 引用计数: 0，对象可被回收

// 引用计数算法的问题：循环引用
function createCircularReference() {
    var obj1 = {};
    var obj2 = {};
    
    obj1.ref = obj2;  // obj1引用obj2，obj2引用计数+1
    obj2.ref = obj1;  // obj2引用obj1，obj1引用计数+1
    
    // 即使函数执行完毕，两个对象的引用计数都不为0
    // 造成内存泄漏
}

// 现代JavaScript引擎已经解决了循环引用问题

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

用于处理内存碎片问题：

// 标记整理算法处理内存碎片
// 模拟内存分配情况：

/*
内存状态（标记前）：
[对象A][空闲][对象B][空闲][对象C][空闲][对象D]

标记后发现：
[活跃][垃圾][活跃][垃圾][活跃][垃圾][活跃]

整理后：
[对象A][对象B][对象C][对象D][空闲][空闲][空闲]
*/

// 这种算法可以减少内存碎片，提高内存使用效率

4. 分代垃圾回收

现代JavaScript引擎（如V8）使用分代垃圾回收：

// 分代垃圾回收概念
// 新生代（Young Generation）：新创建的对象
// 老生代（Old Generation）：存活时间较长的对象

// 对象晋升示例
function frequentlyCalledFunction() {
    var tempObject = { data: "temporary" };
    // tempObject 创建在新生代
    
    // 函数执行完毕，如果tempObject仍然存活
    // 经过几次垃圾回收后，会晋升到老生代
    return tempObject;
}

// 频繁调用的函数
for (let i = 0; i < 1000; i++) {
    frequentlyCalledFunction();
}

// 一些对象会因为频繁存活而被移动到老生代

5. 新生代垃圾回收（Scavenge算法）

// Scavenge算法工作原理
// 使用复制算法，将内存分为两个空间：From空间和To空间

/*
初始状态：
From空间: [对象A][对象B][对象C]
To空间: []

垃圾回收过程：
1. 标记From空间中的存活对象
2. 将存活对象复制到To空间
3. 清空From空间
4. 交换From和To空间的角色

结果：
From空间: []
To空间: [对象A][对象C]  // 假设对象B已死亡
*/

// 代码示例
function createObjects() {
    var objects = [];
    
    // 创建多个对象
    for (let i = 0; i < 100; i++) {
        objects.push({ id: i, data: "object_" + i });
    }
    
    // 只返回部分对象，其余成为垃圾
    return objects.filter(obj => obj.id % 2 === 0);
}

var result = createObjects();
// 50个对象成为垃圾，会在新生代GC中被回收

3. 常见内存问题和解决方案

内存泄漏类型

// 1. 意外的全局变量
function leakyFunction() {
    // 错误：忘记声明变量
    globalVar = "I'm global now!";  // 创建全局变量
    
    // 正确做法
    var localVar = "I'm local";
}

// 2. 被遗忘的定时器
var someData = new Array(1000000);

var intervalId = setInterval(function() {
    // 定时器持有someData的引用
    if (someData && someData.length > 0) {
        // 处理数据
    }
}, 1000);

// 解决方案：记得清理定时器
// clearInterval(intervalId);
// someData = null;

// 3. 事件监听器未移除
function attachEventListener() {
    var largeData = new Array(1000000);
    
    document.getElementById('button').addEventListener('click', function() {
        console.log(largeData.length);  // 闭包持有largeData引用
    });
    
    // 解决方案：提供清理方法
    return function cleanup() {
        document.getElementById('button').removeEventListener('click', arguments.callee);
        largeData = null;
    };
}

// 4. 闭包导致的内存泄漏
function createLeakyClosure() {
    var largeData = new Array(1000000);
    
    return function() {
        // 即使不使用largeData，闭包也会保持其引用
        return "some result";
    };
}

// 优化后的闭包
function createOptimizedClosure() {
    var largeData = new Array(1000000);
    var result = processData(largeData);  // 处理数据
    
    // 释放大对象
    largeData = null;
    
    return function() {
        return result;  // 只持有处理结果的引用
    };
}

JavaScript的垃圾回收机制虽然自动化，但理解其工作原理对于编写高性能、无内存泄漏的应用至关重要。通过合理的编程实践和内存管理策略，可以最大化应用的性能和稳定性。