V8核心优化：隐藏类与内联缓存（附实战Demo）

function Point(x, y) {
  this.x = x; // 第一步：创建隐藏类C0 → 添加x属性 → 转为C1
  this.y = y; // 第二步：C1添加y属性 → 转为C2
}

const p1 = new Point(1, 2); // 隐藏类C2
const p2 = new Point(3, 4); // 与p1共享C2（属性顺序相同）
const p3 = new Point(5);    // 只有x属性 → 隐藏类C1（与p1/p2不同）

console.log(%HaveSameMap(p1, p2)); // true（V8调试API，需开启flags）
console.log(%HaveSameMap(p1, p3)); // false

// 案例A：先x后y
const objA = {};
objA.x = 1;
objA.y = 2; // 隐藏类：C0→C1(x)→C2(x,y)

// 案例B：先y后x
const objB = {};
objB.y = 1;
objB.x = 2; // 隐藏类：C0→C3(y)→C4(y,x)

console.log(%HaveSameMap(objA, objB)); // false（属性顺序不同，隐藏类不同）

const user = { name: "Alice" }; // 隐藏类C0→C1(name)
user.age = 20;                  // C1→C2(name,age)
user.gender = "female";         // C2→C3(name,age,gender)

// 每次添加新属性都会创建新的隐藏类，建议初始化时定义所有属性
const userOpt = { name: "Bob", age: 25, gender: "male" }; // 直接生成C3，无切换

// 频繁访问属性的函数
function getUserName(user) {
  return user.name; // 第一次访问：缓存user的隐藏类和name的偏移量
}

// 相同隐藏类的对象 → 缓存命中
const user1 = { name: "Charlie" };
const user2 = { name: "David" };

console.log(getUserName(user1)); // 首次调用：缓存未命中，记录隐藏类
console.log(getUserName(user2)); // 二次调用：缓存命中，直接返回属性值

// 不同隐藏类的对象 → 缓存失效
const user3 = { age: 30, name: "Eve" }; // 属性顺序不同，隐藏类不同
console.log(getUserName(user3)); // 缓存失效，重新查找属性

// 测试1：相同隐藏类（缓存命中）
function testICHit() {
  const arr = [];
  const base = { a: 1, b: 2, c: 3 }; // 固定隐藏类
  for (let i = 0; i < 1e6; i++) {
    arr.push(base.a + base.b + base.c); // 缓存持续命中
  }
}

// 测试2：不同隐藏类（缓存失效）
function testICMiss() {
  const arr = [];
  for (let i = 0; i < 1e6; i++) {
    const obj = i % 2 ? { a: 1, b: 2, c: 3 } : { c: 3, b: 2, a: 1 };
    arr.push(obj.a + obj.b + obj.c); // 频繁切换隐藏类，缓存失效
  }
}

// 执行时间对比：testICHit() 远快于 testICMiss()
console.time("IC Hit");
testICHit();
console.timeEnd("IC Hit"); // ~10ms

console.time("IC Miss");
testICMiss();
console.timeEnd("IC Miss"); // ~50ms（性能差距5倍）

// 未优化：多次属性访问，多次缓存查询
function calculateTotal(order) {
  return order.price + order.tax + order.shipping;
}

// 优化：缓存对象引用，减少属性查找
function calculateTotalOpt(order) {
  const { price, tax, shipping } = order; // 一次解构，多次复用
  return price + tax + shipping;
}

// 反例：动态属性+混合结构 → 双重性能损耗
function badDesign() {
  let total = 0;
  for (let i = 0; i < 1e5; i++) {
    const obj = {};
    if (i % 2) obj.a = i; // 隐藏类C1
    else obj.b = i;       // 隐藏类C2
    total += obj.a || obj.b; // 内联缓存频繁失效
  }
  return total;
}

// 正例：固定结构+统一属性顺序 → 协同优化
function goodDesign() {
  let total = 0;
  for (let i = 0; i < 1e5; i++) {
    const obj = { a: i % 2 ? i : undefined, b: i % 2 ? undefined : i }; // 固定隐藏类
    total += obj.a || obj.b; // 内联缓存持续命中
  }
  return total;
}

// 性能对比：goodDesign() 比 badDesign() 快3-5倍
console.time("Bad");
badDesign();
console.timeEnd("Bad"); // ~30ms

console.time("Good");
goodDesign();
console.timeEnd("Good"); // ~8ms