타입 가드와 타입 좁히기

function printId(id: string | number) {
  // 처음에는 'id'의 타입이 'string | number'입니다.
  console.log(`ID: ${id}`);

  // id.toUpperCase(); // Error: 'string | number' 형식에 'toUpperCase' 속성이 없습니다.
                     // number 타입에는 이 메서드가 없기 때문입니다.

  // 타입 가드를 사용하여 타입을 좁힙니다.
  if (typeof id === 'string') {
    // 이 if 블록 안에서 'id'의 타입은 'string'으로 좁혀집니다.
    console.log(`대문자 ID: ${id.toUpperCase()}`);
  } else {
    // 이 else 블록 안에서 'id'의 타입은 'number'로 좁혀집니다.
    console.log(`고정 소수점 ID: ${id.toFixed(2)}`);
  }
}

printId("abc123DEF"); // ID: abc123DEF, 대문자 ID: ABC123DEF
printId(123.456);     // ID: 123.456, 고정 소수점 ID: 123.46

function printValue(value: string | number | boolean) {
  if (typeof value === 'string') {
    console.log(`문자열: ${value.length}`);
  } else if (typeof value === 'number') {
    console.log(`숫자: ${value * 2}`);
  } else {
    console.log(`불리언: ${!value}`);
  }
}

printValue("hello");  // 문자열: 5
printValue(100);      // 숫자: 200
printValue(true);     // 불리언: false

class Bird {
  fly() { console.log('새가 날아갑니다.'); }
  layEggs() { console.log('알을 낳습니다.'); }
}

class Fish {
  swim() { console.log('물고기가 헤엄칩니다.'); }
  layEggs() { console.log('알을 낳습니다.'); }
}

function move(animal: Bird | Fish) {
  if (animal instanceof Bird) {
    animal.fly(); // 'animal'은 Bird 타입으로 좁혀짐
  } else {
    animal.swim(); // 'animal'은 Fish 타입으로 좁혀짐
  }
  animal.layEggs(); // 'Bird'와 'Fish' 모두 layEggs 메서드를 가지므로 안전하게 호출 가능
}

move(new Bird()); // 새가 날아갑니다., 알을 낳습니다.
move(new Fish()); // 물고기가 헤엄칩니다., 알을 낳습니다.

interface Car {
  drive(): void;
}

interface Boat {
  sail(): void;
}

function operateVehicle(vehicle: Car | Boat) {
  if ('drive' in vehicle) {
    vehicle.drive(); // 'vehicle'은 Car 타입으로 좁혀짐
  } else {
    vehicle.sail();  // 'vehicle'은 Boat 타입으로 좁혀짐
  }
}

class MyCar implements Car { drive() { console.log('자동차 운전!'); } }
class MyBoat implements Boat { sail() { console.log('보트 항해!'); } }

operateVehicle(new MyCar());  // 자동차 운전!
operateVehicle(new MyBoat()); // 보트 항해!

function greetUser(user: { name: string; email?: string | null }) {
  console.log(`안녕하세요, ${user.name}님!`);

  if (user.email) { // null·undefined·빈 문자열이 아닐 때
    // 이 블록 안에서 user.email의 타입은 string으로 좁혀집니다.
    console.log(`이메일: ${user.email.toLowerCase()}`);
  } else {
    console.log("이메일 정보가 없습니다.");
  }
}

greetUser({ name: "Alice" });             // 안녕하세요, Alice님!, 이메일 정보가 없습니다.
greetUser({ name: "Bob", email: "[email protected]" }); // 안녕하세요, Bob님!, 이메일: [email protected]
greetUser({ name: "Charlie", email: null }); // 안녕하세요, Charlie님!, 이메일 정보가 없습니다.

interface AdminUser {
  id: number;
  role: 'admin';
  manageUsers(): void;
}

interface GeneralUser {
  id: number;
  role: 'general';
  viewProfile(): void;
}

type User = AdminUser | GeneralUser;

// isAdminUser는 사용자 정의 타입 가드 함수입니다.
// user is AdminUser: true 분기에서 AdminUser로 좁히겠다는 계약이며 구현의 정확성은 작성자 책임입니다.
function isAdminUser(user: User): user is AdminUser {
  return (user as AdminUser).role === 'admin';
}

function handleUser(user: User) {
  if (isAdminUser(user)) {
    // 이 블록 안에서 user는 AdminUser 타입으로 좁혀집니다.
    console.log("관리자 권한으로 로그인했습니다.");
    user.manageUsers();
  } else {
    // 이 블록 안에서 user는 GeneralUser 타입으로 좁혀집니다.
    console.log("일반 사용자 권한으로 로그인했습니다.");
    user.viewProfile();
  }
}

const admin: AdminUser = { id: 1, role: 'admin', manageUsers: () => console.log("사용자 관리") };
const general: GeneralUser = { id: 2, role: 'general', viewProfile: () => console.log("프로필 보기") };

handleUser(admin);   // 관리자 권한으로 로그인했습니다., 사용자 관리
handleUser(general); // 일반 사용자 권한으로 로그인했습니다., 프로필 보기

const birdLike: Bird = {
  fly() { console.log('객체의 fly 호출'); },
  layEggs() { console.log('객체의 layEggs 호출'); }
};

console.log(birdLike instanceof Bird); // false
console.log('fly' in birdLike);        // true
// move(birdLike); // 구조 타입 검사는 통과하지만 swim이 없어 실행 중 실패함

function moveByMembers(animal: Bird | Fish) {
  if ('fly' in animal) {
    animal.fly();
  } else {
    animal.swim();
  }
  animal.layEggs();
}

moveByMembers(birdLike);