TypeScriptの型一覧：基本・応用・最新のユーティリティ型まで実務で役立つリファレンス

2026年5月14日

型リファレンス

TypeScriptは、JavaScriptに強力な静的型付けを提供することで、開発効率とコードの堅牢性を飛躍的に向上させる言語です。

2026年現在、フロントエンドからバックエンドまで、TypeScriptを用いた開発は完全に標準的なものとなりました。

本記事では、TypeScriptで利用可能な基本的な型から、実務で頻出する応用的な型、そして最新のユーティリティ型までを体系的に整理して紹介します。

型システムの全体像を把握し、より高度な型安全性を手に入れるためのリファレンスとしてご活用ください。

目次 [ close ]

プリミティブ型の一覧と基本的な定義方法

TypeScriptにおける型の基本は、JavaScriptに存在するプリミティブ値を正しく定義することから始まります。

基本的な7つのプリミティブ型

まずは、日常的な開発で最も頻繁に使用するプリミティブ型を確認しましょう。

これらは値そのものの種類を制限するための、最も基礎的な要素です。

TypeScript

// 基本的なプリミティブ型の定義
const message: string = "Hello, TypeScript";
const count: number = 2026;
const isActive: boolean = true;
const uniqueKey: symbol = Symbol("key");
const bigValue: bigint = 100n;
const emptyValue: null = null;
const notDefined: undefined = undefined;

string型はテキストデータを扱い、シングルクォート、ダブルクォート、バッククォートでの記述を許容します。

number型は整数だけでなく、浮動小数点数も扱うことが可能です。

bigint型は、通常のnumber型では表現できない非常に大きな整数を扱う際に利用されます。

symbol型は、オブジェクトのプロパティなどで一意の識別子を作成する際に非常に有効です。

特別な意味を持つ型 (any, unknown, void, never)

TypeScriptには、値の状態や関数の性質を表現するための特別な型が存在します。

any型は型チェックを無効化するため、使用は最小限に留めるべきです。

対照的に、unknown型は「何らかの型であるが、使用前に型を特定する必要がある」ことを示す安全な型です。

TypeScript

// 安全な型変換の例
let value: unknown = "2026年";

if (typeof value === "string") {
    // string型として扱える
    console.log(value.length);
}

実行結果

void型は、値を返さない関数の戻り値として定義されます。

一方で、never型は「決して発生しない」ことを表現するための型です。

例外をスローする関数や、無限ループなど、プログラムの末尾に到達しない場合に適用されます。

never型を型ガードと組み合わせることで、ロジックの漏れをコンパイル時に検知できるメリットがあります。

オブジェクトと配列を制御する型定義

実務においては、単一の値ではなく構造化されたデータを扱う機会が圧倒的に多くなります。

インターフェース (interface) と型エイリアス (type)

オブジェクトの構造を定義するには、interfaceまたはtypeを使用します。

2026年の開発トレンドでは、拡張性を求める場合はinterfaceを使い、複雑な型の組み合わせにはtypeを使用するのが一般的です。

TypeScript

// ユーザー情報の定義
interface User {
    id: number;
    name: string;
    readonly email: string; // 変更不可
    age?: number; // オプション（省略可能）
}

const currentUser: User = {
    id: 1,
    name: "開発者",
    email: "example@example.com"
};

readonly修飾子を付与することで、意図しない値の書き換えを未然に防ぐことができます。

また、?を付けることでプロパティをオプション扱いにでき、柔軟なオブジェクト定義が可能です。

配列とタプル型

複数の同じ種類のデータを管理するのが配列であり、特定の順番と型を厳密に固定するのがタプルです。

TypeScript

// 配列の定義
const scores: number[] = [80, 90, 75];
const tags: Array<string> = ["TS", "JS"];

// タプル型の定義
const response: [number, string] = [200, "Success"];

タプル型は、APIのレスポンス形式やReactのuseStateのような戻り値を表現するのに適しています。

要素数と各インデックスの型が確定しているため、バグの混入を防ぐ強力な手段となります。

高度な型演算 (Advanced Types)

TypeScriptの真価は、既存の型を組み合わせて新しい型を作り出す高度な機能にあります。

共用体型 (Union Types) と交差型 (Intersection Types)

Union Typesは「AまたはB」という表現を可能にし、Intersection Typesは「AかつB」という合成を可能にします。

TypeScript

// Union Types
type Status = "success" | "error" | "loading";

// Intersection Types
type Admin = { privileges: string[] };
type Employee = { id: string; name: string };
type AdminUser = Admin & Employee;

Statusのようなリテラル型を組み合わせたUnion型は、定数管理に非常に便利です。

これにより、指定した文字列以外の代入を厳格に禁止できます。

条件付き型 (Conditional Types)

型の世界における「if文」のような役割を果たすのがConditional Typesです。

特定の条件に合致するかどうかで、結果として返却される型を動的に変更できます。

TypeScript

type IsString<T> = T extends string ? "Yes" : "No";

type A = IsString<string>; // "Yes"
type B = IsString<number>; // "No"

これは、複雑なライブラリの型定義やフレームワークの内部ロジックで多用されます。

テンプレートリテラル型

文字列のパターンを型として定義できる機能です。

CSSのプロパティ名や、特定の命名規則を持つキーの生成に威力を発揮します。

TypeScript

type Color = "red" | "blue";
type Intensity = "low" | "high";

// "red-low" | "red-high" | "blue-low" | "blue-high" が生成される
type ColorVariant = `${Color}-${Intensity}`;

実務を効率化するユーティリティ型

TypeScriptには、標準で用意されている便利な変換用の型「ユーティリティ型」が多数存在します。

オブジェクト操作系のユーティリティ型

既存の型をベースに、一部を変更した新しい型を即座に作成できます。

型名	効果
`Partial<T>`	全てのプロパティをオプション（任意）にする
`Required<T>`	全てのプロパティを必須にする
`Readonly<T>`	全てのプロパティを読み取り専用にする
`Pick<T, K>`	特定のキー `K` だけを抽出する
`Omit<T, K>`	特定のキー `K` だけを除外する
`Record<K, T>`	キー `K`、値 `T` の連想配列型を作成する

例えば、更新処理などで一部のデータだけを受け取りたい場合にはPartialが最適です。

TypeScript

interface Article {
    id: string;
    title: string;
    content: string;
}

// idだけが必須で、他は任意となる更新用型
type UpdateArticleDto = Pick<Article, "id"> & Partial<Omit<Article, "id">>;

このようにユーティリティ型を組み合わせることで、コードの重複を最小限に抑えることができます。

型抽出系のユーティリティ型

関数やクラスから、特定の型情報を抜き出すためのユーティリティも重要です。

特に、外部ライブラリの関数の戻り値などを再利用したい場面で重宝します。

ReturnType<T>: 関数の戻り値の型を取得する。
Parameters<T>: 関数の引数の型をタプルとして取得する。
Awaited<T>: Promiseの中身の型（非同期処理の解決後の型）を取得する。

TypeScript

async function fetchData() {
    return { id: 1, status: "ok" };
}

// { id: number; status: string; } 型が抽出される
type DataResponse = Awaited<ReturnType<typeof fetchData>>;

2026年現在のモダンな型定義手法

TypeScriptは進化を続けており、より記述を簡潔にするための新しい構文が登場しています。

satisfies演算子の活用

satisfies演算子は、型推論の結果を維持しつつ、特定の型に合致しているかをチェックできる機能です。

これまでの型注釈（: Type）では、型の抽象度が高くなりすぎて具体的な値の情報が失われることがありました。

TypeScript

const theme = {
    primary: "#ff0000",
    secondary: [0, 255, 0]
} satisfies Record<string, string | number[]>;

// 型チェックをパスしつつ、具体的なメソッドが使える
theme.primary.toUpperCase();
theme.secondary.map(v => v);

satisfiesを使うことで、型安全性を確保しながらIDEの補完機能を最大限に引き出すことができます。

インデックス型アクセスとKeyof

オブジェクトのキーや値の種類を動的に取得する手法も、大規模開発では欠かせません。

keyof演算子は、オブジェクトのプロパティ名の型をUnion型として取得します。

TypeScript

interface Config {
    apiEndpoint: string;
    retryCount: number;
}

type ConfigKey = keyof Config; // "apiEndpoint" | "retryCount"

これにより、プロパティ名にタイプミスがあった場合にコンパイルエラーとして検知できるようになります。

型ガードと型絞り込み

実行時の値の状態に応じて、型をより具体的なものに制限する技術が型ガードです。

複雑な型を扱う際には、この「絞り込み」をいかにスマートに行うかが重要になります。

ユーザー定義型ガード (Type Predicates)

自分自身で定義した判定ロジックを、TypeScriptの型システムに伝えることができます。

TypeScript

interface Cat {
    meow(): void;
}

interface Dog {
    bark(): void;
}

function isCat(animal: Cat | Dog): animal is Cat {
    return (animal as Cat).meow !== undefined;
}

function speak(animal: Cat | Dog) {
    if (isCat(animal)) {
        animal.meow(); // ここではCat型として確定
    } else {
        animal.bark(); // ここではDog型として確定
    }
}

animal is Cat という戻り値の型定義がポイントです。

この記述により、条件分岐の中でTypeScriptが型を自動的に推論し直してくれます。