【TypeScript】Record型で始める型安全なオブジェクト操作

type RecordType = Record<Keys, Values>;

type NumberRecord = Record<string, number>;

// 使用例
const scores: NumberRecord = {
  math: 90,
  science: 85,
  english: 95
};

// 文字列のキーと数値の値を持つRecord
type StringNumberRecord = Record<string, number>;

const ages: StringNumberRecord = {
  alice: 25,
  bob: 30,
  charlie: 35
};

// 文字列のキーとブール値の値を持つRecord
type StringBooleanRecord = Record<string, boolean>;

const isActive: StringBooleanRecord = {
  user1: true,
  user2: false,
  user3: true
};

// 特定のキーのみを許可するRecord
type UserRoles = Record<'admin' | 'user' | 'guest', string>;

const roleDescriptions: UserRoles = {
  admin: '全ての権限を持つ',
  user: '一般的な権限を持つ',
  guest: '閲覧のみの権限を持つ'
};

// 上記の定義では、以下のようなコードはエラーになります
// const invalidRoles: UserRoles = {
//   admin: '全ての権限を持つ',
//   user: '一般的な権限を持つ'
// };
// エラー: 'guest' プロパティがありません

// ユーザー情報の型定義
type UserInfo = {
  name: string;
  age: number;
  isActive: boolean;
};

// ユーザーIDをキーとし、ユーザー情報を値として持つRecord
type UsersRecord = Record<string, UserInfo>;

const users: UsersRecord = {
  'user1': { name: '田中太郎', age: 28, isActive: true },
  'user2': { name: '鈴木花子', age: 34, isActive: false },
  'user3': { name: '佐藤次郎', age: 22, isActive: true }
};

// Record型を引数に取る関数
function getActiveUsers(users: Record<string, { isActive: boolean }>) {
  const activeUsers: Record<string, { isActive: boolean }> = {};

  for (const id in users) {
    if (users[id].isActive) {
      activeUsers[id] = users[id];
    }
  }

  return activeUsers;
}

// 使用例
const allUsers = {
  'user1': { isActive: true },
  'user2': { isActive: false },
  'user3': { isActive: true }
};

const activeUsers = getActiveUsers(allUsers);
// 結果: { 'user1': { isActive: true }, 'user3': { isActive: true } }

// APIからのレスポンスを管理する例
type ApiResponse = Record<string, unknown>;

async function fetchData(endpoint: string): Promise<ApiResponse> {
  const response = await fetch(`https://api.example.com/${endpoint}`);
  return response.json();
}

// フォームの入力値を管理する例
type FormValues = Record<string, string | number | boolean>;

function handleSubmit(formValues: FormValues) {
  // フォームの送信処理
  console.log('送信データ:', formValues);
}

const userFormData: FormValues = {
  name: '山田太郎',
  age: 30,
  isSubscribed: true
};

handleSubmit(userFormData);

// 状態を表す列挙型
enum Status {
  Pending = 'PENDING',
  InProgress = 'IN_PROGRESS',
  Completed = 'COMPLETED',
  Failed = 'FAILED'
}

// 状態ごとのメッセージを定義
type StatusMessages = Record<Status, string>;

const messages: StatusMessages = {
  [Status.Pending]: '処理待ちです',
  [Status.InProgress]: '処理中です',
  [Status.Completed]: '処理が完了しました',
  [Status.Failed]: '処理に失敗しました'
};

function getStatusMessage(status: Status): string {
  return messages[status];
}

console.log(getStatusMessage(Status.Completed)); // "処理が完了しました"

// ジェネリックを使用した汎用的なRecord型の定義
function createMap<K extends string, V>(keys: K[], valueCreator: (key: K) => V): Record<K, V> {
  return keys.reduce((result, key) => {
    result[key] = valueCreator(key);
    return result;
  }, {} as Record<K, V>);
}

// 使用例
const colors = ['red', 'green', 'blue'] as const;
type Color = typeof colors[number];

const colorCodes = createMap<Color, string>(
  colors as unknown as Color[],
  (color) => {
    switch (color) {
      case 'red': return '#FF0000';
      case 'green': return '#00FF00';
      case 'blue': return '#0000FF';
      default: return '#000000';
    }
  }
);

console.log(colorCodes);
// 出力: { red: '#FF0000', green: '#00FF00', blue: '#0000FF' }

// Record型を使った定義
type UserRecord = Record<string, { name: string; age: number }>;

// インデックスシグネチャを使った定義
type UserIndex = {
  [key: string]: { name: string; age: number };
};

// インターフェースを使った定義
interface User {
  name: string;
  age: number;
  email: string;
}

// 型エイリアスを使った定義
type UserType = {
  name: string;
  age: number;
  email: string;
};

// Record型を使った同様の定義
type UserKeys = 'name' | 'age' | 'email';
type UserRecord = Record<UserKeys, string | number>;

// 良い例
type ValidKeys = 'id' | 'name' | 'email';
type UserData = Record<ValidKeys, string>;

// 避けるべき例（キーが任意の文字列）
type LooseUserData = Record<string, string>;

// 良い例
interface UserDetails {
  name: string;
  age: number;
  isActive: boolean;
}

type UsersMap = Record<string, UserDetails>;

// 避けるべき例（インラインで複雑な型を定義）
type MessyUsersMap = Record<string, {
  name: string;
  age: number;
  isActive: boolean;
  // さらに複雑な型が続く...
}>;

// 読み取り専用のRecord
type ReadonlyConfig = Readonly<Record<string, any>>;

// 必須キーと任意キーを組み合わせる
type RequiredKeys = 'id' | 'name';
type OptionalKeys = 'email' | 'phone';

type UserRecord = Record<RequiredKeys, string> & Partial<Record<OptionalKeys, string>>;

const user: UserRecord = {
  id: '12345',
  name: '山田太郎'
  // email と phone は任意
};