TypeScriptで | を使わずにユニオン型を得る方法大全

ユニオン型は、`string | number`のような記法で「`string`**または**`number`」のような意味の型を作る方法です。TypeScriptプログラミングではユニオン型は非常に便利で、様々なインターフェースを的確に型で表現するためには欠かせない道具です。

ユニオン型を得るためには上の例のように`|`記法を使いますが、この記事では`|`と書かずに型推論を用いてユニオン型を得る方法を集めてみました。

## 構文系

JavaScriptの構文の意味から型推論でユニオン型が推論される系です。

### 条件分岐

条件分岐の構文では、ランタイムの条件によって結果が変わるため、コンパイル時には結果がどちらに分岐するか分かりません。そのため、TypeScriptコンパイラはどちらでも対処できるようにユニオン型を推論します。

#### 条件演算子

```ts
let c = Math.random() ? "pikachu" : 25;

type T = typeof c;
```

こうすると`T`は`string | number`型となります。`|`を使わずにユニオン型を得ることができました。
#### if文

if文などを使う場合でもユニオン型を得ることができます。この場合は関数の返り値の型の推論と組み合わせましょう。

```ts
function f() {
  if (Math.random()) {
    return "pikachu" + "";
  } else {
    return 25 + 0;
  }
}
// type T = string | number
type T = ReturnType<typeof f>;
```

あるいは、`let`の型の推論と組み合わせることもできます。

```ts
let v;
if (Math.random()) {
  v = "pikachu";
} else {
  v = 25;
}
// type T = string | number
type T = typeof v;
```

#### 型ガードと`||`

TypeScriptでは`typeof v === "string"`のような条件式（型ガード）によって`v`の型を`string`に絞り込んだりすることができます。複数の型ガードを`||`で繋げるとユニオン型になります。

```ts
function f(val: unknown) {
  if (typeof val === "string" || typeof val === "number") {
    // type T = string | number
    type T = typeof val;
  }
}
```

`|`を使わないんだから`||`も使いたくないという場合は、`&&`を使うこともできます。

```ts
function f(val: unknown) {
  if (!(typeof val !== "string" && typeof val !== "number")) {
    // type T = string | number
    type T = typeof val;
  }
}
```

また`typeof val === "object"`で`unknown`を絞り込むと`object | null`というユニオン型を作ることができます。

```ts
function f(val: unknown) {
  if (typeof val === "object") {
    // type T = object | null
    type T = typeof val;
  }
}
```


### 配列リテラル

TypeScriptでは、`as const`を付けない配列リテラルは`T[]`の形の型に推論されます。配列の中身に複数の型の値がある場合、`T`はユニオン型となります。

```ts
const arr = ["pikachu", 25];
// type T = string | number
type T = typeof arr extends (infer T)[] ? T : never;
```

## 型計算系

純粋な型の計算でユニオン型を作る系です。

### タプル型を使う

タプル型に対して`number`でlookupするとタプル型の各要素のユニオン型を得ることができます。

```ts
// type T = string | number
type T = [string, number][number];
```

@kazatsuyu さんのご指摘で追加しました。ありがとうございました。

### オプショナルなプロパティを使う

オブジェクトのオプショナルなプロパティの型を取得すると、自動的に`undefined`とのユニオン型になります。

```ts
// type T = string | undefined
type T = {a?: string}['a']; // string | undefined
```

@cisdur7 さんのご指摘で追加しました。ありがとうございました。

ちなみに、TypeScript 4.1で追加されたTemplate Literal Typesを用いると、次のようにして`string | number`など任意のユニオン型を作ることができます。

```ts
type PU = {a?: "pikachu"}['a'];

// type T = string | number
type T = { pikachu: string; undefined: number }[`${PU}`];
```


### `keyof`を使う

次のように複数のキー名を持つオブジェクト型に対して`keyof`を用いるとユニオン型が得られます。これは、`Obj`を`{ pikachu: number } & { pichu: number }`と見て、オブジェクトのキー名が反変の位置にあることを用いてインターセクション型をユニオン型に変換しているという見方もできます。

```ts
type Obj = {
  pikachu: number;
  pichu: number;
};
// type T = "pikachu" | "pichu"
type T = keyof Obj;
```

### `infer`を使う

複数の位置で同じ型変数を`infer`すると、ユニオン型が推論されます（反変の位置にある場合はインターセクション型になります）。

```ts
type Obj = {
  pikachu: string;
  pichu: number;
}
// type T = string | number
type T = Obj extends { pikachu: infer T; pichu: infer T } ? T : never;
```

### Conditional Typesを使う

Conditional typesは条件分岐を表す型ですが、特定の条件で両辺のユニオン型に解決される場合があります。

```ts
type A<V> = V extends boolean ? string : number;
// type T = string | number
type T = A<any>;
```

### Mapped Typesを使う

TypeScript 4.1で追加されたMapped Typesのkey remappingを使うと、複数のキーに由来する型を同じキーに集めることでユニオン型を発生させられます。

```ts
type Obj = {
  pikachu: string;
  pichu: number;
};

type Obj2 = {[K in keyof Obj as "raichu"]: Obj[K]};
// type T = string | number
type T = Obj2["raichu"];
```

### タプル型を使う (2)

TypeScript 4.0で追加されたVariadic Tuple Typesでは、`[string, ...T, string]`のような型を書くことができるようになりました。しかし、もし例えば`T`が`number`だった場合に、結果は`[string, ...number[], string]`とはなりません。可変長部分よりも後ろに固定長の部分が来ることはできないからです。

ただし、TypeScript 4.2ではこの点が改良されて`[string, ...number[], string]`もOKになります。ただし可変長部分はタプル型の中に1つだけであり、`[string, ...number[], string, ...number[], string]`のようなものは依然として不可能です。

このようなTypeScriptで許可されていないタプル型を作ろうとした際にはTypeScriptで扱える形に強制的に変換され、その際にユニオン型が生じることがあります。

```ts
type A<N extends any[]> = [string, ...N, string, ...N, string];
// type T = string | number
type T = A<number[]>[1];
```

## まとめ

この記事では、`|`を使わずにユニオン型を得る方法をまとめました。これでキーボードが壊れて`|`が入力できなくなっても安心ですね。

思いつく限り記載しましたが、もしかしたら抜けがあるかもしれません。見つけた方はぜひ教えてください。