Hidden Classes, Inline Caches & V8 Optimization

Rule 1: Initialize all object properties in constructor with correct types. Rule 2: Never delete properties — set to null/undefined instead. Rule 3: Keep function arguments consistent in type.

Rule 4: Avoid mixing types in arrays — use typed arrays for numbers. Rule 5: Prefer prototype methods over per-instance closures for methods. Rule 6: Use monomorphic call sites — don't pass wildly different objects to same function.

Rule 7: For hot numeric loops, use integer arithmetic where possible.

// ❌ Anti-patterns
class BadPoint {
  constructor(x, y) {
    this.x = x;
    this.y = y;
  }
  getDistance() { // Per-instance closure — new function per instance!
    return Math.sqrt(this.x ** 2 + this.y ** 2);
  }
}

// ✅ Prototype method — shared across all instances (one hidden class)
class GoodPoint {
  constructor(x, y) {
    this.x = x; // always number
    this.y = y; // always number
    // No conditional properties!
  }
}
GoodPoint.prototype.getDistance = function() {
  return Math.sqrt(this.x ** 2 + this.y ** 2);
};

// Typed arrays for numeric hot paths
const normalArray = [1, 2, 3, 4, 5];     // any element type
const typedArray = new Float64Array(5);  // V8 guarantees float64
typedArray[0] = 1; typedArray[1] = 2;   // no hidden class changes possible!

// Integer arithmetic — V8 SMI optimization
function sumSMI(arr) {
  let total = 0; // SMI (small integer) — fastest!
  for (let i = 0; i < arr.length; i++) {
    total += arr[i]; // stays SMI if arr has only integers
  }
  return total;
}