【TypeScript】交差型（Intersection Types）の使い方｜& で複数の型を1つに合成する

TypeScript には、複数の型を組み合わせて新しい型を作る仕組みがいくつかあります。その一つが交差型（Intersection Types）です。A & B と書くと、「A の性質も B の性質も両方持つ型」を作れます。この記事では、交差型の基本の書き方、type や interface との組み合わせ、よく混同されるユニオン型（|）との違い、そして同名プロパティが衝突したときの挙動までを、初心者にもわかりやすく解説します。

交差型とは何か

交差型は、複数の型を & でつないで「そのすべてを満たす型」を表す書き方です。たとえば「名前を持つ型」と「年齢を持つ型」を交差させると、「名前も年齢も両方持つ型」になります。既にある型を土台に、あとから性質を足し合わせていくイメージです。

type HasName = { name: string };
type HasAge = { age: number };

// 2つの型を & で合成する
type Person = HasName & HasAge;

// Person は name と age の両方が必須になる
const taro: Person = {
  name: "太郎",
  age: 30,
};

HasName & HasAge とした Person は、name と age のどちらも必須になります。片方でも欠けているとエラーになります。「AとBを合体させて、両方の項目を持つ1つの型を作る」——これが交差型の基本的な役割です。

ユニオン型（|）との違い

交差型（&）とよく混同されるのがユニオン型（|）です。記号が似ているうえに意味も正反対なので、ここでしっかり区別しておきましょう。ユニオン型は「AまたはB（どちらか一方）」、交差型は「AかつB（両方）」を表します。

オブジェクトの型で考えると、この違いがはっきりします。次のコードを見てください。

type HasName = { name: string };
type HasAge = { age: number };

// ユニオン型：name だけ、または age だけでもOK
type NameOrAge = HasName | HasAge;
const a: NameOrAge = { name: "太郎" };        // OK
const b: NameOrAge = { age: 30 };             // OK

// 交差型：name と age の両方が必要
type NameAndAge = HasName & HasAge;
const c: NameAndAge = { name: "太郎", age: 30 }; // OK
// const d: NameAndAge = { name: "太郎" };      // エラー（age が足りない）

「複数の型のうちどれかを受け取りたい」ならユニオン型、「複数の型を合体させて全部入りの型を作りたい」なら交差型、と覚えておくと迷いません。

interface の extends との使い分け

「既存の型に性質を足す」という点では、interface の extends でも似たことができます。次の2つはほぼ同じ「name と age を持つ型」を作ります。

interface HasName { name: string }

// interface は extends で受け継ぐ
interface Person1 extends HasName {
  age: number;
}

// type は & で合成する
type Person2 = HasName & { age: number };

どちらを使うかは好みやプロジェクトの方針によりますが、目安としては次のように考えると分かりやすいです。interface を中心に設計しているなら extends が自然です。一方で、type エイリアスやユニオン型、あとで説明する複雑な型を組み合わせたいときは、交差型（&）のほうが柔軟に書けます。交差型は interface だけでなく、その場で書いたオブジェクト型やジェネリクスとも自由に合成できるのが強みです。

実務でよくある使い方

共通のプロパティを付け足す

交差型が活躍する典型例が、「どのデータにも共通で付けたい項目」をまとめて足すケースです。たとえば、あらゆるデータに id と createdAt（作成日時）を持たせたい、という場面を考えてみます。

// 共通で持たせたい項目
type BaseEntity = {
  id: number;
  createdAt: string;
};

// それぞれのデータ固有の項目
type User = { name: string; email: string };
type Article = { title: string; body: string };

// 共通項目 & 固有項目 で合成する
type UserEntity = BaseEntity & User;
type ArticleEntity = BaseEntity & Article;

const user: UserEntity = {
  id: 1,
  createdAt: "2026-07-17",
  name: "太郎",
  email: "taro@example.com",
};

BaseEntity を一度定義しておけば、あとは & でそれぞれのデータに合成するだけで、共通項目を漏れなく付けられます。共通部分の定義を1か所にまとめられるので、項目が増えたときの修正も1か所で済みます。

関数の引数をまとめて受け取る

複数の設定オブジェクトを1つにまとめて受け取りたいときにも交差型が便利です。たとえば「表示に関する設定」と「動作に関する設定」を別々に定義しておき、関数の引数ではそれらを合成した型を使う、といった書き方ができます。

type StyleOptions = { color: string; size: number };
type BehaviorOptions = { closable: boolean };

// 両方の設定をまとめて受け取る
function createModal(options: StyleOptions & BehaviorOptions) {
  console.log(options.color, options.size, options.closable);
}

createModal({ color: "red", size: 16, closable: true });

設定を種類ごとに小さな型に分けておき、使う場所で必要なものを & で組み合わせる。こうすると、型を再利用しやすく、見通しのよい設計になります。

プロパティが衝突するとどうなるか

交差型で注意したいのが、同じ名前のプロパティが、違う型で衝突したときの挙動です。たとえば片方で id: number、もう片方で id: string と定義された型を交差させると、その id は「number でも string でもある値」を求められます。しかし、そんな値は存在しないため、型は never（絶対に値を持てない型）になります。

type A = { id: number };
type B = { id: string };

// id は number & string になり、実質 never（代入できる値がない）
type C = A & B;

// number でも string でもないため、どんな値もエラーになる
// const x: C = { id: 1 };     // エラー
// const y: C = { id: "1" };   // エラー

これはバグではなく、「両方を同時に満たす」という交差型のルールに忠実に従った結果です。交差させる型どうしで同名プロパティがあるときは、型が一致しているか（または一方がもう一方を含む関係になっているか）を確認しましょう。文字列リテラル型どうしのように、両立できる組み合わせであれば衝突にはなりません。意図せず never になってしまったときは、プロパティ名の重複や型のずれを疑うのが解決の近道です。

まとめ

交差型（Intersection Types）は、A & B のように書いて「複数の型のすべてを満たす型」を作る機能です。オブジェクト型なら「両方のプロパティを持つ型」になり、共通項目の付け足しや設定オブジェクトの合成に役立ちます。似た記号のユニオン型（|）が「どちらか一方」を表すのに対し、交差型は「両方」を表す点が最大の違いです。interface の extends と役割が重なる部分もありますが、type やその場で書いたオブジェクト型と自由に合成できるのが交差型の強みです。同名プロパティが型違いで衝突すると never になる点にだけ気をつければ、型を部品のように組み合わせて再利用できる便利な機能です。

参考ページ

• Intersection Types – TypeScript Documentation
• Union Types – TypeScript Documentation