TypeScriptのリテラル型を使いこなす：型安全性を高める具体例と活用パターンの解説

2026年5月17日

基本の型・変数宣言

TypeScriptにおいて、型システムを最大限に活用するために欠かせない概念の一つが「リテラル型」です。

リテラル型を理解し、適切に使いこなすことで、単なる「文字列型」や「数値型」といった広い定義から脱却し、より厳密で安全なコードを記述できるようになります。

本記事では、2026年現在のモダンな開発環境を前提に、リテラル型の基本から高度な応用パターン、型安全性を飛躍的に高めるための具体的なテクニックを詳しく紹介します。

目次 [ close ]

リテラル型の基礎知識

リテラル型とは、プリミティブ型のサブタイプとして、「特定の値そのもの」を型として扱う仕組みのことです。

通常の文字列型（string）が任意の文字列を許容するのに対し、リテラル型は指定された特定の値以外を受け付けません。

文字列リテラル型

もっとも頻繁に利用されるのが文字列リテラル型です。

変数の値が特定の文字列に限定される場合、その文字列自体を型として定義できます。

TypeScript

// 文字列リテラル型の定義
let status: "success" | "error" | "loading";

status = "success"; // OK
status = "pending"; // コンパイルエラー: 型 '"pending"' を型 '"success" | "error" | "loading"' に割り当てることはできません。

数値リテラル型と真偽値リテラル型

リテラル型は文字列だけでなく、数値や真偽値に対しても適用可能です。

例えば、特定のポート番号や固定のフラグ値を扱う際に非常に有効です。

TypeScript

// 数値リテラル型
type HTTPStatus = 200 | 404 | 500;

const code: HTTPStatus = 200; // OK

// 真偽値リテラル型
type IsEnabled = true;
const active: IsEnabled = true; // true以外は代入不可

Union型との組み合わせによる表現力の向上

リテラル型は単体で使用されるよりも、Union型（|）と組み合わせて使用されることが一般的です。

これにより、変数が取り得る値の選択肢を明示的に定義できます。

マジックナンバーや意図しない文字列の混入を防ぐための非常に強力な手段となります。

例えば、UIコンポーネントのサイズ指定などで活用されます。

TypeScript

type ButtonSize = "small" | "medium" | "large";

function createButton(size: ButtonSize) {
    // 引数sizeは必ず定義された3つの文字列のいずれかになる
    console.log(`Creating a ${size} button.`);
}

Enumとリテラル型の使い分け

TypeScriptには列挙型（Enum）が存在しますが、モダンな開発ではリテラル型のUnionを用いるケースが増えています。

それぞれの特徴を理解し、プロジェクトの目的に応じて使い分けることが重要です。

機能	Enum	リテラル型のUnion
実行時の影響	JavaScriptオブジェクトとして残る	コンパイル時に消去される
代入の柔軟性	名前付きの定義が必要	値そのものを直接書ける
メンテナンス性	一箇所で管理しやすい	型推論と相性が良い

実行時のコード量を減らし、TypeScript本来の軽量な型システムの恩恵を受けるには、リテラル型の使用が推奨される場面が多いと言えます。

Template Literal Typesによる高度な型定義

TypeScript 4.1以降で導入された「Template Literal Types」は、リテラル型をさらに進化させた機能です。

JavaScriptのテンプレートリテラルと同じ構文を用いて、新しい文字列リテラル型を動的に生成できます。

これにより、命名規則に基づいた型定義や、CSSのプロパティのような組み合わせを安全に表現可能です。

基本的な構文

既存の型を組み合わせて、特定のパターンを持つ文字列を定義します。

TypeScript

type VerticalAlignment = "top" | "middle" | "bottom";
type HorizontalAlignment = "left" | "center" | "right";

// すべての組み合わせを自動生成
type Alignment = `${VerticalAlignment}-${HorizontalAlignment}`;

const position: Alignment = "top-left"; // OK
const invalidPosition: Alignment = "up-right"; // コンパイルエラー

実用的な活用例：APIのパス生成

APIのパス定義において、特定のプレフィックスを強制する場合などに便利です。

TypeScript

type ApiVersion = "v1" | "v2";
type Endpoint = "users" | "posts";

type ApiPath = `/api/${ApiVersion}/${Endpoint}`;

const fetchPath: ApiPath = "/api/v1/users"; // 型安全

as const（constアサーション）による推論の制御

オブジェクトや配列を定義する際、デフォルトではプロパティの型は「string」や「number」などの広い型に推論されます。

しかし、値を変更しない定数として扱う場合は、as constを使用することでリテラル型として推論させることができます。

constアサーションの動作

as constを付与することで、オブジェクトのすべてのプロパティが「readonly」かつ「リテラル型」になります。

TypeScript

const CONFIG = {
    apiHost: "https://api.example.com",
    retryCount: 3,
} as const;

// CONFIG.apiHost の型は string ではなく "https://api.example.com" になる
// CONFIG.apiHost = "other"; // エラー: 読み取り専用プロパティのため代入不可

これにより、設定オブジェクトやマッピングデータを型安全に管理できます。

Discriminated Unions（判別可能な共用体）での活用

リテラル型の真骨頂は、「Discriminated Unions（判別可能な共用体）」における活用にあります。

これは、共通のリテラル型を持つプロパティ（タグ）をキーにして、オブジェクトの型を絞り込む手法です。

複雑な状態管理やAPIレスポンスの処理において、条件分岐の安全性を劇的に向上させます。

具体的な実装パターン

以下の例では、statusプロパティをタグとして使用しています。

TypeScript

interface SuccessResponse {
    status: "success";
    data: string[];
}

interface ErrorResponse {
    status: "error";
    message: string;
}

type ApiResponse = SuccessResponse | ErrorResponse;

function handleResponse(response: ApiResponse) {
    if (response.status === "success") {
        // ここでは response は SuccessResponse 型として扱われる
        console.log(response.data.length);
    } else {
        // ここでは response は ErrorResponse 型として扱われる
        console.error(response.message);
    }
}

TypeScriptのコンパイラは、if文によるチェックを通じて型を自動的に絞り込み（Narrowing）ます。

このパターンを利用することで、存在しないプロパティへのアクセスをコンパイル時に完全に防止できます。

型ガードとリテラル型の親和性

リテラル型を用いた型の絞り込みは、switch文でも同様に機能します。

特に、すべてのパターンを網羅しているかをチェックする「排他的チェック」と相性が抜群です。

exhaustiveness check（網羅性チェック）

リテラル型の全てのケースを処理しているかを保証するテクニックを紹介します。

TypeScript

type Shape = "circle" | "square" | "triangle";

function getShapeName(shape: Shape) {
    switch (shape) {
        case "circle":
            return "円";
        case "square":
            return "正方形";
        case "triangle":
            return "三角形";
        default:
            const _exhaustiveCheck: never = shape;
            return _exhaustiveCheck;
    }
}

もしShape型に新しいリテラル（例: “rectangle”）が追加された場合、default節でコンパイルエラーが発生します。

これにより、修正漏れを即座に検知できるため、大規模開発における保守性が向上します。

リテラル型を使いこなすためのベストプラクティス

リテラル型を効果的に導入するためには、いくつかのポイントに注意する必要があります。

まず、マジックナンバーや定数文字列を直接コードに散布しないことが大切です。

共通の型定義（Type Alias）として抽出し、名前を付けることで再利用性と可読性を高めましょう。

また、外部APIからのレスポンスなど、実行時まで値が不確定な場合は、zodなどのバリデーションライブラリと組み合わせてリテラル型に変換するアプローチが推奨されます。

Zodを用いたリテラル型への変換例

実行時のバリデーションとリテラル型の定義を同時に行う方法です。

TypeScript

import { z } from "zod";

const UserRoleSchema = z.union([
    z.literal("admin"),
    z.literal("user"),
    z.literal("guest"),
]);

type UserRole = z.infer<typeof UserRoleSchema>;

function processRole(input: unknown) {
    const result = UserRoleSchema.safeParse(input);
    if (result.success) {
        const role: UserRole = result.data;
        console.log(`Validated role: ${role}`);
    }
}