型パフォーマンス最適化

TypeScriptの型システムは強力ですが、複雑な型定義はコンパイル時間に影響を与える可能性があります。型パフォーマンスを最適化することで、開発体験を向上させることができます。

なぜ型パフォーマンスが重要なのか

型計算の課題

問題のあるコード:

// 非常に複雑な型計算
type DeepNested<T> = T extends any
  ? {
      [K in keyof T]: T[K] extends object
        ? T[K] extends any[]
          ? DeepNested<T[K][number]>[]
          : DeepNested<T[K]>
        : T[K];
    }
  : never;

type ComplexType = DeepNested<{
  a: { b: { c: { d: { e: string } } } };
  f: { g: { h: { i: { j: number } } } };
}>;

// 問題点:
// - コンパイル時間が長い
// - 型エラーのメッセージが複雑
// - IDEの応答が遅い

最適化されたコード:

// 型の深さを制限
type DeepNested<T, Depth extends number = 3> = Depth extends 0
  ? T
  : T extends object
  ? {
      [K in keyof T]: T[K] extends any[]
        ? DeepNested<T[K][number], Prev<Depth>>[]
        : DeepNested<T[K], Prev<Depth>>;
    }
  : T;

// メリット:
// - コンパイル時間が短い
// - 型エラーのメッセージが明確
// - IDEの応答が速い

メリット:

コンパイル時間: 型計算の最適化によりコンパイルが高速化
IDE応答: 型チェックが高速化されIDEが快適に動作
エラーメッセージ: 複雑な型エラーのメッセージが明確になる

型の分割と再利用

大きな型の分割

// 問題: 大きな型定義
type LargeConfig = {
  database: {
    host: string;
    port: number;
    username: string;
    password: string;
    // ... 50個のフィールド
  };
  api: {
    baseUrl: string;
    timeout: number;
    // ... 50個のフィールド
  };
  // ... 10個のセクション
};

// 解決: 型の分割
type DatabaseConfig = {
  host: string;
  port: number;
  username: string;
  password: string;
};

type ApiConfig = {
  baseUrl: string;
  timeout: number;
};

type LargeConfig = {
  database: DatabaseConfig;
  api: ApiConfig;
};

条件型の最適化

早期リターン

// 問題: 複雑な条件型
type Process<T> = T extends string
  ? T extends `${infer U}`
    ? U extends `${infer V}`
      ? V extends `${infer W}`
        ? W
        : V
      : U
    : T
  : never;

// 解決: 早期リターン
type Process<T> = T extends string
  ? T extends `${infer U}${string}`
    ? U
    : T
  : never;

条件型のキャッシュ

// 問題: 同じ型計算を繰り返す
type A<T> = T extends string ? string : number;
type B<T> = T extends string ? string : number;
type C<T> = A<T> | B<T>; // 同じ計算を2回実行

// 解決: 型エイリアスでキャッシュ
type StringOrNumber<T> = T extends string ? string : number;
type A<T> = StringOrNumber<T>;
type B<T> = StringOrNumber<T>;
type C<T> = A<T> | B<T>; // 1回だけ計算

マップ型の最適化

不要なマッピングの回避

// 問題: すべてのプロパティをマッピング
type Optional<T> = {
  [K in keyof T]: T[K] | undefined;
};

// 解決: 必要なプロパティだけをマッピング
type Optional<T> = {
  [K in keyof T]?: T[K];
};

ユーティリティ型の最適化

組み込み型の使用

// 問題: 独自の実装
type MyPartial<T> = {
  [K in keyof T]?: T[K];
};

// 解決: 組み込み型を使用
type MyPartial<T> = Partial<T>;

実践的な例: 型パフォーマンスの測定

// 型の複雑さを測定するためのヘルパー
type MeasureComplexity<T> = T extends any
  ? {
      depth: number;
      keys: keyof T extends never ? 0 : number;
    }
  : never;

// 型の最適化前後を比較
type Before = {
  a: { b: { c: { d: string } } };
  e: { f: { g: { h: number } } };
};

type After = {
  a: Nested<string, 4>;
  e: Nested<number, 4>;
};

type Nested<T, D extends number> = D extends 0
  ? T
  : { value: Nested<T, Prev<D>> };

tsconfig.jsonの最適化

{
  "compilerOptions": {
    "skipLibCheck": true, // 型定義ファイルのチェックをスキップ
    "incremental": true, // インクリメンタルコンパイル
    "tsBuildInfoFile": ".tsbuildinfo" // ビルド情報のキャッシュ
  }
}

まとめ

型パフォーマンス最適化のポイント：

型の分割: 大きな型を小さな型に分割
条件型の最適化: 早期リターンとキャッシュ
組み込み型の使用: 標準ライブラリの型を活用
tsconfig.jsonの最適化: コンパイラオプションの調整

型パフォーマンスの最適化は、開発体験を向上させる重要な要素です。適切に最適化することで、コンパイル時間とIDEの応答性を大幅に改善できます。