はじめに

TypeScript には 型推論（Type Inference） という強力な機能があり、明示的に型を指定しなくても TypeScript が適切な型を推測してくれます。
また、複数の型を組み合わせる ユニオン型（Union Type） や インターセクション型（Intersection Type） を使うことで、柔軟な型定義が可能になります。
本記事では、それらの概念と使い方を詳しく解説します。

1. 型推論（Type Inference）とは？

TypeScript では、明示的に型を指定しなくても、変数の初期値から 自動的に型を推測 します。

基本的な型推論

TYPESCRIPT
let message = "Hello, TypeScript!";
// message の型は string と推論される

let age = 30;
// age の型は number と推論される

message や age のように、初期値を代入した場合、TypeScript はその値の型を推論する ため、string や number を明示的に指定しなくても問題ありません。

関数の戻り値の型推論

TYPESCRIPT
function add(a: number, b: number) {
  return a + b;
}

この場合、戻り値の型は number と推論されるため、明示的に : number を指定しなくても動作します。

2. ユニオン型（Union Type）

ユニオン型を使うと、複数の型を持つ変数を定義 できます。

ユニオン型の基本

TYPESCRIPT
let value: number | string;
value = 42; // OK
value = "Hello"; // OK
// value = true; // エラー（boolean は許可されていない）

value は number または string を格納できる変数として定義されています。

ユニオン型を使った関数

TYPESCRIPT
function printId(id: number | string) {
  console.log(`ID: ${id}`);
}

printId(101); // OK
printId("abc123"); // OK
// printId(true); // エラー

ユニオン型を使うと、異なる型のデータを受け取る関数を柔軟に設計できます。

型ガードを使ってユニオン型を処理する

ユニオン型を使うとき、型に応じた適切な処理を行うために型ガード（Type Guard）を使用 します。

TYPESCRIPT
function printLength(value: string | number) {
  if (typeof value === "string") {
    console.log(`文字列の長さ: ${value.length}`);
  } else {
    console.log(`数値: ${value}`);
  }
}

printLength("TypeScript"); // 文字列の長さ: 10
printLength(42); // 数値: 42

このように、typeof を使うことで、ユニオン型の値に適切な処理を適用 できます。

3. インターセクション型（Intersection Type）

インターセクション型は、複数の型を組み合わせて、新しい型を作る ために使用されます。

インターセクション型の基本

TYPESCRIPT
interface Person {
  name: string;
}

interface Employee {
  employeeId: number;
}

type EmployeeInfo = Person & Employee;

const employee: EmployeeInfo = {
  name: "Alice",
  employeeId: 101,
};

ここでは、Person と Employee を組み合わせた EmployeeInfo 型を定義し、
name と employeeId の両方を持つオブジェクトを作成しています。

インターセクション型の活用例

オブジェクトの拡張に便利

TYPESCRIPT
interface Developer {
  skills: string[];
}

interface Manager {
  teamSize: number;
}

type TechLead = Developer & Manager;

const techLead: TechLead = {
  skills: ["TypeScript", "React"],
  teamSize: 5,
};

このように、複数のインターフェースを組み合わせて、より詳細な型を定義 できます。

4. ユニオン型 vs インターセクション型の違い

具体例

TYPESCRIPT
type A = { a: number };
type B = { b: string };

type UnionType = A | B;
type IntersectionType = A & B;

const u1: UnionType = { a: 10 }; // OK
const u2: UnionType = { b: "hello" }; // OK
const u3: UnionType = { a: 10, b: "hello" }; // OK

const i1: IntersectionType = { a: 10, b: "hello" }; // OK
// const i2: IntersectionType = { a: 10 }; // エラー（b がない）

ユニオン型は「どちらかの型が含まれていれば OK」、インターセクション型は「すべての型を持っていなければならない」違いがあります。

まとめ

ユニオン型とインターセクション型を使いこなすことで、柔軟で安全な型定義が可能になります。