function add(a, b) {
  return a + b;
}

{
  "type": "FunctionDeclaration",
  "id": { "type": "Identifier", "name": "add" },
  "params": [
    { "type": "Identifier", "name": "a" },
    { "type": "Identifier", "name": "b" }
  ],
  "body": {
    "type": "BlockStatement",
    "body": [
      {
        "type": "ReturnStatement",
        "argument": {
          "type": "BinaryExpression",
          "operator": "+",
          "left": { "type": "Identifier", "name": "a" },
          "right": { "type": "Identifier", "name": "b" }
        }
      }
    ]
  }
}

// 1. 원본 코드 (인라이닝 전)
function add(x, y) {
  return x + y;
}
 
function multiply(x, y) {
  return x * y;
}
 
function calculateValue(a, b) {
  const sum = add(a, b);        // 함수 호출 #1
  const doubled = multiply(sum, 2);  // 함수 호출 #2
  return doubled;
}
 
const result = calculateValue(5, 3);
 
// 2. 첫 번째 단계 인라이닝 (add 함수 인라이닝)
function multiply(x, y) {
  return x * y;
}
 
function calculateValue(a, b) {
  // add 함수가 인라이닝됨
  const sum = (a + b);          // 직접 연산으로 대체
  const doubled = multiply(sum, 2);  // 아직 함수 호출 존재
  return doubled;
}
 
const result = calculateValue(5, 3);
 
// 3. 두 번째 단계 인라이닝 (multiply 함수 인라이닝)
function calculateValue(a, b) {
  // add와 multiply 모두 인라이닝됨
  const sum = (a + b);          // 직접 연산
  const doubled = (sum * 2);    // 직접 연산으로 대체
  return doubled;
}
 
const result = calculateValue(5, 3);
 
// 4. 최종 최적화 단계 (calculateValue 함수까지 인라이닝)
// 실제 V8 엔진이 내부적으로 변환하는 형태
const result = ((5 + 3) * 2);   // 모든 함수 호출이 직접 연산으로 대체
 
// 5. 더 복잡한 예시: 조건문이 있는 경우
// 인라이닝 전
function getValue(obj) {
  if (obj === null) return 0;
  return obj.value;
}
 
function processObjects(objects) {
  return objects.map(obj => getValue(obj));
}
 
// 인라이닝 후
function processObjects(objects) {
  return objects.map(obj => {
    // getValue 함수의 내용이 직접 삽입됨
    if (obj === null) return 0;
    return obj.value;
  });
}

// 내부 분기처리가 복잡한 케이스
function complexOperation(x, y) {
  if (x > 100) {
    return x * y;
  } else if (x < 0) {
    return x + y;
  } else {
    return Math.pow(x, y);
  }
}
 
// 크기가 매우크고 연산이 복잡한 케이스
function largeFunction(input) {
  let result = 0;
  for (let i = 0; i < 100; i++) {
    result += Math.sin(input * i);
    result *= Math.cos(input / (i + 1));
    // ... 많은 연산들
  }
  return result;
}

class Person {
    int age;     // 0부터 4바이트 
    string name; // 4바이트부터 시작
};

const user = {};
 
히든 클래스 1 (C01)

user.name = "choi"
 
히든 클래스 C01 -> 히든 클래스 C02 offset 0 : name
 
user.age = 29
 
히든 클래스 C01 -> 히든 클래스 C02 offset 0 : name -> 히든 클래스 C03 offset 1 : age

function user(name, age){
   this.name = name;
    this.age = age
};
 
const user1 = new user("hyun", 20);
const user2 = new user("mina", 32);
 
// 같은 히든 클래스를 공유

const user1 = { name : "hyun", age : 20 };
const user2 = { age : 32, name : "mina" };

(() => {
  const hyun = { name: "hyun", age: 35 };
  const luke = { name: "luke", age: 28 };
  const harry = { name: "harry", age: 26 };
  const mina = { name: "mina", age: 55 };
  const helen = { name: "helen", age: 900 };
  const people = [hyun, luke, harry, mina, helen];
  const getAge = (person) => person.age;
 
  console.time("test1");
  for (let i = 0; i < 1_000_000_000; i++) {
    getAge(people[i % 5]);
  }
  console.timeEnd("test1");
})();
 
(() => {
  const hyun = { name: "hyun", age: 35, rank: "Captain" };
  const luke = { name: "luke", age: 28, skill: "Jedi Master" };
  const harry = { name: "harry", age: 26, title: "Princess" };
  const mina = { name: "mina", age: 55, status: "Retired Jedi" };
  const helen = { name: "helen", age: 900, wisdom: "Legendary" };
  const people = [hyun, luke, harry, mina, helen];
  const getAge = (person) => person.age;
 
  console.time("test2");
  for (let i = 0; i < 1_000_000_000; i++) {
    getAge(people[i % 5]);
  }
  console.timeEnd("test2");
})();