過去バージョン

型の全体マップ

Primitive Types

// number (整数・浮動小数点・特殊値全部)
let n1: number = 42;
let n2: number = 3.14;
let n3: number = 0xff;       // 16進
let n4: number = 0b1010;     // 2進
let n5: number = 0o755;      // 8進
let n6: number = NaN;
let n7: number = Infinity;

// string
let s1: string = "hello";
let s2: string = 'world';
let s3: string = `tagged ${n1}`;   // テンプレートリテラル

// boolean
let b: boolean = true;

// bigint (ES2020)
let bi: bigint = 1234567890123456789n;
let bi2: bigint = BigInt("9007199254740993");

// symbol
let sym: symbol = Symbol("id");
let sym2: symbol = Symbol.for("global");

// undefined / null
let u: undefined = undefined;
let nl: null = null;

any / unknown / never / void

// any: 何でも入る、何でもできる (型チェック完全無効)
let a: any = 42;
a = "hello";
a.toUpperCase();    // チェックされない (実行時エラー可能性)

// unknown: 何でも入るが、使う前に型を絞る必要あり
let u: unknown = 42;
// u.toUpperCase();  // ❌ unknown は呼べない
if (typeof u === "string") {
  u.toUpperCase();  // ✅ ここでは string と判明
}

// never: 絶対に存在しない値の型
function fail(msg: string): never {
  throw new Error(msg);
}
function infinite(): never {
  while (true) {}
}

// void: 戻り値が無い (undefined を返すと同義)
function log(msg: string): void {
  console.log(msg);
}

Object 型

// オブジェクトリテラル型
let user: { name: string; age: number } = { name: "山田", age: 30 };

// interface
interface User {
  name: string;
  age: number;
  email?: string;       // Optional
  readonly id: number;  // 読み取り専用
}

// type alias
type Point = {
  x: number;
  y: number;
};

// Index Signature (任意キー)
type StringDict = { [key: string]: string };

// {}, object, Object の違い
let x1: {} = "anything";       // null / undefined 以外何でも (緩い)
let x2: object = { a: 1 };     // オブジェクトのみ (Primitive 不可)
let x3: Object = "abc";        // Object 型 (≒ {})
// → {} / Object は使わず、明示的に型を書くのが推奨

Array と Tuple

// 配列 (2 つの書き方)
let arr1: number[] = [1, 2, 3];
let arr2: Array<number> = [1, 2, 3];

// 多次元
let matrix: number[][] = [[1, 2], [3, 4]];

// readonly 配列 (要素追加不可)
let ro: readonly number[] = [1, 2, 3];
// ro.push(4);  // ❌

// Tuple (要素数と型が固定)
let pair: [string, number] = ["age", 30];
let triple: [string, number, boolean] = ["taro", 30, true];

// Optional Tuple (TS 3.0+)
let opt: [string, number?] = ["a"];

// Rest Tuple
let rest: [string, ...number[]] = ["sum", 1, 2, 3];

// Named Tuple (TS 4.0+)
let xy: [x: number, y: number] = [10, 20];

Enum

// Numeric Enum (デフォルト)
enum Direction {
  Up,       // 0
  Down,     // 1
  Left,     // 2
  Right,    // 3
}
let d: Direction = Direction.Up;

// 初期値指定
enum HttpStatus {
  OK = 200,
  NotFound = 404,
  Error = 500,
}

// String Enum (推奨: 値が文字列なので可読性が高い)
enum Color {
  Red = "red",
  Green = "green",
  Blue = "blue",
}

// const enum (ビルド時にリテラル展開、JS に enum 自体は残らない)
const enum LogLevel {
  Debug, Info, Warn, Error,
}
console.log(LogLevel.Info);  // → console.log(1) に変換

リテラル型

// 値そのものを型にする
let one: 1 = 1;
let hello: "hello" = "hello";

// Union と組み合わせて「許す値」を制限
type Direction = "up" | "down" | "left" | "right";
let d: Direction = "up";
let d2: Direction = "north";   // ❌

// Numeric Literal
type Dice = 1 | 2 | 3 | 4 | 5 | 6;

// Boolean Literal
type Truthy = true;

// Template Literal Type (TS 4.1+)
type Greeting = `Hello, ${string}`;
type Event = `on${Capitalize<string>}`;   // "onClick" / "onChange" など

Union / Intersection

// Union: AかBかCのどれか
type ID = string | number;
type Result<T> = { ok: true; data: T } | { ok: false; error: string };

// Intersection: AかつBかつC
type WithId = { id: number };
type WithName = { name: string };
type Person = WithId & WithName;   // { id: number; name: string }

Function 型

// 関数型
type BinaryOp = (a: number, b: number) => number;
const add: BinaryOp = (a, b) => a + b;

// Call Signature (オブジェクト型として)
type CallableLog = {
  (msg: string): void;
  level: "info" | "warn" | "error";
};

// Construct Signature
type Constructor<T> = new (...args: any[]) => T;
function create<T>(C: Constructor<T>): T {
  return new C();
}

// Overload
function f(x: string): string;
function f(x: number): number;
function f(x: string | number) { return x; }

Utility Types (組み込み便利型)

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

type PartialUser = Partial<User>;       // 全部 Optional
type UserName = Pick<User, "name">;     // { name: string }
type WithoutEmail = Omit<User, "email">;// { id: number; name: string }

type Dict = Record<string, number>;     // { [k: string]: number }

type Statuses = "active" | "inactive" | "deleted";
type Visible = Exclude<Statuses, "deleted">;   // "active" | "inactive"

async function fetchUser(): Promise<User> { /* ... */ }
type FetchResult = Awaited<ReturnType<typeof fetchUser>>;  // User

function f(a: number, b: string) {}
type Args = Parameters<typeof f>;     // [number, string]
type Ret = ReturnType<typeof f>;      // void

型の幅 (Widening) と Narrowing

// Widening: const は narrow、let は wide
const a = "hello";   // 型: "hello" (リテラル)
let b = "hello";     // 型: string

// const アサーションで強制 narrow
const c = "hello" as const;        // "hello"
const d = ["a", 1] as const;       // readonly ["a", 1]
const e = { a: 1 } as const;       // { readonly a: 1 }

// Narrowing (型ガードで絞る)
function f(x: string | number) {
  if (typeof x === "string") {
    x.toUpperCase();  // ここでは string
  } else {
    x.toFixed(2);     // ここでは number
  }
}

FAQ

Q: String と string の違いは?
A: string は Primitive、String はラッパーオブジェクト型。常に小文字 string を使います。

Q: any[] と unknown[]?
A: any[] は要素を何でも使える危険型、unknown[] は安全だが利用前に型を絞る必要あり。原則 unknown[]。

Q: Tuple と配列の違いは?
A: Tuple は長さと各位置の型が固定。[string, number] は 2 要素のみで型順序が決まっています。