TypeScript インデックス型と keyof キーワード

インデックス型と keyof は、TypeScript でオブジェクト型を操作するための強力なツールです。

これらを使用すると、オブジェクトのプロパティに動的にアクセスし、柔軟な型マッピングを作成できます。


SVG 図:インデックス型と keyof の動作原理 背景 タイトル インデックス型と keyof の動作原理 keyof 演算子 keyof 演算子 type Keys = keyof User // "id" | "name" | "email" 矢印 インデックスアクセス型 インデックスアクセス型 type Value = User["name"] // string 矢印 マップ型 マップ型 type Partial<T> {[P in keyof T]?: T[P]} 下半分:ユースケース インデックス型のユースケース ユースケース1 動的プロパティアクセス ユースケース2 型安全なオブジェクト操作 ユースケース3 汎用ユーティリティ型の作成 矢印マーク

なぜインデックス型が必要なのか

JavaScript では、オブジェクトのプロパティに動的にアクセスする必要がよくあります。

たとえば、関数がオブジェクトのすべてのキーを取得したり、キーに基づいて対応する値の型にアクセスしたりする必要がある場合があります。

インデックス型と keyof を使用すると、型安全性を維持しながら、この動的な性質を型システムで表現できます。

概念:インデックス型はオブジェクトのプロパティへの動的アクセスを可能にする型の一種であり、keyof はオブジェクト型のすべてのキーからなるユニオン型を取得するために使用されます。


keyof 演算子

keyof 演算子は、オブジェクト型のすべてのキーで構成されるユニオン型を取得するために使用します。

例

// ユーザー型を定義
interface User {
    id: number;       // ユーザーID
    name: string;     // ユーザー名
    email: string;    // メールアドレス
    age?: number;     // 年齢(省略可能)
}

// keyof を使用してすべてのキーのユニオン型を取得
// 結果: "id" | "name" | "email" | "age"
type UserKeys = keyof User;

// keyof をテスト
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user: User = {
    id: 1,
    name: "Alice",
    email: "alice@example.com"
};

// name プロパティを取得
const userName: string = getProperty(user, "name");
console.log("ユーザー名: " + userName);

実行結果:

用户名: Alice

説明:keyof は、文字列型ではなく、キー名のリテラル型のユニオン型を返します。


インデックスアクセス型

インデックスアクセス型(Index Access Type)を使用すると、オブジェクトのプロパティの型を取得できます。

例

// ユーザー型を定義
interface User {
    id: number;
    name: string;
    email: string;
}

// インデックスアクセス型を使用してプロパティの型を取得
type UserId = User["id"];      // number
type UserName = User["name"];  // string

// ユニオン型を使用して複数のキーにアクセスできる
type UserIdAndName = User["id" | "name"];  // number | string

// keyof を使用してすべてのプロパティ型のユニオンを取得
type AllUserValues = User[keyof User];  // number | string

// 実際の使用例
function getValue<T, K extends keyof T>(obj: T, key: K): T[K] {
    return obj[key];
}

const user: User = { id: 1, name: "Bob", email: "bob@test.com" };

// id の型を取得
const idValue: number = getValue(user, "id");
console.log("ID: " + idValue);

// name の型を取得
const nameValue: string = getValue(user, "name");
console.log("Name: " + nameValue);

インデックスアクセス:角括弧 [] を使用すると、オブジェクト型の特定のプロパティ型にアクセスでき、非常に強力で柔軟です。


マップ型の基礎

マップ型を使用すると、既存の型に基づいて新しい型を作成し、そのすべてのキーを走査できます。

例

// ユーザー型を定義
interface User {
    id: number;
    name: string;
    email: string;
    age: number;
}

// すべてのプロパティを省略可能にする
type PartialUser = Partial<User>;

// すべてのプロパティを読み取り専用にする
type ReadonlyUser = Readonly<User>;

// カスタムマップ型:すべてのプロパティを省略可能にして文字列化する
type Stringify<T> = {
    [P in keyof T]: string;
};

type StringifiedUser = Stringify<User>;

// 実際の使用例
const partialUser: PartialUser = {
    id: 1,
    name: "Alice"
    // email と age は省略可能
};

const readonlyUser: ReadonlyUser = {
    id: 1,
    name: "Bob",
    email: "bob@test.com",
    age: 25
};
// readonlyUser.name = "Charlie"; // エラー:読み取り専用

console.log("一部のユーザー: " + partialUser.name);
console.log("読み取り専用ユーザー: " + readonlyUser.name);

マップ型:[P in keyof T] 構文を使用して型のすべてのキーを走査することは、ユーティリティ型を作成するための基礎です。


キーの型を制約する

keyof とジェネリック制約を使用して、関数が受け取るキーを制限します。

例

// 設定型を定義
interface Config {
    apiUrl: string;
    timeout: number;
    retry: boolean;
}

// 存在するキーのみ取得できる
function getConfigValue<T, K extends keyof T>(
    config: T,
    key: K
): T[K] {
    return config[key];
}

// 設定を定義
const config: Config = {
    apiUrl: "https://api.example.com",
    timeout: 5000,
    retry: true
};

// 正しい:キーが存在する
const url: string = getConfigValue(config, "apiUrl");
const timeoutVal: number = getConfigValue(config, "timeout");

// エラー:キーが存在しない(TypeScript がエラーを報告する)
// const invalid = getConfigValue(config, "unknown");

console.log("API URL: " + url);
console.log("Timeout: " + timeoutVal);

制約:K extends keyof T により、渡されるキーが必ずオブジェクト上に存在するキーであることが保証され、実行時エラーを防ぎます。


特定の型のプロパティのみを取得する

オブジェクト型から特定の型のプロパティキーを抽出します。

例

// 混合型を定義
interface Mixed {
    id: number;
    name: string;
    age: number;
    email: string;
    active: boolean;
}

// すべての文字列型のキーを抽出
type StringKeys<T> = {
    [K in keyof T]: T[K] extends string ? K : never;
}[keyof T];

// すべての数値型のキーを抽出
type NumberKeys<T> = {
    [K in keyof T]: T[K] extends number ? K : never;
}[keyof T];

// テスト
type StringProps = StringKeys<Mixed>;  // "name" | "email"
type NumberProps = NumberKeys<Mixed>;  // "id" | "age"

// 実際の応用:文字列プロパティの値を取得
function getStringProps<T, K extends StringKeys<T>>(
    obj: T,
    keys: K[]
): T[K][] {
    return keys.map(key => obj[key]);
}

const mixed: Mixed = {
    id: 1,
    name: "Alice",
    age: 25,
    email: "alice@test.com",
    active: true
};

const strings = getStringProps(mixed, ["name", "email"]);
console.log("文字列プロパティ: " + strings.join(", "));

条件型:条件型とマップ型を組み合わせることで、複雑な型のフィルタリングや抽出を実現できます。


配列型を走査する

インデックス型を使用して配列やタプルを操作します。

例

// タプル型を定義
type Tuple = [string, number, boolean];

// タプルの要素型を取得
type First = Tuple[0];   // string
type Second = Tuple[1];  // number
type Third = Tuple[2];   // boolean

// number を使用してすべての要素型を取得
type AllElements = Tuple[number];  // string | number | boolean

// 配列の要素型を取得
type StringArray = string[];
type ArrayElement = StringArray[number];  // string

// 実際の応用:関数のオーバーロード
function getElement<T extends any[]>(
    arr: T,
    index: number
): T[indexof T] | undefined {
    return index < arr.length ? arr[index] : undefined;
}

const tuple: Tuple = ["hello", 123, true];
const arr: string[] = ["a", "b", "c"];

console.log("タプル要素 + getElement(tuple, 0));
console.log("配列要素 + getElement(arr, 1));

タプルのインデックス:タプルは数値インデックスを使用でき、各インデックスが特定の要素型に対応します。これは配列ではできません。


注意事項

  • keyof はユニオン型を返す:keyof はキー名のリテラル型のユニオン型を返す
  • インデックスアクセスの安全性:アクセスするキーが対象の型に存在することを確認する
  • ジェネリック制約:extends keyof を使用してジェネリックパラメータを制約する
  • マップ型には in キーワードが必要:マップ型は [P in keyof T] 構文を使用する

ベストプラクティス:インデックス型は汎用ユーティリティ型を作成するための基盤であり、習得すれば型操作の能力を大幅に向上させることができます。


まとめ

インデックス型と keyof は、TypeScript の型システムの重要な構成要素です。

  • keyof:オブジェクト型のすべてのキーを取得する
  • インデックスアクセス:キーを使用してプロパティの型を取得する
  • マップ型:既存の型に基づいて新しい型を作成する
  • 型安全性:動的プロパティアクセスの型安全性を確保する

アドバイス:オブジェクトのプロパティを操作する必要がある場合は、インデックス型を優先的に使用して型安全性を維持してください。

その他の拡張