TypeScriptユーティリティ型を完全攻略！10のコード例で理解しよう

はじめに
●TypeScriptユーティリティ型とは
- ○基本の概念：ユーティリティ型の魅力
●TypeScriptユーティリティ型の使い方
●TypeScriptユーティリティ型の応用例
●注意点と対処法
- ○型の互換性と注意点
- ○ユーティリティ型のパフォーマンスに関する考慮点
●カスタマイズ方法
- ○既存のユーティリティ型の拡張
- ○独自のユーティリティ型の作成と共有
まとめ

はじめに

TypeScriptは、JavaScriptのスーパーセットとして、型に関する多くの強力な機能を提供しています。

ユーティリティ型を利用することで、コードの再利用性を向上させ、型の安全性を保ちながら柔軟な表現が可能になります。

この記事では、TypeScriptのユーティリティ型の基礎から応用、そしてカスタマイズ方法まで、初心者でもわかる10のコード例を用いて徹底解説します。

TypeScriptを既に使用している方はもちろん、これからTypeScriptを学ぶ方にとっても、ユーティリティ型の知識は非常に有益です。

これを機に、TypeScriptの新たな手法を手に入れて、より洗練されたコーディングを目指しましょう。

それでは、TypeScriptのユーティリティ型を一緒に学んでいきましょう。

●TypeScriptユーティリティ型とは

TypeScriptのユーティリティ型は、様々な型操作を簡単に実現するためのツールとして提供されています。

これにより、複雑な型操作をシンプルに表現できるようになります。

例えば、あるオブジェクトの全てのプロパティをオプションにしたい、特定のプロパティだけを取得したい、といったことが簡単に行えるようになります。

○基本の概念：ユーティリティ型の魅力

ユーティリティ型は、型の変換や組み合わせを行う際の助けとなるツールとして設計されています。

これにより、TypeScriptでのコード記述が大幅にシンプルになるとともに、コードの再利用性も向上します。

このコードでは、TypeScriptのPartialユーティリティ型を使って、オブジェクトの全てのプロパティをオプショナルにする例を紹介しています。

この例では、User型が定義されており、その後でPartial<User>としてオブジェクトのプロパティを全てオプショナルにしています。

// User型の定義
type User = {
    name: string;
    age: number;
};

// User型の全てのプロパティをオプショナルにした型を作成
type OptionalUser = Partial<User>;

const user1: OptionalUser = { name: "Taro" }; // ageプロパティは省略可能
const user2: OptionalUser = { age: 25 };      // nameプロパティは省略可能

このように、Partialを使用することで簡単に全てのプロパティをオプショナルにすることができます。

特定の場面で必要となるプロパティのみを指定してオブジェクトを作成することが可能となり、柔軟なコード設計が実現できます。

ユーティリティ型を使用することで、従来よりも簡潔かつ明瞭に型操作が行えるようになるため、TypeScriptのコードの品質と効率が大幅に向上します。

●TypeScriptユーティリティ型の使い方

TypeScriptはJavaScriptのスーパーセットとして知られ、型システムの導入によって、より堅牢なプログラムを作成することができます。

そして、その型システムの中で非常に強力な機能としてユーティリティ型が存在します。

ユーティリティ型を使うことで、既存の型を再利用しつつ、その型に様々な操作を行うことができるのです。

ここでは、TypeScriptのユーティリティ型の基本的な使い方について、サンプルコードを交えて解説します。

○サンプルコード1：Partialの基本的な使用方法

このコードではPartialユーティリティ型を使って、オブジェクトの型から新しい型を作成するコードを表しています。

この例ではオブジェクトの全てのプロパティをオプショナルにして、部分的なオブジェクトを作成しています。

// Userという型を定義
type User = {
    id: number;
    name: string;
    email: string;
};

// Partialを使用して、User型の全てのプロパティをオプショナルにする
type PartialUser = Partial<User>;

// PartialUser型の変数を作成
const user1: PartialUser = {
    id: 1
};

const user2: PartialUser = {
    id: 2,
    name: "Taro"
};

上記のコードでは、まずUser型を定義しています。このUser型にはid、name、emailの3つのプロパティが存在します。

その後、Partialユーティリティ型を使用して、User型の全てのプロパティをオプショナルにした新しい型PartialUserを作成しています。

その結果、user1やuser2のように、部分的なオブジェクトを作成することができるようになりました。

このように、Partialはオブジェクトの型のプロパティをすべてオプショナルに変換する際に非常に役立つユーティリティ型です。

例えば、APIから部分的なデータを受け取る際や、フォームの入力データを扱う際など、全てのプロパティが必須でないケースでこのPartialを活用することができます。

このサンプルコードの場合、user1にはidだけが定義されていますが、これは問題なくPartialUser型として認識されます。

同様にuser2にはidとnameが定義されており、emailが省略されていますが、これもPartialUser型として問題ありません。

○サンプルコード2：Readonlyを活用したオブジェクトの変更防止

TypeScriptのユーティリティ型の中でも特に便利であるReadonlyについて解説します。

このユーティリティ型は、オブジェクトのプロパティを読み取り専用に変更する際に使用します。

オブジェクトのプロパティを変更不可能にすることで、データの安全性を保つことができます。

このコードでは、Readonlyを使ってオブジェクトのプロパティを読み取り専用にするコードを表しています。

この例では、Person型のオブジェクトを読み取り専用にして、その後でそのオブジェクトのプロパティを変更しようとするとエラーが発生することを表しています。

// Person型の定義
type Person = {
  name: string;
  age: number;
};

// Readonlyを使用してPerson型のオブジェクトを読み取り専用にする
const readonlyPerson: Readonly<Person> = {
  name: "太郎",
  age: 25
};

// 以下のコードはエラーとなる。readonlyPersonのプロパティは変更できないため。
// readonlyPerson.name = "花子";

上のコードを実行すると、readonlyPerson.name = "花子";の部分でエラーが発生します。

これはreadonlyPersonのプロパティが読み取り専用であるため、変更を試みるとTypeScriptの型チェックによりエラーが検出されるからです。

このように、Readonlyを活用することで、プログラムの中でデータの変更を意図的に防止することができます。

さらに、応用例として、関数の引数や戻り値としてオブジェクトを渡す場面でReadonlyを使用することで、関数内でのデータの変更を防ぐこともできます。

// オブジェクトのプロパティを表示する関数
function displayPersonInfo(person: Readonly<Person>): void {
  console.log(`名前: ${person.name}, 年齢: ${person.age}`);
}

// 上記の関数にreadonlyPersonを渡す
displayPersonInfo(readonlyPerson);

この例では、displayPersonInfo関数内でpersonオブジェクトのプロパティを変更しようとすると、同様にエラーが発生します。

関数の引数としてオブジェクトを渡す場合、Readonlyを活用することで、意図しないデータの変更を予防することが可能となります。

○サンプルコード3：Pickで特定のプロパティを選択

TypeScriptのユーティリティ型の中には、オブジェクト型から特定のプロパティを取り出すことができる「Pick」という型があります。

このコードでは、Pickを使用して特定のプロパティを選択する方法を表します。

この例では、あるオブジェクトからいくつかのプロパティだけを抽出して新たなオブジェクト型を作成しています。

// 元の型を定義
interface User {
    id: number;
    name: string;
    email: string;
    age: number;
}

// Pickを用いて、idとnameのみを持つ新しい型を定義
type PickedUser = Pick<User, 'id' | 'name'>;

// PickedUserの型の変数を定義
const simpleUser: PickedUser = {
    id: 1,
    name: '山田太郎'
};

上記のコードでは、元々Userというオブジェクト型があり、この中にはid, name, email, ageという4つのプロパティが定義されています。

しかし、ある場面ではidとnameだけを扱いたい場合があるかと思います。

そのような場合にPickを使用して、特定のプロパティだけを持つ新しい型PickedUserを作成しています。

このPickedUser型の変数simpleUserを定義するときには、idとnameのみを持つオブジェクトを代入する必要があります。

この例から、ある型の中から必要なプロパティだけを取り出して、新しい型を作成する場面でPickが非常に便利であることがわかります。

このコードを実際に実行すると、simpleUserという変数にはidとnameという2つのプロパティのみが含まれています。

そのため、この変数を使って処理を行う際には、それ以外のプロパティ（emailやageなど）にはアクセスすることができません。

これにより、不要なプロパティに誤ってアクセスしてしまうようなミスを防ぐことができます。

○サンプルコード4：Omitを使ってプロパティを除外

TypeScriptにおいて、特定のオブジェクトからいくつかのプロパティを除外したい場合、ユーティリティ型の「Omit」を活用することができます。

ここでは、Omitを使ってオブジェクトからプロパティを取り除く方法を紹介します。

このコードではOmitユーティリティ型を使って、オブジェクトの特定のプロパティを除外する方法を表しています。

この例では、Person型から「age」プロパティを除外して、新しい型を作成しています。

type Person = {
    name: string;
    age: number;
    address: string;
}

// Omitを使用して、Person型から「age」プロパティを除外
type PersonWithoutAge = Omit<Person, 'age'>;

const person: PersonWithoutAge = {
    name: "Taro",
    address: "Tokyo"
};

上記のコードを実行すると、PersonWithoutAge型のオブジェクトpersonには、「name」と「address」のプロパティのみが含まれています。

「age」プロパティは含まれていません。

また、Omitは、特定のプロパティを除外するだけでなく、複数のプロパティを同時に除外することも可能です。

下記のサンプルコードでは、Person型から「age」と「address」の2つのプロパティを除外しています。

// Omitを使用して、Person型から「age」と「address」の2つのプロパティを除外
type PersonNameOnly = Omit<Person, 'age' | 'address'>;

const person2: PersonNameOnly = {
    name: "Hanako"
};

この場合、PersonNameOnly型のオブジェクトperson2は「name」のプロパティのみを持っています。

さらに、Omitは他のユーティリティ型とも組み合わせて使うこともできます。

下記のサンプルコードでは、OmitとPickを組み合わせて、オブジェクトから特定のプロパティを取得し、それ以外のプロパティを除外しています。

// Pickを使用して、Person型から「name」と「address」の2つのプロパティを取得
type PickedPerson = Pick<Person, 'name' | 'address'>;

// Omitを使用して、PickedPerson型から「address」プロパティを除外
type NameOnlyFromPicked = Omit<PickedPerson, 'address'>;

const person3: NameOnlyFromPicked = {
    name: "Jiro"
};

このように、Omitは非常に柔軟に利用することができ、多様なシチュエーションでオブジェクトの型をカスタマイズするのに役立ちます。

このOmitユーティリティ型を活用することで、不要なプロパティを持たせないように型を定義することが可能となり、より安全かつ明瞭なコードの実装が期待できます。

特に大規模なプロジェクトや複数の開発者との協力時には、このような型の柔軟性が求められる場面が増えてくるでしょう。

○サンプルコード5：Recordでキーと値のペアを定義

TypeScriptにおけるユーティリティ型の中で、非常に強力で柔軟性に富むRecordについて解説します。

このコードでは、Recordを使ってキーと値のペアを効果的に定義する方法を表しています。

この例では、特定のキーのセットと、それらのキーに関連付けられる値の型を定義して、オブジェクトの形を強制する方法を探求しています。

// Recordの基本的な形
type MyRecord = Record<string, number>;

const example: MyRecord = {
    key1: 1,
    key2: 2,
    key3: 3
    // key4: 'four'  // この行をコメントアウトを外すとエラーが発生する
};

このコードでは、MyRecordという型を定義しています。Record<string, number>は、すべてのキーがstring型で、それに対応する値がnumber型でなければならないということを表しています。

したがって、key4: 'four'という行をコメントアウトを外すと、その値がnumber型ではないためエラーが発生します。

さらに、特定のキーセットを持つオブジェクトを定義する場合の方法も考えてみましょう。

// 特定のキーセットを持つRecordの定義
type UserRoles = Record<'admin' | 'user' | 'guest', string>;

const roles: UserRoles = {
    admin: '全ての権限',
    user: '基本的な権限',
    guest: '閲覧のみの権限'
    // moderator: 'モデレーターの権限'  // この行をコメントアウトを外すとエラーが発生する
};

この例では、キーが'admin', 'user', 'guest'のいずれかであるオブジェクトを定義しています。

これらのキーに関連する値は、すべてstring型である必要があります。

したがって、moderator: 'モデレーターの権限'という行をコメントアウトを外すと、そのキーが定義されていないためエラーが発生します。

●TypeScriptユーティリティ型の応用例

TypeScriptのユーティリティ型は非常に強力なツールとして知られており、それを応用することで、より複雑な型操作が可能となります。

ここでは、ユーティリティ型の応用例として、複数のユーティリティ型を組み合わせた実例を紹介します。

○サンプルコード6：複数のユーティリティ型を組み合わせる

このコードでは、PartialとPickを使って、オブジェクトの特定のプロパティを部分的に選択し、そのプロパティのみを持つ新しい型を作成する例を表しています。

この例では、User型の中からnameとageプロパティだけを部分的に取り出して、新しい型を定義しています。

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

type PartialPickUser = Partial<Pick<User, 'name' | 'age'>>;

const user: PartialPickUser = {
  name: "Taro",
  age: 25
};

この例を見ると、PartialPickUserはnameとageプロパティのみを持つことができる型となり、それ以外のプロパティは持つことができません。

したがって、userオブジェクトでは、nameとageプロパティを持つことが確認できます。

このように、TypeScriptのユーティリティ型を組み合わせることで、非常に柔軟な型操作が可能となります。

特に、大規模なプロジェクトで多くの型を管理しなければならない場合、ユーティリティ型の組み合わせをうまく使うことで、型の再利用性を高めることができます。

○サンプルコード7：カスタムユーティリティ型の作成

TypeScriptは、型の再利用や型の変換を容易にするためのユーティリティ型を多数提供しています。

しかし、特定のプロジェクトや要件に合わせて、オリジナルのユーティリティ型を作成することも可能です。

このコードでは、カスタムユーティリティ型の作成方法を表しています。

この例では、特定のキーを持つオブジェクトのみを許容するユーティリティ型を作成しています。

// 2つの文字列リテラル型 'id' と 'name' を持つオブジェクトの型を定義
type UserKeys = 'id' | 'name';

// カスタムユーティリティ型の作成
type CustomUtility<T> = {
  [K in keyof T]: K extends UserKeys ? T[K] : never;
};

// 使用例
type User = {
  id: number;
  name: string;
  age: number;
};

type FilteredUser = CustomUtility<User>;  // { id: number; name: string; age: never; }

この例のCustomUtility<T>というユーティリティ型は、与えられた型TからUserKeysに定義されたキーのみを許容し、それ以外のキーにはnever型を割り当てるものとなっています。

このため、FilteredUser型はageの型としてneverを持つことになります。

この方法を使うことで、特定のキーのみを持つオブジェクト型を簡単に作成することができます。

これは、APIのレスポンス型やフォームデータの型など、限定的なキーのみを持つオブジェクトを扱う際に非常に役立ちます。

このコードの実行結果、FilteredUser型は{ id: number; name: string; age: never; }となり、ageプロパティは使用できないことが確認できます。

これにより、不要なプロパティや予期せぬプロパティの追加を防ぐことができます。

さらに、このカスタムユーティリティ型は他の型と組み合わせても使用できます。

例えば、次のようにして複数の型の共通部分のみを取得するユーティリティ型を作成することも可能です。

type CommonProperties<T, U> = {
  [K in keyof T & keyof U]: T[K] & U[K];
};

// 使用例
type Product = {
  id: number;
  name: string;
  price: number;
};

type Order = {
  id: number;
  name: string;
  quantity: number;
};

type Common = CommonProperties<Product, Order>;  // { id: number; name: string; }

この例では、Product型とOrder型の共通のプロパティのみを取得するCommon型を作成しています。

このような型は、複数のオブジェクト間で共通の操作や処理を行いたい際に役立ちます。

また、こちらのコードの結果として、Common型は{ id: number; name: string; }となり、Product型とOrder型の共通のプロパティのみが抽出されることが確認できます。

○サンプルコード8：ユーティリティ型を活用した実践的な関数の定義

このコードでは、ユーティリティ型を使って実践的な関数の定義をする方法を表しています。

この例では、関数の引数や戻り値の型を安全に扱うためのテクニックを表します。

type User = {
    id: number;
    name: string;
    email: string;
};

function updateUser(user: User, fieldsToUpdate: Partial<User>): User {
    return { ...user, ...fieldsToUpdate };
}

// 使用例
const user: User = {
    id: 1,
    name: 'Taro',
    email: 'taro@example.com'
};

const updatedUser = updateUser(user, { email: 'new-email@example.com' });

このコードでは、Userという型を定義しています。

そして、ユーティリティ型のPartialを使用して、Userの部分的な情報を更新する関数updateUserを定義しています。

この関数は、元のユーザーオブジェクトと更新したいフィールドを持ったオブジェクトを受け取り、更新されたユーザーオブジェクトを返します。

上記のコードを実行すると、updatedUserは次のようなオブジェクトとなります。

{
    id: 1,
    name: 'Taro',
    email: 'new-email@example.com'
}

この例からもわかるように、ユーティリティ型は非常に強力なツールとして活用できます。

特に、部分的な情報の更新や抽出、除外など、日常的に行われる型の操作を簡単に行える点が大きな魅力となっています。

○サンプルコード9：大規模なプロジェクトでのユーティリティ型の活用

大規模なプロジェクトにおいては、多様なデータ構造や、それを取り扱う関数・クラスが登場します。

その中でTypeScriptのユーティリティ型は、効率的に型を制御する強力な道具として機能します。

このセクションでは、大規模プロジェクトでのユーティリティ型の具体的な使用例とその利点について解説します。

□モジュール間でのデータ構造の共有

大規模プロジェクトでは、多数のモジュールやコンポーネントが存在します。

モジュールAからモジュールBへデータを渡す場合、そのデータ構造を厳密に定義し、変更があった場合に迅速に対応することが求められます。

このコードではPickを使って、特定のプロパティのみを取り出すことができる型を作成しています。

この例では、ユーザーの情報からnameとemailのみを取り出す型を定義しています。

// 全ユーザー情報の型
type UserInfo = {
    id: number;
    name: string;
    email: string;
    age: number;
    address: string;
};

// nameとemailのみを取り出す型
type UserContact = Pick<UserInfo, 'name' | 'email'>;

function sendEmail(user: UserContact) {
    // email送信の処理...
}

このように、モジュール間で必要な情報のみを厳格に定義し、他の不要な情報を排除することができます。

□APIレスポンスの型定義

大規模プロジェクトでのAPIのやり取りは頻繁に行われます。

APIから受け取ったデータの型を厳密に定義することで、予期せぬバグを防ぐことができます。

このコードではPartialを使って、すべてのプロパティがオプショナルな型を定義しています。

この例ではAPIから受け取るユーザー情報の一部のプロパティが欠けている可能性がある場合の型を表しています。

// APIから受け取る可能性のあるユーザー情報の型
type APIResponse = Partial<UserInfo>;

function fetchUserData(): Promise<APIResponse> {
    // APIからのデータ取得の処理...
    // 例えば、ageとaddressが欠けている場合でも問題なく扱うことができる
}

APIから受け取るデータに一部のプロパティが欠けている場合でも、この型を使用して安全にデータを扱うことができます。

○サンプルコード10：ユーティリティ型の限界とその克服方法

TypeScriptのユーティリティ型は非常に強力なツールですが、当然ながらその使用には一定の限界が存在します。

ここでは、それらの限界を認識し、それに対処するための方法を紹介していきます。

□ユーティリティ型の限界

まず、ユーティリティ型の一般的な限界について説明します。

例えば、Partial<T>やReadonly<T>は、第一引数として型Tを受け取りますが、これらのユーティリティ型が想定するよりも複雑な型変換を行いたい場合、直接的な方法での対応が難しくなることがあります。

このコードでは、一般的なユーティリティ型の使用例を表しています。

この例では、Userという型に対して、PartialやReadonlyを使用しています。

type User = {
  id: number;
  name: string;
};

// Partialを使ってUserのすべてのプロパティをオプションにする
type OptionalUser = Partial<User>;

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

この例では、OptionalUserはUser型の各プロパティがオプションとなり、UnmodifiableUserは各プロパティが変更不可能となる型を作成しています。

しかし、例えばUser型のうち、idだけをオプションにしたい場合や、特定のプロパティだけを読み取り専用にしたい場合など、より細かい制御が必要となる場面が考えられます。

□限界を克服する方法

前述のような課題に対処するため、カスタムユーティリティ型を定義することで、より細かい制御や特定の変換を行うことが可能になります。

例えば、下記のコードでは、User型のidだけをオプションにするカスタムユーティリティ型を定義しています。

type User = {
  id: number;
  name: string;
};

// idだけをオプションにするカスタムユーティリティ型
type UserIdOptional = {
  id?: User['id'];
} & Omit<User, 'id'>;

この例では、UserIdOptional型は、User型のidがオプションとなり、他のプロパティ（この場合name）はそのまま維持される型を定義しています。

このように、既存のユーティリティ型の機能だけでは対応しきれない特定の要件に応じて、カスタムユーティリティ型を自ら定義することで、限界を克服することが可能です。

●注意点と対処法

TypeScriptのユーティリティ型を用いる際には、数々の注意点が存在します。

これらを無視してしまうと、コードの安全性が損なわれたり、意図しない動作を招く恐れがあります。

ここでは、ユーティリティ型を効果的に利用するための重要な注意点と、それらの問題を回避するための対処法をいくつか紹介します。

○型の互換性と注意点

TypeScriptにおける型の互換性は、ユーティリティ型を使用する上で非常に重要なテーマです。

ユーティリティ型を活用すると、オブジェクトや関数の型を変更することが容易になりますが、それに伴い、元の型との互換性が失われる場合があります。

このコードでは、User型と、その型のプロパティを一部除外したSimplifiedUser型を定義しています。

そして、それらの型の変数間で代入を試みる例を表しています。

type User = {
  id: number;
  name: string;
  email: string;
};

type SimplifiedUser = Omit<User, 'email'>;

const user: User = {
  id: 1,
  name: '山田太郎',
  email: 'taro@example.com'
};

const simplifiedUser: SimplifiedUser = user; // エラーが発生

上の例では、simplifiedUser変数にuserを代入しようとしたときにエラーが発生します。

これは、SimplifiedUser型がUser型からemailプロパティを除外しているため、その型の変数にUser型の変数を直接代入することはできません。

この問題を解決するための対処法として、型のアサーションを使用する方法が考えられます。

型アサーションを使用することで、明示的に型を変換することができます。

const simplifiedUser: SimplifiedUser = user as SimplifiedUser;

このように、asキーワードを用いて型アサーションを行うことで、エラーを回避できます。

しかし、型アサーションは安易に使用するべきではありません。

不適切な型アサーションは、ランタイム時に予期せぬエラーを引き起こす可能性があるため、必要最低限の場面でのみ使用するように心がけましょう。

○ユーティリティ型のパフォーマンスに関する考慮点

ユーティリティ型は非常に便利ですが、大規模なプロジェクトや複雑な型の定義において、過度に使用するとコンパイルのパフォーマンスが低下する場合があります。

例えば、多数のプロパティを持つ大きなオブジェクト型に対して、頻繁にユーティリティ型を適用すると、TypeScriptの型チェックの時間が増加する可能性が考えられます。

このような状況を避けるためには、次のような対処法を考慮すると良いでしょう。

必要な場面でのみユーティリティ型を使用することで、型の複雑さを減少させることができる。
同じ型の定義を複数の場所で繰り返し使用するのではなく、一箇所で定義し、その型を再利用することで、全体の型の複雑さを低減することができる。

ユーティリティ型を適切に活用することで、コードの品質や安全性を向上させることができます。

しかし、その利用には適切なバランスが必要です。

上記のような注意点や対処法を意識して、効果的にユーティリティ型を活用していきましょう。

●カスタマイズ方法

TypeScriptのユーティリティ型は非常に便利で、多くの場面での型の操作をサポートしていますが、特定のニーズに合わせてカスタマイズすることも可能です。

ここでは、既存のユーティリティ型をどのように拡張するか、また、独自のユーティリティ型を作成し、それをどのように共有するかを解説します。

○既存のユーティリティ型の拡張

TypeScriptでは、既存のユーティリティ型をカスタマイズして拡張することができます。

例として、Partial型を拡張して、指定したプロパティのみを部分的に持つ型を作成することを考えます。

このコードではPartialとPickを使って、特定のプロパティだけを部分的に持つ新しい型を作成するコードを表しています。

この例ではUser型からnameとageのみを部分的に持つPartialUser型を定義しています。

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

type PartialUser = Partial<Pick<User, 'name' | 'age'>>;

// この型は{name?: string, age?: number}として評価されます。

このようにして、特定のプロパティのみを部分的に持つ型をカスタマイズできます。

実際に上記のコードを実行すると、PartialUser型は{name?: string, age?: number}として評価されることが確認できます。

○独自のユーティリティ型の作成と共有

TypeScriptを使用すると、完全に新しいユーティリティ型を0から作成することもできます。

例えば、特定のプロパティが存在する場合、他のプロパティも必須となるような型を定義することを考えます。

このコードでは、Requiresという名前の独自のユーティリティ型を作成するコードを表しています。

この例では、addressプロパティが存在する場合、cityプロパティも必須となるUserWithAddress型を定義しています。

type Requires<T, K extends keyof T> = K extends any ? (Omit<T, K> & Required<Pick<T, K>>) : never;

type UserWithAddress = Requires<User, 'address' | 'city'>;

// この型はaddressとcityが同時に存在する場合のみ有効です。

上記のコードを利用することで、特定のプロパティが存在する場合に他のプロパティも必須となるような型を定義できます。

独自のユーティリティ型を共有する場合は、NPMパッケージやTypeScriptの型定義ファイル（.d.ts）を利用して、他のプロジェクトや開発者と共有することができます。

これにより、カスタマイズした型を効率的に再利用でき、TypeScriptの型のエコシステムをさらに豊かにすることが可能となります。