TypeScript マッピング型

マッピング型(Mapped Types)は、TypeScript において既存の型から新しい型を作成する強力な機能です。

これにより、開発者はプロパティの特性を一括で変更できます。例えば、すべてのプロパティをオプションにしたり、すべてのプロパティを読み取り専用にしたりできます。

マッピング型は、TypeScript の組み込みユーティリティ型を実装する中核技術です。


SVG 図: マッピング型の動作原理 背景 タイトル マッピング型の動作原理 元の型 元の型 interface User { id: number; name: string; } 矢印 マッピング構文 マッピング構文 { [P in keyof T]?: T[P] // オプション修飾子を追加 } 矢印 結果の型 結果の型 type PartialUser = { id?: number; name?: string; } 下半分: 修飾子の説明 マッピング型の修飾子 修飾子の説明 ? プレフィックス オプション修飾子を追加 type Partial<T> readonly プレフィックス 読み取り専用修飾子を追加 type Readonly<T> -? プレフィックス オプション修飾子を削除 type Required<T> as キーワード キー名を再マッピング as `${P}` 矢印マーク

なぜマッピング型が必要か

実際の TypeScript 開発では、既存の型に基づいてバリアント(変種)を作成する必要がよくあります。

たとえば、すべてのプロパティがオプションのバージョンや、すべてのプロパティが読み取り専用のバージョンが必要です。

従来の方法ではこれらの型を手動で定義するため、手間がかかり、エラーも発生しやすくなります。

マッピング型は、これらの型バリアントを自動生成する宣言的な方法を提供します。

概念の説明:マッピング型は `in` キーワードを使用して、keyofとin既存の型のすべてのキーを走査し、各キーに同じ型変換を適用します。


基本的なマッピング型

基本的なマッピング型は、元の型のすべてのキーを走査して新しい型を作成します。

これは Partial や Readonly などのユーティリティ型を実装するための基礎です。

実例

// ユーザーインターフェースを定義
interface User {
    // ユーザーID
    id: number;
    // ユーザー名
    name: string;
    // ユーザーのメールアドレス
    email: string;
}

// Partial ユーティリティ型を実装
// T のすべてのキーを走査し、オプション修飾子 ? を追加
type Partial<T> = {
    // P は keyof T が返すすべてのキーを走査します
    // T[P] は元の型における対応するキーの値の型を取得します
    [P in keyof T]?: T[P];
};

// Partial 型を使用
type PartialUser = Partial<User>;

// PartialUser 型は次と同等です:
// { id?: number; name?: string; email?: string }

// 一部のプロパティのみを提供できます
var user: PartialUser = { name: "Alice" };

console.log("部分ユーザー: " + JSON.stringify(user));

実行結果:

部分用户: {"name":"Alice"}

構文の説明:[P in keyof T]T 型のすべてのキーを走査することを示します。?修飾子はプロパティをオプションにします。


プロパティ修飾子

マッピング型は、プロパティの特性を変更するために複数のプロパティ修飾子をサポートしています。

これらの修飾子は組み合わせて使用でき、さまざまな型変換のニーズに対応できます。

実例

// ユーザーインターフェースを定義
interface User {
    // ユーザー名
    name: string;
    // ユーザーの年齢
    age: number;
}

// readonly マッピングを使用:すべてのプロパティを読み取り専用にする
// readonly 修飾子を追加
type Readonly<T> = {
    readonly [P in keyof T]: T[P];
};

// オプションマッピングを使用:すべてのプロパティをオプションにする(基本版)
type Optional<T> = {
    [P in keyof T]?: T[P];
};

// -? マッピングを使用:オプション修飾子を削除(必須にする)
// -? は既存の ? 修飾子を削除します
type Required<T> = {
    [P in keyof T]-?: T[P];
};

// 読み取り専用型をテスト
var readonlyUser: Readonly<User> = { name: "Alice", age: 25 };
// readonlyUser.age = 30; // エラー: 読み取り専用プロパティは変更できません

// オプション型をテスト
var optionalUser: Optional<User> = { name: "Bob" };

console.log("読み取り専用: " + JSON.stringify(readonlyUser));
console.log("オプション: " + JSON.stringify(optionalUser));

実行結果:

只读: {"name":"Alice","age":25}
可选: {"name":"Bob"}

修飾子の説明:?オプションを追加、-?オプションを削除;readonly読み取り専用を追加、-readonly読み取り専用を削除。


キー名のマッピング

マッピング型はさらに `as` キーワードを使用して、asキー名を再マッピングできます。

これは、キー名の形式を一括で変更する必要がある場合に非常に便利です。

実例

// ユーザーインターフェースを定義
interface User {
    // ユーザーID
    id: number;
    // ユーザー名
    name: string;
    // ユーザーの年齢
    age: number;
}

// as キーワードを使用してキー名を再マッピング
// すべてのキーにプレフィックスを追加
type WithPrefix<T, Prefix extends string> = {
    // テンプレートリテラル型を使用してキーをリネーム
    // Capitalize は先頭文字を大文字にします
    [P in keyof T as `${Prefix}${Capitalize<string & P>}`]: T[P];
};

// WithPrefix を使用して "user" プレフィックスを追加
type PrefixedUser = WithPrefix<User, "user">;

// 変換後の型:
// { userId: number; userName: string; userAge: number }

// プレフィックス付きの型を使用
var user: PrefixedUser = { userId: 1, userName: "Alice", userAge: 25 };

console.log("プレフィックス付き: " + JSON.stringify(user));

実行結果:

带前缀: {"userId":1,"userName":"Alice","userAge":25}

テンプレートリテラル型:`as` を使用すると、`${Prefix}${Capitalize}`動的に新しいキー名を生成できます。


キーのフィルタリング

条件型とマッピング型を組み合わせることで、キーのフィルタリングを実現できます。

これは Omit などのユーティリティ型を実装する際に非常に役立ちます。

実例

// ユーザーインターフェースを定義
interface User {
    // ユーザーID
    id: number;
    // ユーザー名
    name: string;
    // ユーザーのパスワード
    password: string;
    // ユーザーのメールアドレス
    email: string;
}

// Omit を実装:指定したキーを除外
// 条件型を使用してキーをフィルタリング
type Omit<T, K extends keyof T> = {
    // P は T のすべてのキーを走査
    // P が K に代入可能な場合(つまり除外リストにある場合)は never を返す(含めない)
    // それ以外の場合は P を返す(そのキーを保持)
    [P in keyof T as P extends K ? never : P]: T[P];
};

// Omit を使用して password キーを除外
type UserWithoutPassword = Omit<User, "password">;

// 変換後の型:
// { id: number; name: string; email: string }

// password を除外した型を使用
var user: UserWithoutPassword = { id: 1, name: "Alice", email: "a@b.com" };

console.log("パスワードなし: " + JSON.stringify(user));

実行結果:

无密码: {"id":1,"name":"Alice","email":"a@b.com"}

never 型:マッピング型で never をプロパティの型として使用すると、そのプロパティは完全に削除されます。


条件付きマッピング

マッピング型は条件型と組み合わせることで、プロパティの型に応じて異なる変換を適用できます。

これにより、型変換がより柔軟でスマートになります。

実例

// APIレスポンスインターフェースを定義
interface APIResponse {
    // レスポンスデータ
    data: string;
    // エラーメッセージ
    error: string;
    // ロード中かどうか
    isLoading: boolean;
    // タイムスタンプ
    timestamp: number;
}

// 関数型を () => void に変換
// すべてのプロパティを走査し、プロパティの型に応じて条件変換を行う
type FunctionToVoid<T> = {
    // T[P] が関数型の場合は () => void に変換
    // それ以外の場合は元の型を維持
    [P in keyof T]: T[P] extends (...args: any[]) => any
        ? () => void
        : T[P];
};

// 条件付きマッピングを使用
var response: FunctionToVoid<APIResponse> = {
    data: "hello",
    error: "",
    isLoading: false,
    timestamp: Date.now()
};

console.log("レスポンス: " + JSON.stringify(response));

実行結果:

响应: {"data":"hello","error":"","isLoading":false,"timestamp":...}

適用シナリオ:条件付きマッピングは、APIレスポンスの処理や設定オブジェクトのクリーンアップなど、型に応じて異なる処理が必要なシナリオでよく使用されます。


組み込みマッピング型

TypeScript には、マッピング型に基づいて実装された多くのユーティリティ型が組み込まれています。

これらのユーティリティ型は、日々の開発におけるほとんどのニーズを満たすことができます。

実例

// Partial - すべてのプロパティをオプションにする
type P1 = Partial<{ a: string; b: number }>;
// 結果:{ a?: string; b?: number }

// Required - すべてのオプションプロパティを必須にする
type R1 = Required<{ a?: string; b?: number }>;
// 結果:{ a: string; b: number }

// Readonly - すべてのプロパティを読み取り専用にする
type RO1 = Readonly<{ a: string; b: number }>;
// 結果:{ readonly a: string; readonly b: number }

// Pick - 指定されたプロパティを選択する
type PK = Pick<{ a: string; b: number; c: boolean }, "a" | "b">;
// 結果:{ a: string; b: number }

// Omit - 指定されたプロパティを除外する
type OM = Omit<{ a: string; b: number; c: boolean }, "c">;
// 結果:{ a: string; b: number }

// Partial のテスト
console.log("Partial: " + JSON.stringify({} as P1));

// Pick のテスト
console.log("Pick: " + JSON.stringify({ a: "x" } as PK));

ユーティリティ型の組み合わせ:これらの組み込みユーティリティ型はすべて、マップ型と条件型に基づいて実装されています。その原理を理解することで、より上手く使用できます。


注意事項

  • keyof キーワード:型のすべてのキーからなるユニオン型を取得するために使用します。
  • in キーワード:キー名のユニオン型を走査するために使用します。
  • 修飾子の位置:?とreadonlyプロパティ名の前にある場合、修飾子を追加することを示します。
  • マイナス修飾子:-?と-readonly修飾子を削除するために使用します。
  • as キーワード:キー名を再マッピングするために使用します。文字列または数値リテラル型を返す必要があります。

応用:マップ型は条件型やテンプレートリテラル型と組み合わせて、複雑な型変換を実現できます。


まとめ

マップ型は、TypeScriptの型システムにおいて最も強力な機能の1つです。

  • keyof:型のすべてのキーを取得する
  • in:キー名を走査してマッピングする
  • ?:オプショナル修飾子を追加する
  • readonly:読み取り専用修飾子を追加する
  • -?:オプショナル修飾子を削除する
  • as:キー名を再マッピングする

ベストプラクティス:マップ型を上手に活用することで、繰り返しの型定義を大幅に減らし、コードの保守性を向上させることができます。


その他の拡張