typeof만으로 부족할 때, TypeScript 객체 타입을 어떻게 믿을 수 있을까?

function process(response: unknown) {
  if (typeof response === 'string') {
    // 이 블록 안에서 response는 'string' 타입으로 추론된다.
    console.log(response.toUpperCase());
  }
}

interface Product {
  id: number;
  name: string;
  inStock: boolean;
}

function processProduct(response: unknown) {
  if (
    response &&
    typeof response === 'object' &&
    'id' in response &&
    'name' in response &&
    'inStock' in response
  ) {
    // 하지만... 이 블록 안에서도 response의 타입은 여전히 'unknown'이거나
    // `{ id: unknown; name: unknown; ... }` 일 뿐, 'Product'라고 확신하지 못한다.
    // 그래서 또다시 타입 단언을 사용해야만 한다.
    console.log((response as Product).name);
  }
}

function isString_Normal(value: unknown): boolean {
  return typeof value === 'string';
}
 
function check(value: unknown) {
  if (isString_Normal(value)) {
    // isString_Normal이 true여도, 타입스크립트는 이 사실을 타입 추론에 활용하지 못한다.
    // 따라서 'value'는 여전히 unknown 타입이다.
    // 에러: 'value' is of type 'unknown'.
    // value.toUpperCase();
  }
}

function isString_TypeGuard(value: unknown): value is string {
  return typeof value === 'string';
}
 
function check(value: unknown) {
  if (isString_TypeGuard(value)) {
    // isString_TypeGuard가 true를 반환했으므로,
    // 타입스크립트는 '계약'에 따라 value의 타입을 string으로 좁힌다.
    // 이제 string의 모든 메서드를 안전하게 사용할 수 있다.
    console.log(value.toUpperCase());
  }
}

interface Product {
  id: number;
  name: string;
  inStock: boolean;
}

// Product 타입을 위한 커스텀 타입 가드
function isProduct(value: unknown): value is Product {
  // 1. value가 null이 아니고, 타입이 'object'인지 확인한다.
  if (value === null || typeof value !== 'object') {
    return false;
  }
 
  // 2. 필요한 모든 속성(id, name, inStock)이 value 객체 안에 있는지 확인한다.
  return 'id' in value && 'name' in value && 'inStock' in value;
  
  // (더 엄격하게 하려면 각 속성의 타입까지 검사할 수도 있다.)
  // e.g., return typeof (value as any).id === 'number' && ...
}
 
// --- 타입 가드 사용하기 ---
function processApiResponse(response: unknown) {
  // Before: 복잡하고 지저분했던 조건문
  // if (response && typeof response === 'object' && 'id' in response && ...)
 
  // After: 깔끔하고 의미가 명확한 함수 호출
  if (isProduct(response)) {
    // 이 블록 안에서 'response'는 완벽하게 'Product' 타입으로 추론된다.
    // 더 이상 'as Product' 같은 타입 단언이 필요 없다.
    console.log(`상품명: ${response.name}, 재고: ${response.inStock ? '있음' : '없음'}`);
  } else {
    console.error("오류: 유효하지 않은 상품 데이터입니다.");
  }
}
 
// 테스트
processApiResponse({ id: 1, name: "노트북", inStock: true }); // "상품명: 노트북, 재고: 있음"
processApiResponse({ id: 2, name: "키보드" }); // "오류: 유효하지 않은 상품 데이터입니다." (inStock 속성 없음)
processApiResponse("This is a string"); // "오류: 유효하지 않은 상품 데이터입니다."

// isProduct 함수는 이전에 정의했다고 가정하자.
interface Product { id: number; name: string; inStock: boolean; }
interface ApiError { code: number; message: string; }
 
const mixedResponses: (Product | ApiError)[] = [
    { id: 1, name: "노트북", inStock: true },
    { code: 404, message: "Not Found" },
    { id: 2, name: "키보드", inStock: false },
    { code: 500, message: "Server Error" },
];
 
// 일반적인 필터링
// TypeScript는 filter 내부 로직을 통해 타입을 좁혀주지 못한다.
// 따라서 filtered1의 타입은 여전히 (Product | ApiError)[] 인 것이다.
const filtered1 = mixedResponses.filter(item => 'id' in item);
 
 
// 커스텀 타입 가드를 사용한 필터링
// isProduct 타입 가드를 filter의 인자로 전달하면,
// TypeScript는 필터링된 결과가 Product[] 타입임을 '확신'할 수 있다.
const productList: Product[] = mixedResponses.filter(isProduct);
 
console.log(productList);
// 결과: [{ id: 1, ... }, { id: 2, ... }]
 
// 이제 productList 배열의 모든 요소에 대해 .name, .inStock 속성을
// 에러 없이 안전하게 접근할 수 있다.
productList.forEach(product => console.log(product.name));