TypeScriptのユニオン型を使いこなす：実践的な型定義と型ガードの活用術

// 数値、または文字列を受け取るユニオン型の定義
function printId(id: number | string) {
  console.log("Your ID is: " + id);
}

// どちらの型でも呼び出し可能
printId(101);
printId("202");

Your ID is: 101
Your ID is: 202

// 特定の文字列のみを許容するリテラル型のユニオン
type ButtonSize = "small" | "medium" | "large";

function createButton(size: ButtonSize) {
  // 実装内容
  console.log(`Creating a ${size} button.`);
}

// 許可された値はOK
createButton("medium");

// 許可されていない値を渡すとコンパイルエラー
// createButton("extra-large");

interface Circle {
  kind: "circle"; // 判別用のプロパティ
  radius: number;
}

interface Square {
  kind: "square"; // 判別用のプロパティ
  sideLength: number;
}

type Shape = Circle | Square;

function getArea(shape: Shape) {
  // shape.radius にアクセスしようとすると、Squareの可能性を指摘されエラーになる
  
  if (shape.kind === "circle") {
    // ここでは shape は Circle 型として扱われる
    return Math.PI * shape.radius ** 2;
  } else {
    // ここでは shape は Square 型として扱われる
    return shape.sideLength ** 2;
  }
}

function formatInput(input: string | number) {
  if (typeof input === "string") {
    // input は string 型に絞り込まれる
    return input.trim().toUpperCase();
  }
  // ここでは input は number 型として扱われる
  return input.toFixed(2);
}

interface Admin {
  name: string;
  privileges: string[];
}

interface Employee {
  name: string;
  startDate: Date;
}

type UnknownUser = Admin | Employee;

function printInformation(user: UnknownUser) {
  console.log("Name: " + user.name);
  
  if ("privileges" in user) {
    // user は Admin 型に絞り込まれる
    console.log("Privileges: " + user.privileges.join(", "));
  }
  
  if ("startDate" in user) {
    // user は Employee 型に絞り込まれる
    console.log("Start Date: " + user.startDate);
  }
}

class FileLogger {
  logToFile(message: string) {
    console.log("Writing to file: " + message);
  }
}

class ConsoleLogger {
  logToConsole(message: string) {
    console.log("Console output: " + message);
  }
}

type Logger = FileLogger | ConsoleLogger;

function executeLog(logger: Logger) {
  if (logger instanceof FileLogger) {
    logger.logToFile("Process started");
  } else {
    logger.logToConsole("Process started");
  }
}

interface Bird {
  fly(): void;
  layEggs(): void;
}

interface Fish {
  swim(): void;
  layEggs(): void;
}

// ユーザー定義の型ガード
function isFish(pet: Bird | Fish): pet is Fish {
  return (pet as Fish).swim !== undefined;
}

function movePet(pet: Bird | Fish) {
  if (isFish(pet)) {
    pet.swim();
  } else {
    pet.fly();
  }
}

type ApiResponse<T> = 
  | { status: "success"; data: T }
  | { status: "error"; message: string; code: number };

async function fetchData(): Promise<ApiResponse<{ id: number; name: string }>> {
  try {
    // 通信処理のシミュレーション
    const response = { id: 1, name: "Sample Data" };
    return { status: "success", data: response };
  } catch (e) {
    return { status: "error", message: "Failed to fetch", code: 500 };
  }
}

async function main() {
  const result = await fetchData();
  
  if (result.status === "success") {
    // 成功時のみ data プロパティにアクセス可能
    console.log(result.data.name);
  } else {
    // 失敗時は message と code を使用
    console.error(`Error ${result.code}: ${result.message}`);
  }
}

type Color = "red" | "blue" | "green";

function getColorName(color: Color) {
  switch (color) {
    case "red":
      return "赤";
    case "blue":
      return "青";
    case "green":
      return "緑";
    default:
      // すべてのケースが網羅されていれば、ここには到達しない
      const _exhaustiveCheck: never = color;
      return _exhaustiveCheck;
  }
}