/Optimization

Code Optimization for JavaScript

Primary LanguageJavaScript

Code Optimization for JavaScript

How to optimize OOP for JavaScript VMs

  • Object layout and consistency
    • Don’t add or delete fields later; initialize all fields in the constructor or factory.
    • Keep class fields consistent (shape) — same order and types across instances.
    • Object shape (hidden class) — runtime layout that enables fast property access.
    • Do not change type of identifier or field; keep the same shape throughout usage.
    • Avoid shape changes via optional properties — use null to replace objects and undefiled instead of primitive values.
    • Monomorphic code — optimized for a single object shape to stay in fast paths.
    • Inline caching — a JIT optimization that remembers seen shapes for quick property access.
    • Avoid union types in most cases to prevent polymorphic or megamorphic inline caches; unions are ok for same type values, enums (e.g. months, statusCodes), same contracts (e.g. Promise and Thenable).
    • Stable property access — prefer dot notation compared to dynamic [name] access.
  • Data representation
    • Avoid Holey Arrays — no empty elements, deletes, or resizes.
    • Prefer single-type arrays.
    • Keep numbers as signed small integers to avoid accidental doubles or NaN.
    • Use typed arrays for numeric hot paths.
    • Reuse preallocated memory to reduce GC pressure.
  • Functions and state
    • Inline-friendly functions — keep them small, pure, with monomorphic parameters.
    • Avoid polymorphic returns so the runtime can specialize call sites.
    • Prefer arrow functions when object context is unnecessary.
    • Don’t change incoming parameters.
    • Avoid bound functions in hot code: bind, apply, call.
  • Loops and control flow
    • Avoid functions inside loops.
    • Prefer for loops for performance and for..of for expressiveness;
    • Avoid for..in and .forEach().
    • Choose array iteration method that match semantics (intent).
    • Optimize loop invariants.
    • Prefer iterative solutions over recursive ones when depth is high.
  • Execution efficiency
    • Optimize lexical scope — keep identifier visibility tight.
    • Prefer const, fall back to let when reassignment is required.
    • String building in hot paths: use template strings or arrays plus join.
    • Avoid deopt triggers — no with, eval, or prototype mutation in hot code.
    • Warm up predictable paths before measuring performance.
    • Separate hot and cold paths to keep hot functions small.