ユニオン型とインターセクション型を分かりやすく解説

// ユニオン型の基本例
let userId: number | string;  // number型 または string型を受け入れる

// 数値を代入
userId = 12345;
console.log(userId); // 12345

// 文字列を代入
userId = "user-abc-123";
console.log(userId); // "user-abc-123"

// 動物の種類を限定する型
type AnimalType = 'dog' | 'cat' | 'rabbit' | 'hamster';

let myPet: AnimalType;

// 正しい値の代入
myPet = 'dog';     // OK
myPet = 'cat';     // OK

// 間違った値を代入しようとするとエラー
// myPet = 'elephant'; // エラー: Type '"elephant"' is not assignable to type 'AnimalType'

// 関数での活用例
function feedAnimal(animal: AnimalType): string {
    switch (animal) {
        case 'dog':
            return 'ドッグフードをあげました';
        case 'cat':
            return 'キャットフードをあげました';
        case 'rabbit':
            return 'にんじんをあげました';
        case 'hamster':
            return 'ひまわりの種をあげました';
        default:
            return '不明な動物です';
    }
}

console.log(feedAnimal('dog')); // 'ドッグフードをあげました'

// 一般ユーザーの型
interface RegularUser {
    type: 'regular';        // ユーザータイプを識別するフィールド
    name: string;           // ユーザー名
    email: string;          // メールアドレス
}

// 管理者ユーザーの型
interface AdminUser {
    type: 'admin';          // ユーザータイプを識別するフィールド
    name: string;           // ユーザー名
    permissions: string[];  // 権限のリスト
}

// ゲストユーザーの型
interface GuestUser {
    type: 'guest';          // ユーザータイプを識別するフィールド
    sessionId: string;      // セッションID
}

// ユニオン型でまとめる
type User = RegularUser | AdminUser | GuestUser;

// 使用例
function greetUser(user: User): string {
    switch (user.type) {
        case 'regular':
            return `こんにちは、${user.name}さん！新着メールは${user.email}に送信されます。`;
        case 'admin':
            return `管理者の${user.name}さん、ようこそ！権限: ${user.permissions.join(', ')}`;
        case 'guest':
            return `ゲストユーザーさん、ようこそ！セッション: ${user.sessionId}`;
        default:
            return '不明なユーザーです';
    }
}

// テスト用のデータ
const regularUser: RegularUser = {
    type: 'regular',
    name: '田中太郎',
    email: 'tanaka@example.com'
};

const adminUser: AdminUser = {
    type: 'admin',
    name: '管理者',
    permissions: ['read', 'write', 'delete']
};

console.log(greetUser(regularUser)); // こんにちは、田中太郎さん！新着メールは...
console.log(greetUser(adminUser));   // 管理者の管理者さん、ようこそ！権限: ...

// 基本情報の型
interface PersonalInfo {
    name: string;      // 名前
    age: number;       // 年齢
}

// 連絡先情報の型
interface ContactInfo {
    email: string;     // メールアドレス
    phone: string;     // 電話番号
}

// 住所情報の型
interface AddressInfo {
    address: string;   // 住所
    zipCode: string;   // 郵便番号
}

// インターセクション型で全ての情報を組み合わせ
type CompleteUserInfo = PersonalInfo & ContactInfo & AddressInfo;

// 使用例
const user: CompleteUserInfo = {
    // PersonalInfo のプロパティ
    name: '山田花子',
    age: 25,
    // ContactInfo のプロパティ
    email: 'yamada@example.com',
    phone: '090-1234-5678',
    // AddressInfo のプロパティ
    address: '東京都渋谷区1-2-3',
    zipCode: '150-0001'
};

// 全ての情報を表示する関数
function displayUserInfo(user: CompleteUserInfo): void {
    console.log(`名前: ${user.name}`);
    console.log(`年齢: ${user.age}歳`);
    console.log(`メール: ${user.email}`);
    console.log(`電話: ${user.phone}`);
    console.log(`住所: ${user.address} (〒${user.zipCode})`);
}

displayUserInfo(user);

// 型Aの定義
interface TypeA {
    id: number;        // 数値のID
    name: string;      // 名前
    optional?: string; // 省略可能なプロパティ
}

// 型Bの定義
interface TypeB {
    id: string;        // 文字列のID（TypeAと型が異なる）
    email: string;     // メールアドレス
}

// 型Cの定義
interface TypeC {
    name: string;      // 名前（TypeAと同じ型）
    optional: string;  // 必須プロパティ（TypeAでは省略可能）
    phone: string;     // 電話番号
}

// TypeAとTypeBのインターセクション
type AandB = TypeA & TypeB;
// この場合、idプロパティは number & string となり、
// 実際には never型になる（数値かつ文字列は存在しないため）

// TypeAとTypeCのインターセクション
type AandC = TypeA & TypeC;
// この場合は以下のような型になる：
// {
//   id: number;
//   name: string;        // 同じ型なので問題なし
//   optional: string;    // 必須側が優先される
//   email: string;
//   phone: string;
// }

// 実際に使える例
const validUser: AandC = {
    id: 123,
    name: '佐藤次郎',
    optional: '追加情報',  // 必須になる
    phone: '080-9876-5432'
};

console.log(validUser);

// プリミティブ型のインターセクション
type NumberAndString = number & string;  // これは never型になる
type StringAndBoolean = string & boolean; // これも never型になる

// never型の変数を作ってみる
let impossible: NumberAndString;

// どんな値も代入できない
// impossible = 123;      // エラー: Type 'number' is not assignable to type 'never'
// impossible = "hello";  // エラー: Type 'string' is not assignable to type 'never'
// impossible = true;     // エラー: Type 'boolean' is not assignable to type 'never'

console.log('プリミティブ型のインターセクションは実用的ではありません');

// インターフェースの継承を使った場合
interface BaseUser {
    id: number;
    name: string;
}

interface ExtendedUser extends BaseUser {
    email: string;
    createdAt: Date;
}

// インターセクション型を使った場合
type BaseUserType = {
    id: number;
    name: string;
};

type ExtendedUserType = BaseUserType & {
    email: string;
    createdAt: Date;
};

// どちらも同じような結果になる
const user1: ExtendedUser = {
    id: 1,
    name: '鈴木一郎',
    email: 'suzuki@example.com',
    createdAt: new Date()
};

const user2: ExtendedUserType = {
    id: 2,
    name: '高橋二郎',
    email: 'takahashi@example.com',
    createdAt: new Date()
};

// 実用例：APIレスポンスの型を組み合わせる
type ApiResponse<T> = {
    success: boolean;
    message: string;
};

type UserData = {
    userId: number;
    username: string;
};

// ユニオン型とインターセクション型を組み合わせ
type UserApiResponse = ApiResponse<UserData> & {
    data: UserData | null;  // 成功時はUserData、失敗時はnull
};

const successResponse: UserApiResponse = {
    success: true,
    message: 'ユーザー情報を取得しました',
    data: {
        userId: 100,
        username: 'testuser'
    }
};

const errorResponse: UserApiResponse = {
    success: false,
    message: 'ユーザーが見つかりません',
    data: null
};