JavaScript作为一门动态、弱类型的语言，其灵活性在带来了开发效率的同时，也引入了管理复杂状态和确保数据完整性的挑战。长期以来，JavaScript开发者在处理不可变数据结构时，不得不依赖于浅层冻结（如Object.freeze()）、深度克隆或第三方库（如Immutable.js、Immer）。然而，这些方案各有其局限性，如性能开销、API不一致或无法提供原生级别的语义支持。
为了解决这些问题，TC39（ECMAScript的技术委员会）提出了“Records and Tuples”提案，旨在原生支持不可变复合数据结构。Records（记录）和Tuples（元组）将作为JavaScript语言的内建类型，提供深度不可变性、结构相等性以及潜在的性能优化。本文将深入探讨Records和Tuples的核心概念、其在堆内存中的实现原理、内存布局考量以及它们对JavaScript生态系统的深远影响。
1. Records与Tuples：不可变复合数据的基石
1.1 什么是Records？
Records是一种深度不可变的、有序的键值对集合，类似于JavaScript中的Object，但具有严格的不可变语义。一旦一个Record被创建，它的所有属性都不能被修改、添加或删除。此外，如果Record中包含其他Record或Tuple，它们也都是不可变的。
字面量语法： #{ key: value, anotherKey: anotherValue }
核心特性：
- 深度不可变性： Record本身及其所有嵌套的Record或Tuple都是不可变的。
- 结构相等性： 两个Record如果具有相同的键和相同的值（递归地比较），则它们被认为是相等的。这意味着
record1 === record2将执行深度值比较。 - 有序性： 属性的顺序在比较和迭代时是保留的。
- 哈希化能力： 由于其不可变性，Record可以被哈希化，从而在Map和Set中作为键使用，这与普通JavaScript对象作为键时只能依赖引用相等性形成鲜明对比。
1.2 什么是Tuples？
Tuples是一种深度不可变的、有序的值列表，类似于JavaScript中的Array，但同样具有严格的不可变语义。一旦一个Tuple被创建，它的所有元素都不能被修改、添加或删除。如果Tuple中包含其他Record或Tuple，它们也都是不可变的。
字面量语法： #[ value1, value2, value3 ]
核心特性：
- 深度不可变性： Tuple本身及其所有嵌套的Record或Tuple都是不可变的。
- 结构相等性： 两个Tuple如果具有相同的长度和相同的值（递归地比较），则它们被认为是相等的。这意味着
tuple1 === tuple2将执行深度值比较。 - 有序性： 元素的顺序是保留的。
- 哈希化能力： 与Record类似，Tuple也可以被哈希化，在Map和Set中作为键使用。
1.3 为什么需要Records和Tuples？
现有JavaScript处理不可变数据的局限性：
-
Object.freeze()和Array.freeze()： 它们提供的是浅层不可变性。嵌套的对象或数组仍然是可变的，这使得维护复杂数据结构的不可变性变得困难且容易出错。const mutableObject = { a: 1, b: { c: 2 } }; Object.freeze(mutableObject); mutableObject.a = 10; // 无效，严格模式下报错 mutableObject.b.c = 20; // 有效！内部对象仍然可变 console.log(mutableObject.b.c); // 20 -
深度克隆： 为了实现深度不可变性，开发者通常需要手动进行深度克隆或使用库。这不仅增加了代码复杂性，而且在每次“修改”数据时都会产生大量的内存分配和垃圾回收开销。
const original = { a: 1, b: { c: 2 } }; // 使用 JSON.parse(JSON.stringify()) 进行深度克隆（有局限性，如不支持函数、undefined、Symbol等） const cloned = JSON.parse(JSON.stringify(original)); cloned.b.c = 20; console.log(original.b.c); // 2 console.log(cloned.b.c); // 20 // 每次克隆都复制所有数据，效率低下 -
第三方库： Immutable.js、Immer等库提供了强大的不可变数据结构，但它们引入了新的API、增加了包体积，并且在与原生JavaScript对象交互时需要额外的转换。
Records和Tuples旨在通过原生支持解决这些问题，提供以下优势：
- 简化状态管理： 在React、Vue等前端框架中，不可变状态可以简化组件更新逻辑，避免不必要的重新渲染。
- 提高代码可预测性： 不可变数据消除了副作用，使得代码更易于理解、测试和调试。
- 并发安全： 尽管JavaScript是单线程的，但不可变数据在Web Workers或共享内存等场景下能提供更好的数据完整性保障。
- 性能优化潜力： 原生实现可以利用底层引擎优化，特别是通过结构共享（Structural Sharing）减少内存分配和垃圾回收压力，并加速相等性比较。
2. 堆内存中的不可变复合数据结构：内存布局
理解Records和Tuples的内存布局是理解其性能优势和工作原理的关键。JavaScript运行时（如V8）将对象分配在堆内存中。对于Records和Tuples，其设计目标之一是实现高效的内存管理，特别是通过结构共享来优化“修改”操作。
2.1 JavaScript对象在堆内存中的基本表示
在JavaScript中，无论是普通对象、数组、函数还是即将推出的Records和Tuples，它们都是在堆内存中分配的。变量存储的不是对象本身，而是指向堆内存中该对象地址的引用。
一个典型的JavaScript对象在堆内存中可能包含以下部分（概念性表示，具体实现因引擎而异）：
- 对象头（Object Header）： 包含对象的元数据，如类型信息（是对象、数组、Record等）、大小、属性的数量、原型链指针、以及可能的哈希值或其他标志位。
- 属性存储（Property Storage）： 存储对象的属性。这可以是一个指向键值对列表的指针，或者对于小对象，键值对可以直接存储在对象内部。对于动态语言，属性通常通过哈希表或隐藏类（Hidden Class）来管理，以优化查找性能。
- 元素存储（Element Storage）： 对于数组，这通常是一个连续的内存块，用于存储数组的元素。
当一个变量引用一个对象时，它实际上存储的是这个对象在堆内存中的地址。
let obj1 = { a: 1, b: 2 }; // obj1 指向堆内存中的一个对象 A
let obj2 = obj1; // obj2 也指向对象 A
let obj3 = { a: 1, b: 2 }; // obj3 指向堆内存中的另一个对象 B在堆内存中，A和B是两个不同的对象，即使它们的内容相同。obj1 === obj2为true（引用相等），而obj1 === obj3为false。
2.2 深度不可变性与结构共享
Records和Tuples的核心优势在于其深度不可变性。当需要对一个Record或Tuple进行“修改”时，实际上并不会改变原有的数据结构，而是会创建一个新的Record或Tuple。为了避免每次修改都进行完整的深度复制，引入了结构共享（Structural Sharing）的概念。
结构共享是持久化数据结构（Persistent Data Structures）的基础。其核心思想是，在从一个现有结构创建新结构时，只分配新数据所需的内存，并重用旧结构中未改变的部分。这通过共享指针来实现。
示例：Record的“修改”与结构共享
假设我们有一个Record user：
const user = #{
id: 1,
name: "Alice",
address: #{
street: "123 Main St",
city: "Anytown"
}
};在堆内存中，这可能被表示为：
表 1: 原始Record user 的概念性内存布局
| 内存地址 | 内容 | 类型 | 备注 |
|---|---|---|---|
0x1000 |
Record Header | Record | user 对象的根 |
0x1008 |
id: 1 |
Number | |
0x1010 |
name: "Alice" |
String | 字符串 "Alice" 可能在其他内存区域，这里是引用 |
0x1018 |
address: 0x2000 |
Pointer | 指向嵌套的 address Record |
0x2000 |
Record Header | Record | address 对象 |
0x2008 |
street: "123 Main St" |
String | 字符串 "123 Main St" 的引用 |
0x2010 |
city: "Anytown" |
String | 字符串 "Anytown" 的引用 |
现在，我们想要创建一个新的Record updatedUser，其中只改变 city 属性：
const updatedUser = user with {
address: user.address with {
city: "Newtown"
}
};这里使用了 with 表达式，这是Records和Tuples提案中用于创建新实例的语法，它表达了基于现有实例进行修改的意图。
在实现 updatedUser 时，JavaScript引擎会执行以下操作：
-
创建新的
addressRecord： 因为city属性发生了变化，所以需要创建一个新的addressRecord。这个新Record将包含新的city: "Newtown"属性，但它将重用旧addressRecord中的street: "123 Main St"属性的引用。表 2: 新的
updatedAddressRecord 的概念性内存布局内存地址 内容 类型 备注 0x3000Record Header Record 新的 addressRecord0x3008street:0x2008Pointer 共享 user.address.street的引用0x3010city: "Newtown"String 字符串 "Newtown" 的引用 -
创建新的
userRecord： 因为address属性指向了一个新的Record (0x3000)，所以也需要创建一个新的userRecord。这个新Record将重用旧userRecord中的id和name属性的引用，但address属性将指向新的updatedAddressRecord (0x3000)。表 3: 新的
updatedUserRecord 的概念性内存布局内存地址 内容 类型 备注 0x4000Record Header Record 新的 userRecord0x4008id: 1Number 共享 user.id的值0x4010name:0x1010Pointer 共享 user.name的引用0x4018address:0x3000Pointer 指向新的 updatedAddressRecord (0x3000)
通过这种方式，只有被修改的路径上的节点（以及它们的直接父节点）需要被重新创建。未改变的数据结构部分（如 id 和 name，以及 street）被共享，极大地减少了内存分配和复制的开销。
2.3 Tuples的结构共享
Tuples的结构共享原理与Records类似。当“修改”一个Tuple时，实际上是创建了一个新Tuple，并共享未改变的元素。
const point = #[10, 20, 30]; // 一个表示三维点的Tuple
// 假设我们想创建一个新点，只改变 z 坐标
const newPoint = point.with(2, 40); // 假设 with 方法语法
// 实际提案可能没有 .with 方法，而是 #[...point with { 2: 40 }] 这种形式
// 为了演示结构共享，我们假设存在一种修改语法表 4: 原始Tuple point 的概念性内存布局
| 内存地址 | 内容 | 类型 | 备注 |
|---|---|---|---|
0x5000 |
Tuple Header | Tuple | point 对象的根 |
0x5008 |
0: 10 |
Number | |
0x5010 |
1: 20 |
Number | |
0x5018 |
2: 30 |
Number |
创建 newPoint 时：
表 5: 新的Tuple newPoint 的概念性内存布局
| 内存地址 | 内容 | 类型 | 备注 |
|---|---|---|---|
0x6000 |
Tuple Header | Tuple | 新的 newPoint 对象 |
0x6008 |
0: 10 |
Number | 共享 point[0] 的值 |
0x6010 |
1: 20 |
Number | 共享 point[1] 的值 |
0x6018 |
2: 40 |
Number | 新的值 |
通过结构共享，每次“修改”操作的内存开销与被修改部分的深度成正比，而不是与整个数据结构的大小成正比，这在大型数据结构中尤其高效。
2.4 哈希化与规范化（Canonicalization）
Records和Tuples的一个关键特性是结构相等性，即record1 === record2进行的是深度值比较。为了高效地实现这一点，JavaScript引擎可能会采用哈希化和规范化技术。
- 哈希化： 对于一个不可变数据结构，可以计算一个基于其所有内容（包括嵌套的Records和Tuples）的哈希值。如果两个Records/Tuples的哈希值不相等，那么它们肯定不相等，无需进行深度比较。如果哈希值相等，则仍需进行深度比较以避免哈希碰撞。由于Record/Tuple是不可变的，其哈希值在创建后是固定的，可以缓存起来。
- 规范化（Canonicalization）： 更进一步的优化是规范化。如果引擎能保证对于任何两个结构上完全相同的Record/Tuple，它们在内存中只存在一份实例（即它们共享同一个内存地址），那么结构相等性检查就可以退化为简单的引用相等性检查（
===）。这种“去重”或“内部化”机制可以显著提高比较性能，并进一步减少内存占用。然而，实现规范化非常复杂，因为它需要一个高效的全局查找机制来判断一个新创建的Record/Tuple是否已经存在。这类似于字符串内部化（string interning）。
如果规范化得以实现，那么在上述 user 和 updatedUser 的例子中，user.id 和 updatedUser.id 可能不仅仅是值相等，而且它们所指向的内存地址（如果是对象的话）也可能相同，或者对于原始值，它们是直接存储的。user.name 和 updatedUser.name 字符串的引用也可能指向同一个规范化的字符串实例。
2.5 内部表示与存储结构
Records和Tuples的内部存储结构可能会采用针对不可变性优化的数据结构，例如：
- 哈希数组映射树（Hash Array Mapped Tries, HAMT）： 这是一种高效的、持久化的哈希表实现，非常适合用于Record的属性存储。它允许在对哈希表进行“修改”时，通过结构共享只创建新路径上的少量节点。
- 向量Trie（Vector Tries）： 类似于HAMT，但针对有序序列进行了优化，适用于Tuple的元素存储。它同样支持高效的“修改”操作和结构共享。
这些数据结构使得在不破坏原有结构的前提下，通过少量内存分配创建新版本成为可能，从而优化了时间和空间复杂度。
概念性存储结构对比
| 特性 | 普通JavaScript对象/数组 | Records/Tuples (提案) |
|---|---|---|
| 可变性 | 默认可变（Object.freeze() 浅层） |
深度不可变 |
| 相等性 | 引用相等（===） |
结构相等（===） |
| “修改”操作 | 直接修改原对象/数组 | 创建新实例，通过结构共享重用未变部分 |
| 内存分配 | 修改原地，或深克隆时完全复制 | 仅为修改路径上的新节点分配内存，共享旧节点 |
| 哈希化 | 无法原生哈希（需手动实现） | 可原生哈希，可作为Map/Set键 |
| 内部表示 | 隐藏类、哈希表、连续数组等 | 可能采用HAMT、Vector Trie等持久化数据结构 |
3. 代码实践与对比
3.1 Records的基本使用
// 1. 创建Records
const userRecord = #{
id: 1,
name: "Alice",
contact: #{
email: "[email protected]",
phone: "123-456-7890"
},
roles: #["admin", "user"] // Records可以嵌套Tuples
};
console.log(userRecord);
// #{ id: 1, name: "Alice", contact: #{ email: "[email protected]", phone: "123-456-7890" }, roles: #["admin", "user"] }
// 2. 访问属性
console.log(userRecord.name); // Alice
console.log(userRecord.contact.email); // [email protected]
// 3. 尝试修改（会报错或静默失败，取决于严格模式）
try {
userRecord.id = 2; // TypeError: Cannot assign to read only property 'id' of Record
} catch (e) {
console.log(e.message);
}
// 4. “修改”操作：使用 with 表达式创建新Record
const updatedUserRecord = userRecord with {
name: "Alicia",
contact: userRecord.contact with {
email: "[email protected]"
}
};
console.log(updatedUserRecord);
// #{ id: 1, name: "Alicia", contact: #{ email: "[email protected]", phone: "123-456-7890" }, roles: #["admin", "user"] }
// 验证原Record未被修改
console.log(userRecord.name); // Alice
console.log(userRecord.contact.email); // [email protected]
// 5. 结构相等性
const anotherUserRecord = #{
id: 1,
name: "Alice",
contact: #{
email: "[email protected]",
phone: "123-456-7890"
},
roles: #["admin", "user"]
};
console.log(userRecord === anotherUserRecord); // true (深度结构相等)
const differentUserRecord = userRecord with { id: 2 };
console.log(userRecord === differentUserRecord); // false
// 6. Record作为Map的键
const recordMap = new Map();
recordMap.set(userRecord, "original user");
recordMap.set(anotherUserRecord, "another original user"); // 键相同，会覆盖
console.log(recordMap.get(userRecord)); // another original user
console.log(recordMap.size); // 1
// 使用普通对象作为键，即使内容相同，也会被视为不同的键
const obj1 = { a: 1 };
const obj2 = { a: 1 };
const objMap = new Map();
objMap.set(obj1, "obj1");
objMap.set(obj2, "obj2");
console.log(objMap.size); // 23.2 Tuples的基本使用
// 1. 创建Tuples
const coordinates = #[10, 20, 30];
const rgbColor = #[255, 0, 128];
const mixedTuple = #["hello", 123, true, #[1, 2]]; // Tuples可以嵌套其他Tuples或Records
console.log(coordinates); // #[10, 20, 30]
// 2. 访问元素
console.log(coordinates[0]); // 10
console.log(mixedTuple[3][0]); // 1
// 3. 尝试修改（会报错或静默失败）
try {
coordinates[0] = 5; // TypeError: Cannot assign to read only property '0' of Tuple
} catch (e) {
console.log(e.message);
}
// 4. “修改”操作：使用 with 表达式创建新Tuple
const newCoordinates = coordinates with {
2: 40 // 改变索引为2的元素
};
console.log(newCoordinates); // #[10, 20, 40]
console.log(coordinates); // #[10, 20, 30] (原Tuple未被修改)
// 5. 结构相等性
const anotherCoordinates = #[10, 20, 30];
console.log(coordinates === anotherCoordinates); // true (深度结构相等)
const differentCoordinates = #[10, 20, 31];
console.log(coordinates === differentCoordinates); // false
// 6. Tuple作为Set的元素
const tupleSet = new Set();
tupleSet.add(coordinates);
tupleSet.add(anotherCoordinates); // 结构相同，不会被添加
console.log(tupleSet.size); // 1
console.log(tupleSet.has(#[10, 20, 30])); // true (结构相等)3.3 与现有机制的对比
| 特性 | 普通对象/数组 | Object.freeze() / Array.freeze() |
Records / Tuples |
|---|---|---|---|
| 可变性 | 可变 | 浅层不可变 | 深度不可变 |
| 相等性 | 引用相等 (===) |
引用相等 (===) |
结构相等 (===) |
| “修改”机制 | 直接修改（副作用），或手动深拷贝 | 无法修改，深层仍可变；深拷贝需手动 | with 表达式创建新实例，利用结构共享优化内存 |
| 作为Map/Set键 | 只能通过引用相等（内容相同但引用不同则为不同键） | 只能通过引用相等 | 通过结构相等作为键 |
| 性能考量 | 灵活，但修改时需注意副作用；深拷贝开销大 | 浅层保护，但深层仍有副作用；深拷贝开销大 | 创建新实例成本低（结构共享），相等性检查可能高效（哈希） |
| 语法 | {} 和 [] |
Object.freeze({}) 和 Array.freeze([]) |
#{} 和 #[ ] |
| 生态集成 | 广泛支持 | 原生支持，但语义局限 | 原生支持，语义明确，有望成为新范式 |
4. 性能考量与优化潜力
Records和Tuples的引入不仅仅是为了语法糖，更重要的是它们为JavaScript引擎带来了巨大的优化潜力。
4.1 结构共享带来的内存与CPU效益
正如前文所述，结构共享是Records和Tuples在“修改”操作时的核心优势。它带来的效益是显而易见的：
- 减少内存分配： 每次修改不再需要完全复制整个数据结构，只需要分配新修改路径上的少量节点。这显著减少了堆内存的分配量。
- 减少垃圾回收压力： 内存分配的减少直接意味着更少的对象需要被垃圾回收器处理，从而降低了GC暂停的频率和持续时间，提高了应用的响应速度。
- 更快的“修改”： 创建新版本的操作复杂度从
O(N)（N为数据结构总大小）降低到O(logN)或O(depth)（取决于内部数据结构和修改深度），这在大型嵌套数据结构中尤为重要。
4.2 高效的相等性检查
Records和Tuples的结构相等性是一个关键特性。如果没有优化，深度比较可能需要遍历整个数据结构，其复杂度为 O(N)，在某些情况下可能会非常慢。然而，JavaScript引擎可以利用其不可变性进行优化：
- 哈希缓存： 由于Records和Tuples是不可变的，它们的哈希值在创建时就可以计算并缓存起来。在比较两个Record/Tuple时，可以首先比较它们的哈希值。如果哈希值不同，那么它们肯定不相等，无需进行深度比较。这使得许多不相等的比较可以在
O(1)时间内完成（假设哈希计算为O(N)，但只计算一次）。 - 规范化/内部化： 如果引擎能够实现规范化，即确保结构上相同的Record/Tuple在内存中只有一份实例，那么结构相等性检查将退化为简单的引用相等性检查（
===），其复杂度为O(1)。这是终极的性能优化，但实现难度也最高。 - 短路优化： 在深度比较过程中，一旦发现任何不相等的元素或属性，比较即可立即停止。
4.3 JIT编译器的优化机会
Records和Tuples的不可变性使得JavaScript引擎的JIT（Just-In-Time）编译器能够做出更强的优化假设。
- 消除不必要的防御性拷贝： 在处理不可变数据时，JIT编译器知道数据不会在背后被修改，因此可以避免生成防御性拷贝代码。
- 数据流分析简化： 不可变性简化了数据流分析，使得编译器更容易追踪值的来源和变化，从而进行更激进的优化，例如常量传播（Constant Propagation）和死代码消除（Dead Code Elimination）。
- 缓存和备忘录化（Memoization）： 由于输入数据是不可变的，函数的输出可以安全地缓存。如果一个函数接收Records/Tuples作为参数，并且这些参数没有改变，那么可以直接返回之前计算的结果，而无需重新执行函数体。
// 假设有一个计算函数
function expensiveCalculation(dataRecord) {
// 耗时计算...
return resultRecord;
}
// 由于 dataRecord 是不可变的，我们可以安全地缓存结果
let cachedResult = null;
let lastInput = null;
function memoizedCalculation(dataRecord) {
if (dataRecord === lastInput) { // 结构相等性在这里发挥作用
return cachedResult;
}
lastInput = dataRecord;
cachedResult = expensiveCalculation(dataRecord);
return cachedResult;
}
const data1 = #{ a: 1, b: 2 };
const data2 = #{ a: 1, b: 2 }; // 结构上与 data1 相等
memoizedCalculation(data1); // 第一次计算
memoizedCalculation(data2); // 直接返回缓存结果，因为 data1 === data2 为 true5. 与现有JavaScript的集成
Records和Tuples被设计为JavaScript语言的原生部分，因此需要与现有生态系统良好集成。
-
与普通对象/数组的转换：
- 将Records/Tuples转换为普通对象/数组：可能会有内置的转换方法，例如
Record.toObject()/Tuple.toArray()，或者通过structuredClone等机制进行转换。 - 从普通对象/数组创建Records/Tuples：例如
Record.from({ a: 1 })或Tuple.from([1, 2])。
// 假设存在转换方法 const obj = { x: 1, y: { z: 2 } }; const rec = Record.from(obj); // #{ x: 1, y: #{ z: 2 } } const arr = [1, { a: 2 }]; const tup = Tuple.from(arr); // #[1, #{ a: 2 }] const convertedObj = rec.toObject(); // { x: 1, y: { z: 2 } } (深度转换) const convertedArr = tup.toArray(); // [1, { a: 2 }] (深度转换) - 将Records/Tuples转换为普通对象/数组：可能会有内置的转换方法，例如
-
类型检测： 提供内置的
Record.isRecord()和Tuple.isTuple()方法进行类型判断。const myRecord = #{ a: 1 }; const myTuple = #[1, 2]; const myObject = { a: 1 }; const myArray = [1, 2]; console.log(Record.isRecord(myRecord)); // true console.log(Record.isRecord(myObject)); // false console.log(Tuple.isTuple(myTuple)); // true console.log(Tuple.isTuple(myArray)); // false -
迭代： Records和Tuples将支持标准的迭代协议，允许使用
for...of循环、展开运算符 (...) 等。const myTuple = #[1, 2, 3]; for (const item of myTuple) { console.log(item); } // 1 // 2 // 3 const newTuple = #[0, ...myTuple, 4]; // #[0, 1, 2, 3, 4] const myRecord = #{ a: 1, b: 2 }; for (const [key, value] of Object.entries(myRecord)) { // Records可能需要 Object.entries 辅助 console.log(`${key}: ${value}`); } // a: 1 // b: 2 -
序列化： 当使用
JSON.stringify()序列化Records和Tuples时，它们应该被转换为普通的JavaScript对象和数组，以确保与现有JSON标准的兼容性。const data = #{ name: "Test", items: #[1, 2, #{ value: "nested" }] }; const jsonString = JSON.stringify(data); console.log(jsonString); // {"name":"Test","items":[1,2,{"value":"nested"}]} // 注意：这里的输出是普通对象和数组，而不是Record和Tuple的字面量
6. 高级考量
6.1 严格模式的重要性
Records和Tuples的深度不可变性意味着任何尝试修改它们的行为都是非法的。在严格模式下，这些尝试会抛出 TypeError。为了确保代码的健壮性，建议在处理Records和Tuples时始终使用严格模式。
"use strict";
const rec = #{ a: 1 };
try {
rec.a = 2; // TypeError
} catch (e) {
console.log(e.message); // Cannot assign to read only property 'a' of Record
}6.2 与WeakMap/WeakSet的交互
由于Records和Tuples可以被哈希化，并作为Map/Set的键，它们也可以作为WeakMap的键或WeakSet的元素。这对于管理与Records/Tuples关联的元数据而又不阻止其被垃圾回收非常有用。
6.3 内存泄漏风险（极低）
由于结构共享的存在，如果一个大的Record/Tuple被一个小的、新创建的Record/Tuple所引用（通过共享部分），那么只要这个小的Record/Tuple还存在，它所共享的旧Record/Tuple的部分就不能被垃圾回收。这通常不是问题，因为这是不可变数据结构设计的固有特性，也是其内存效率的来源。开发者通常会保留对当前最新状态的引用，而旧状态（如果没有其他引用）会被自然回收。
结语
Records和Tuples提案代表了JavaScript语言在处理数据不变性方面迈出的重要一步。它们通过原生支持深度不可变性、结构相等性以及底层引擎的结构共享优化，为开发者提供了更强大、更高效的工具来构建可预测、易维护的应用程序。随着这些新特性的逐步落地，JavaScript开发者将能够以更少的样板代码、更高的性能和更强的信心来管理复杂的数据状态，从而推动JavaScript生态系统向更健壮、更函数式的编程范式发展。它们的出现，无疑将是JavaScript语言现代化进程中的一个里程碑。