C# 出身者のための TypeScript mapped types と keyof（既存の型から型を作る）

みなさんこんにちは！ヒロポンです！

C# でプロパティを機械的に扱いたいとき、私はずっとリフレクション頼みでした。Type.GetProperties() で全プロパティを取る。あとは foreach で回す。あの手癖です。

で、TypeScript を触り始めると Partial<User>（全プロパティを省略可能にした型）みたいな組み込みのユーティリティ型にぶつかります。便利。めちゃくちゃ便利。便利なんだけど、ある日ふと「これ、中身どうなってるん？？ 自分でも似たの作れるんかな」と気になったんですよね。

その答えが TypeScript mapped types keyof です。

keyof で型のキー一覧を取る。[K in keyof T] で全プロパティを走査する。そこに ? や readonly を付け外しする。これだけで Partial みたいな型を自分の手で組み立てられます。

面白いのは、そのタイミング。C# のリフレクションが実行時にやることを、TypeScript はコンパイル時に型としてやる。今回はこの対比を軸に、C# 出身の目線で追っていきます。

C# のリフレクション と TypeScript の型操作、まず対応マップ

先に全体像を置いておきます。「C# でこう書いてたこと」が「TS だとこれ」に対応する、という地図です。

一番の違いは最後の行です。C# のリフレクションは動かしてみないと分からない。一方の TS は、コードを書いた瞬間にエディタが赤線を出してくれる。この差が、いい感じに効いてくるんですよね！！

では keyof から順に。

keyof — 型のキー一覧を取る

keyof は、型の全プロパティ名を文字列リテラルのユニオン型として取り出します。

interface User {
  id: number;
  name: string;
  age: number;
}

type UserKeys = keyof User;   // "id" | "name" | "age" という型
const k: UserKeys = "name";   // OK。"xxx" みたいな存在しないキーは型エラー

発想としては C# の Type.GetProperties() に近い。ただ、返ってくるのは実行時の配列ではなく型です。だから k に "id" "name" "age" 以外を入れようとすると、その場で型エラー。存在しないプロパティ名を弾ける、というわけです。

ここまでで「keyof はキー名の一覧を"型として"取るやつ」。まずこれだけ押さえておけばOKです。

[K in keyof T] — 全プロパティを走査する

keyof で取ったキーを使って、全プロパティを1つずつ走査しながら新しい型を組み立てる。これが mapped types です。書き方は [K in keyof T]。

// 全プロパティを省略可能(?)にする → Partial の自作版
type MyPartial<T> = { [K in keyof T]?: T[K] };

const p: MyPartial<User> = { name: "太郎" };   // id も age も省略OK

[K in keyof T] は「T の各キー K について」という意味。C# の foreach (var prop in type.GetProperties()) を、型のレベルでやってるイメージです。T[K] は「そのキーの値の型」（name なら string）。

手で書いた場合と並べると、ありがたみがはっきりします。

Before は、User にプロパティが増えるたびに手で足す。足し忘れると事故る。After は元の型を見に行くので、追従が勝手に効きます。

これ、実は組み込みの Partial<T> とほぼ同じ定義なんです。つまり Partial の中身を自分で書けた、ということ。こんな感じで正体が見えてくると、ちょっと嬉しくなりますよね。

ここまでで「[K in keyof T] は全プロパティを走査して型を作るやつ」まで来ました。

修飾子（? / readonly）を付けたり外したりする

mapped types の強みは、走査しながら修飾子を付け外しできるところです。

• 付ける: ?（省略可能に）、readonly（読み取り専用に）
• 外す: -?（必須に戻す）、-readonly（可変に戻す）

// readonly を付与 → Readonly の自作版
type MyReadonly<T> = { readonly [K in keyof T]: T[K] };

// -? で全部を必須に戻す → Required の自作版
type MyRequired<T> = { [K in keyof T]-?: T[K] };

// -readonly で readonly を外して可変に
type Mutable<T> = { -readonly [K in keyof T]: T[K] };

? を素で書けば「付与」。頭に - を足せば「除去」。これで Partial も Required も Readonly も、いい感じに自分の手で作れてしまいます。

ここまでで、修飾子の付け外しまで含めて、既存の型から新しい型を機械的に作れるようになりました。

ミニマム検証 — 手元の tsc で確かめる

型の話は、実際に tsc（TypeScript コンパイラ）に通すと一気に腹落ちします。次のコードを1ファイルに貼って、tsc --noEmit --strict で型チェックしてみてください。

interface User { id: number; name: string; age: number; }

type MyReadonly<T> = { readonly [K in keyof T]: T[K] };
type Mutable<T>    = { -readonly [K in keyof T]: T[K] };

const r: MyReadonly<User> = { id: 1, name: "花子", age: 30 };
// r.id = 2;   // ← ここのコメントを外すと readonly でエラーになる

const m: Mutable<MyReadonly<User>> = { id: 2, name: "x", age: 1 };
m.id = 99;     // Mutable で readonly を外したので、これは書き換えOK