타입 추론 — 명시적 선언 없이도 타입이 잡히는 원리

// TypeScript가 알아서 타입을 추론
let message = 'hello';   // string
let count = 42;           // number
let isReady = true;       // boolean
let items = [1, 2, 3];   // number[]

// const는 리터럴 타입으로 추론
const greeting = 'hello'; // 'hello' (리터럴 타입)
const limit = 100;         // 100 (리터럴 타입)

// 반환 타입을 명시하지 않아도 추론됨
function add(a: number, b: number) {
  return a + b; // 반환 타입: number
}

// 여러 경로가 있으면 유니온으로 추론
function getResult(success: boolean) {
  if (success) {
    return { data: '성공' };       // { data: string }
  }
  return { error: '실패' };        // { error: string }
}
// 반환 타입: { data: string } | { error: string }

// ❌ 추론에만 의존 — 리팩터링 시 반환 타입이 의도치 않게 변할 수 있음
function fetchUser(id: number) {
  // 나중에 누군가 return 문을 빼먹으면 반환 타입이 바뀜
  if (id > 0) {
    return { name: '홍길동' };
  }
  // undefined가 반환될 수 있음
}

// ✅ 명시적 반환 타입 — 의도를 명확히 하고 실수를 방지
function fetchUserSafe(id: number): { name: string } | null {
  if (id > 0) {
    return { name: '홍길동' };
  }
  return null;
}

// 모든 요소가 같은 타입
const numbers = [1, 2, 3]; // number[]

// 여러 타입이 섞이면 유니온
const mixed = [1, 'hello', true]; // (number | string | boolean)[]

// 클래스 계층에서의 추론
class Animal { name = '' }
class Dog extends Animal { bark() {} }
class Cat extends Animal { meow() {} }

const pets = [new Dog(), new Cat()]; // (Dog | Cat)[]
// Animal[]이 아니라 (Dog | Cat)[]로 추론됨

const pets: Animal[] = [new Dog(), new Cat()]; // Animal[]

// addEventListener의 콜백에서 event 타입이 자동 추론됨
document.addEventListener('click', (event) => {
  // event: MouseEvent — 명시하지 않아도 추론됨
  console.log(event.clientX, event.clientY);
});

// 배열 메서드에서도 동작
const numbers = [1, 2, 3];
numbers.forEach((num) => {
  // num: number — 자동 추론
  console.log(num.toFixed(2));
});

// 함수를 별도로 선언하면 문맥을 잃음
const handler = (event) => {
  // event: any — 문맥이 없으므로 추론 불가
  console.log(event.clientX); // any 접근은 타입 검사 안 됨
};
document.addEventListener('click', handler);

// 해결: 타입을 명시
const typedHandler = (event: MouseEvent) => {
  console.log(event.clientX); // OK
};

const x = 'hello';  // 타입: 'hello' (리터럴)
let y = 'hello';    // 타입: string (넓혀짐)

const n = 42;       // 타입: 42 (리터럴)
let m = 42;         // 타입: number (넓혀짐)

let status = 'loading'; // string

// 나중에 다른 문자열을 할당해도 OK
status = 'success';
status = 'error';

let status = 'loading' as const; // 타입: 'loading'
// status = 'success'; // ❌ Error

// 빈 배열은 반드시 타입 명시
const items: string[] = [];
items.push('hello'); // OK

// 타입 명시 없으면
const items2 = []; // never[] — 아무것도 push 불가