【無料配布】10日間で学べるTypeScript学習資料

TypeScriptの型ガード入門:typeof・in・isとunknown/neverでasを卒業する

TypeScriptを書いていると、型エラーが出たときに思わずas(型アサーション) を使って「とにかくコンパイルを通す」という対処をしてしまいがちです。

「string | numberなどのユニオン型をきれいに分岐させたい」
「asを使うのは良くないと聞くけれど、代わりにどう書けばいいのかわからない……」

と悩んでいませんか?

結論から言うと、asの代わりに 「型ガード(typeof・instanceof・in・is)」 を使えば、プログラムの実行時に実際の値を確認しながら安全に型を絞り込めるため、asによる予期せぬ実行時エラーをゼロにできます。

本記事では、基本の型ガード3選から、実務で重宝するユーザー定義型ガード(is)、さらにunknown型やnever型を使った網羅性チェックまで、図解とサンプルコード付きでわかりやすく解説します。

この記事を読み終えれば、危険なasやanyに頼る書き方を卒業し、現場で評価される堅牢なTypeScriptコードが書けるようになります。

目次

型ガードを使えば危険なas(型アサーション)を卒業できる

TypeScriptにおける「型ガード(Type Guard)」とは、if文などで実際の値をチェックし、そのブロック内での型の候補を自動的に絞り込む仕組みのことです。

型アサーション(as)が「開発者がコンパイラを黙らせるための強制的な上書き」であるのに対し、型ガードは「実行時にも安全なチェックを行いながら型を確定させる」ため、本番環境でのクラッシュを防げます。

なぜasの多用は危険なのか(実行時エラーの原因)

asを使うと、TypeScriptコンパイラは「開発者が保証するなら、この型として扱おう」と型チェックをスキップします(asの基本的な仕様についてはTypeScriptのキャスト(as)と型変換も参照してください)。

しかし、asはコンパイル時の見た目を変えるだけで、実行されるJavaScriptのコードには一切影響しません。

そのため、実際にはnullや別の型が入っていた場合、本番実行時にTypeErrorでプログラムが止まってしまいます。

as(型アサーション)で起きる典型的な事故パターン
1. 執筆時
as で無理やり型変換

「これは絶対 string だ」と as string で上書き。

2. コンパイル
エラーが出ずに通過

TypeScriptはチェックを諦めるため、警告なしでビルド成功。

3. 本番実行
想定外の値でクラッシュ

実際は数値や undefined が入り、TypeError で停止。

asを使った危険なコード例を確認しましょう。

function printLengthWithAs(value: string | number) {
  // NG:数値が渡される可能性を無視して as string にしてしまう
  const str = value as string;
  console.log(str.toUpperCase());
}

// コンパイルは通ってしまうが、実行時にエラーで落ちる!
printLengthWithAs(123); // TypeError: str.toUpperCase is not a function

引数valueにはnumberが入る可能性もあるのに、as stringと書いたせいでTypeScriptがエラーを出さなくなります。

printLengthWithAs(123)を実行した瞬間、数値123には.toUpperCase()が存在しないため、本番でアプリがクラッシュします。

型ガード(Narrowing:型の絞り込み)の基本イメージ

先ほどの問題を解決するのが型ガード(Narrowing) です。

if (typeof value === "string")のように条件分岐を書くと、TypeScriptはそのifブロックの中身を「確実にstringである」と自動で判断してくれます。

さらにelseブロック側では「残りの型(この場合はnumber)」へと自動で絞り込まれるため、ユニオン型(union型の基礎)を安全に分岐できます。

型ガード(Narrowing)によって型が自動で絞り込まれるイメージ
value: string | number
▼ if (typeof value === “string”) で分岐 ▼
if ブロック内:string 型に確定

value.toUpperCase() が安全に使える。

else ブロック内:number 型に確定

value.toFixed(2) など数値メソッドが安全に使える。

型ガードで安全に書き直したコードを確認しましょう。

function formatValue(value: string | number): void {
  if (typeof value === "string") {
    // ここでは value が string 型に絞り込まれる
    console.log(value.toUpperCase());
  } else {
    // ここでは value が自動的に number 型に絞り込まれる
    console.log(value.toFixed(2));
  }
}

formatValue("hello"); // "HELLO"
formatValue(123);     // "123.00"(安全に動作する)

JavaScript本来の実行時チェックを行うことで、TypeScriptが「この中では確実にstring」と認識します。

else側では、元の型string | numberからstringが取り除かれるため、書かなくても自動でnumber型になり、数値専用の.toFixed(2)が補完付きで呼び出せます。

基本の型ガード3選(typeof/instanceof/in)

実務で登場する型の絞り込みは、まず標準で使える3つの演算子(typeof・instanceof・in)を使い分けるだけで8割以上対応できます。それぞれ判定できる対象が異なるため、用途ごとに整理しておきましょう。

typeof でプリミティブ型(string・number 等)を絞り込む

typeofは、文字列(string)・数値(number)・真偽値(boolean)などのプリミティブ型を判定するときに使います。

1つだけ注意点として、JavaScriptの仕様上typeof nullは"object"を返す という落とし穴があります。

配列やオブジェクトを判定したいときはtypeofではなく、後述のArray.isArray()やin演算子を使います。

typeof 型ガードで判定できる対象と注意点
得意な判定(プリミティブ型)
  • typeof x === "string"(文字列)
  • typeof x === "number"(数値)
  • typeof x === "boolean"(真偽値)
  • typeof x === "undefined"(未定義)
注意点(typeofの落とし穴)
  • typeof null は "object" になるため x === null で判定
  • 配列の判定には Array.isArray(x) を使う

typeofとArray.isArrayを使った型ガードを確認しましょう。

function printInput(input: string | string[] | null): void {
  if (input === null) {
    console.log("値が空(null)です");
    return;
  }
  if (typeof input === "string") {
    console.log("単一の文字列:", input.trim());
    return;
  }
  // ここでは input は string[] に確定する
  console.log("配列の件数:", input.length);
}

printInput("  TypeScript  "); // 単一の文字列: TypeScript
printInput(["A", "B"]);       // 配列の件数: 2

最初にnullを除外(早期リターン)することで、残りの型が string | string[] になります。

文字列かどうかを判定して.trim()を呼び出しています。

すると、最後の行では自動的にstring[]型だけが残るため、安全に.lengthを参照できます。

instanceofでクラスやErrorオブジェクトを判定する

instanceofは、「特定のクラス(設計図)から作られたインスタンスかどうか」を判定する型ガードです。

実務で最も出番が多いのは、Dateオブジェクトの判定や、try / catchで受け取ったエラーがErrorクラスかどうかを調べる場面です。

instanceof は「どのクラスから生成されたか」を実行時に判定する
判定したい値

date: Date | string や error: unknown

instanceof
──▶
クラス固有メソッドが解禁

date.toISOString() や error.message が安全に使える

Dateクラスから作られた値かどうかを実行時に確認します。

trueのブロック内では.toISOString()などDate専用のメソッドが使えます。

なお、instanceofはクラスに対して使うものなので、typeやinterfaceで定義しただけのオブジェクト型には使えません(その場合は次のin演算子を使います)。

in演算子でオブジェクトのプロパティ有無を判定する

in演算子は、「オブジェクトの中に特定のプロパティ(キー)が含まれているか」を調べる型ガードです。

TypeScriptのtypeやinterfaceはコンパイル後に消えるためinstanceofでは判定できませんが、"adminRole" in userのように書けば、異なる構造のオブジェクト型同士を安全に区別できます。

in 演算子は「固有のプロパティ名」を手がかりにオブジェクト型を分ける
“permission” in user が true
AdminUser 型に確定

user.permission に安全にアクセスできる。

“permission” in user が false
NormalUser 型に確定

user.plan など一般ユーザー固有の項目を使える。

in演算子で2種類のオブジェクト型を分岐する例を確認しましょう。

type AdminUser = {
  name: string;
  permission: "all" | "edit";
};

type NormalUser = {
  name: string;
  plan: "free" | "pro";
};

function showUserInfo(user: AdminUser | NormalUser): void {
  if ("permission" in user) {
    // AdminUser だけに存在するプロパティで判定 → AdminUser 型に確定
    console.log(`管理者 ${user.name}(権限: ${user.permission})`);
    return;
  }
  // ここでは NormalUser 型に確定
  console.log(`一般ユーザー ${user.name}(プラン: ${user.plan})`);
}

showUserInfo({ name: "鈴木", permission: "all" });
showUserInfo({ name: "高橋", plan: "pro" });

userオブジェクトに"permission"というキーが存在するかを確認しています。

AdminUser側にしかpermissionがないため、ifの中はAdminUser、それ以降の行はNormalUserとしてTypeScriptが自動で型を絞り込んでくれます。

ユーザー定義型ガード(is)で複雑な型を安全に判定する

typeofやinだけでは判定しにくい複雑な条件(例:「オブジェクトかつidが数値でnameが文字列である」など)を切り出したいときに使うのが、ユーザー定義型ガード(is) です。

自分で「この関数がtrueを返したら、引数はこの型である」とTypeScriptに教える専用の判定関数を作れます。

arg is Type構文の書き方と仕組み

通常の真偽値(boolean)を返す判定関数と違い、戻り値の型に引数名 is 型名と書くのがポイントです。

ただbooleanを返すだけでは、呼び出し元のif文の中で型が絞り込まれません。

arg is Typeと書いておくことで、その関数をif文の条件に使ったときにTypeScriptが型を確定させてくれます。

戻り値型「boolean」と「arg is Type」の違い
通常の boolean 返却 function isUser(v: unknown): boolean

if (isUser(data)) を書いても、data は unknown のまま絞り込まれない。

ユーザー定義型ガード(is) function isUser(v: unknown): v is User

if (isUser(data)) の中では、data が確実に User 型になる。

v is Userを使った型ガード関数の基本形を確認しましょう。

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

// 戻り値に "value is User" を指定する
function isUser(value: unknown): value is User {
  if (typeof value !== "object" || value === null) {
    return false;
  }
  const obj = value as Record<string, unknown>;
  return typeof obj.id === "number" && typeof obj.name === "string";
}

function printUser(data: unknown): void {
  if (isUser(data)) {
    // ここでは data が User 型として認識される
    console.log(`ID:${data.id} / 名前:${data.name}`);
  } else {
    console.log("User型のデータではありません");
  }
}

printUser({ id: 1, name: "田中" }); // ID:1 / 名前:田中

この関数がtrueを返したとき、引数valueがUser型であることを保証する宣言です。

まずオブジェクトでありnullでないことを確認してから、idが数値・nameが文字列かをチェックしています。

APIレスポンスや配列のfilterで使う実践例

ユーザー定義型ガード(is)が実務で特に輝くのが、配列の.filter()でnullやundefinedを取り除く場面です。

たとえば(string | null)[]という配列に対して、普通に.filter((item) => item !== null)と書いても、古い設定や一部のケースでは配列の型が(string | null)[]のまま残ることがあります。

そこにisNonNullのような型ガード関数を渡すと、戻り値の型がきれいなstring[]に絞り込まれます。

配列の .filter() に型ガードを渡すと配列の型まで綺麗に絞り込まれる
(string | null)[]

["TS", null, "Node.js"]

.filter(isString)
──────▶
string[]

null が型レベルで完全に消える

.filter()でnullを除外してstring[]にする例を確認しましょう。

// null や undefined を除外する汎用型ガード
function isString(value: string | null | undefined): value is string {
  return typeof value === "string";
}

const rawTags: (string | null | undefined)[] = ["TypeScript", null, "Node.js", undefined];

// 型ガードを渡すことで cleanTags の型は string[] になる
const cleanTags: string[] = rawTags.filter(isString);

console.log(cleanTags.map((tag) => tag.toUpperCase())); // ["TYPESCRIPT", "NODE.JS"]

isStringの戻り値型がvalue is stringとなっているため、TypeScriptは「フィルタ後の配列にはstringしか残らない」と理解し、cleanTagsをstring[]として扱えます。

tag.toUpperCase()を呼び出す際にも、毎回if (tag !== null)を書く必要がなくなります。

unknown型とnever型で守りを固める

型ガードとセットで覚えておくと実務の設計力が一段上がるのが、unknown型とnever型です。

どちらも「型チェックの抜け漏れ」を物理的に防ぐための強力な安全装置になります。

unknownとanyの違い(unknownで受けて型ガードで開ける)

外部APIのレスポンスやJSON.parse()の結果など、「実行するまで中身が分からないデータ」を受け取るとき、ついany型を使いたくなりますが、実務ではunknown型を使うのが鉄則です。

  • any型:どんな操作も許可してしまう(=型チェックの放棄)
  • unknown型:何が入っているか分からないので、型ガードでチェックするまで操作を禁止する

つまり、「入り口はunknownで受け止め、型ガードを通して安全を確認してから使う」のが、asやanyを卒業するための王道パターンです。

any 型と unknown 型の決定的な違い
any 型(危険:ノーチェック)
  • 存在しないメソッドを呼んでもエラーが出ない
  • 型安全が完全に失われる
  • 実行時にクラッシュする原因になる
unknown 型(安全:型ガード必須)
  • そのままではプロパティ参照や計算ができない
  • typeof や is で絞れば安全に使える
  • 「チェック漏れ」をコンパイラが防いでくれる

unknownで受け取り型ガードで開ける例を確認しましょう。

function parseJsonSafely(rawText: string): void {
  // JSON.parse の結果を any ではなく unknown として受け取る
  const parsed: unknown = JSON.parse(rawText);

  if (typeof parsed === "object" && parsed !== null && "title" in parsed) {
    // ここで初めて安全に title の存在を確認できる
    if (typeof parsed.title === "string") {
      console.log("タイトル:", parsed.title.toUpperCase());
    }
  }
}

parseJsonSafely('{"title": "TypeScript"}'); // タイトル: TYPESCRIPT

標準のJSON.parse()はanyを返しますが、あえて: unknownと明記することで、チェックなしにparsed.titleへアクセスできないように制限しています。

"title" in parsedとtypeof parsed.title === "string"を通すことで、実行時にも100%壊れない安全な処理になります。

never型を使ったswitch文の網羅性チェック

複数のステータス(例:"pending" | "success" | "error")をswitch文で分岐するとき、将来新しいステータス(例:"cancelled")が増えると、switch文の書き足し忘れが起きやすくなります。

そこでdefault:節にconst _check: never = status;と書いておくと、分岐の漏れがあった瞬間にTypeScriptがコンパイルエラーを出してくれます。

これを網羅性チェック(Exhaustiveness Check)と呼びます。

never型を default に置くと「分岐の書き漏れ」を自動検知できる
全パターン網羅できている場合

default に到達する型が残らないため、never 型への代入が正常に通る。

1つでも分岐が漏れている場合

漏れた型(例:"cancelled")は never に代入できず、即座にコンパイルエラーが出る。

never型によるswitch文の網羅性チェックを確認しましょう。

type Status = "pending" | "success" | "error";

function getStatusLabel(status: Status): string {
  switch (status) {
    case "pending":
      return "処理中";
    case "success":
      return "完了";
    case "error":
      return "エラー";
    default: {
      // 全パターン処理していれば status は never 型になりエラーにならない
      // もし Status に "cancelled" を追加して case を書き忘れるとここでエラーになる
      const _exhaustiveCheck: never = status;
      return _exhaustiveCheck;
    }
  }
}

console.log(getStatusLabel("success")); // "完了"

never型は「どの値も代入できない空の型」です。

すべてのcaseを書き終えていればdefaultには到達しないため通りますが、将来Statusに新しい選択肢を追加したとき、対応するcaseを書き忘れると即座にエラーで教えてくれます。

まとめ:シーン別の型ガード使い分けチェックリスト

最後に、どの場面でどの型ガードを使えばいいかを整理して締めくくります。

まとめ
  • 文字・数値・真偽値の判定→typeof
  • 配列の判定→Array.isArray()
  • null/undefinedの除外→=== nullや!== undefined
  • ErrorやDateなどクラスの判定→instanceof
  • オブジェクトのプロパティ有無→in演算子
  • 複雑な判定や.filter()での絞り込み→ユーザー定義型ガード(arg is Type)
  • 不明な値の受け口&分岐漏れ防止→unknown型とnever型

「型ガードやunknownの使い方を、実際のWebアプリ開発の中で定着させたい」という方は、本サイトで無料配布している【無料配布】10日間で学べるTypeScript学習資料もあわせてご活用ください。

基礎の総復習からサンプルアプリのコードまで一通り手に入ります。

よかったらシェアしてね!
  • URLをコピーしました!
  • URLをコピーしました!
目次