型推論のTips集

# 始めに
自分が今までTypeScriptで型推論させるにあたって、中々いい方法が見つからず、他にいいやり方がないか模索して時間がかかってしまうケースがいくつかありました。
そこで今回は割と使うケースで解決するのに苦労したものについて、Tipsという形でまとめてみました。自分はこのやり方でやっていますが、他にいいやり方があれば是非コメントください！
基本編と上級編に分けており、上級編の方が割と込み入ったことをやっているものになります。

# 基本編
## Object.keysに型をつける
`Object.keys`の返り値の型は`string`で固定されているため、以下のように書くとtype errorになってしまいます。

```typescript
const obj = {
  a: 10,
  b: 'text',
  c: true,
};

Object.keys(obj).forEach((key) => {
  // key: string なのでエラーになってしまう
  console.log(key, obj[key]);
});
```

そこでkeyのunion typeが返ってくるようなメソッドでラップします。

```typescript
function typedKeys<T>(obj: T) {
  return Object.keys(obj) as Array<keyof T>;
}

typedKeys(obj).forEach((key) => {
  // key: 'a' | 'b' | 'c' となるのでOK
  console.log(key, obj[key]);
});
```

### 余談
一応`ObjectConstructor`を型拡張することで`Object.keys`でも詳細の型が当たるようになりますが、僕はなんとなく直接いじるのは良くなさそうな気がしたので上記のようにラップしたメソッドを使っています。

```typescript
interface ObjectConstructor {
  // Object.keysの型を上書く
  keys<T>(obj: T): Array<keyof T>;
}

Object.keys(obj).forEach((key) => {
  // key: 'a' | 'b' | 'c' となるのでOK
  console.log(obj[key])
})
```

### サンプルコード

https://www.typescriptlang.org/play?#code/MYewdgzgLgBCBGArGBeGBvAUDGBDAXDAIwAMANNjPIQORQCmAHlDRTsIVAE4Cu9FAX0yYAZjzDAoAS3AwoATwAO9ACYBpevIgAeACoA+ABQJEhXQEoMlLvSg8uYGAHkk9SQDoA1pojGkl3AgYAEEuLlx5bW95EBEYAwBuTCFMAHpUmEBmhkBDhkBnhkAJhkAkhkA0TUBNBkALBhdENygvH0BzBkAghgVlGHowkC5CwGPIwAjbesBZBkBohjSMqTAGLhFcYHpnV0kAYXBoXklOq3ScGGidAz9TePNCUPDI6Nj4-SStlKqauq0D83cRToBRGYALQ0NoyxQ+is7BWIAANvR3GCQABzA4AbWiAF1zEkBKjhC1VBoniYXm8uJ9gD8-poAUCsCDIODIdC4SZEZoUWiMUA

## filterでnullの型を除去したい時
filterでnullを除去したのに、型はnullも入ったままになってしまいます。

```typescript
const arr = [1, 2, 3, null, null];

// filterでnullは取り除いても型はArray<number | null>
const result = arr.filter((item) => item != null);
```

`is`を使ったtype guardを使うとnullを取り除いた結果を返すことができます。

```typescript
// Array<number>になる
const result = arr.filter((item): item is number => item != null);
```

ただこれを毎回書くのは手間なので、filterHandlerを用意することでnullの型を除去した内容が返ってくるようにできます。

```typescript
function omitNullableHandler<T>(item: T): item is NonNullable<T> {
  return item != null;
}

// nullが取り除かれてArray<number>になる
const result = arr.filter(omitNullableHandler)
```

### サンプルコード
https://www.typescriptlang.org/play?#code/MYewdgzgLgBAhgJwTAvDA2gRgDQwEy4DMuYArgDbkkXkC6A3AFCMD0LMAgknAJ4A8ZALYAjAKbIAPjDKUAfDEB2DID8GJY1CRYCURAqw0iBADoAZgEtyUcQAorpy4ICUqeXdGCYAQjQzyD5sdIwYChTcBgQQTsAORo4YXJRAAs4MAATBIQ+ABVZW3sALhgsh0LXd1MIGCjwGMo4hOz5AG9GGBgtKFIEMBgyz28aJgBfZjZpGkAZBkA15UAohkATNMBpBkAYhkAzBi4EXgFSEXFZQGsGQCsGQGiGNXBodu1dPFR4JBNzSwQrCOjY+KSU9PEHJiA

## union typeを配列にしたい場合
`type Direction = 'east' | 'west' | 'south' | 'north'`のように先にunion typeで型定義をして、それを網羅した配列を作りたいケースです。

残念ながらこのやり方は存在しませんが、逆に先に配列を定義して、その後union typeを生成する流れはできます。

```typescript
const directionList = ['east', 'west', 'south', 'north'] as const;
// 'east' | 'west' | 'south' | 'north'
type Direction = typeof directionList[number];
```

### サンプルコード
https://www.typescriptlang.org/play?#code/MYewdgzgLgBAJgSwE4FNhQeAMg6MC8MA2gOQoCG0JANDCQO4pW0kQgCuUAFjXWCEm4kAujEoxQkKAG4AUAHp5dClRgAfOo1UbWHIer4ChsqAE8ADihgARZGgzgCMM5ZAAzeHfSYwOaETB2AFsAIxQkYTkgA

## enumを使いたい場合
TypeScriptにはenumがありますが、あまりしっかりとしていなくて、enum値以外も代入できてしまう問題があります。

```typescript
enum Direction {
  Up,
  Right,
  Down,
  Left,
};

// enumの型で、enumに入っている値を入れる
const dir: Direction = Direction.Up;

// 範囲外のenum値でも代入できてしまうorz
const dir2: Direction = 10;
```

これ以外にもenumには問題があるらしく、TypeScriptでenum的なことをする場合は以下のように一度オブジェクトで定義してからunion typeに変換するのが良いです。ちょっと冗長で分かりづらいところもあると思いますが、型安全のことを考えるとこれが一番だと思ってます。

```typescript
const Direction = {
  Up: 0,
  Right: 1,
  Down: 2,
  Left: 3,
} as const;
// constと同じ名前で型定義できる
type Direction = typeof Direction[keyof typeof Direction];

// 使い方はenumと変わらないがTSとJS空間が分かれていて、知らないと混乱するかも
// 左のDirection: TS空間のtype
// 右のDirection: JS空間のconst
const dir: Direction = Direction.Up;

// constで定義した値以外を弾ける
const dir2: Direction = 10;
```

### サンプルコード

https://www.typescriptlang.org/play?#code/N4Ag9GIKYHYK4FtDmDIdCVCYxoTQZDRDAKBNeBEAEQEsAnKAYwBdSB7GEYPfEAVQAcAaV-AJVIBzABY1ebEvQDuMCWwAyUAGbjWAXwDcOVhAKJAdgyBo9SSBABliJA1gyBTRUDGDIDMGQCIMWQCQKgJIZrgGIZc+KowDONCAAJhQAXCQU1HSMIAC8kZS0DDAAdFzaupCAI96AT2qAaJoGFgguSIBBDIDHctZIgLIM9oDqDIB+DIBiDPTkAF6sfjCBIRQATBFkSTFMCQCMAAza6jqget2BqJg+IItBw9Ep8cx8HJwRk-ICwmIR48dSshH9l0qqEQDM8uogAIb+awE02vgL34ALBkAMCqADQZALAqgFklJBGQBZ2oBK-1qqxoAE9OFBEltYgkUWj6MoMclGABtADWUGReJAOKglM2hJgAF1Mn9IIB-eUcgE7TQD2DMUAYBITUA8QyASIZAFYMjkAMgwAFQAygCAFLSwBeXoBk1PFgDAlQDSDJ4nPZTIBT91FjgBgHfbQCOctgNWUsiBAGe6BjpowiMpVBmp1sAz8r2qL0iIKl3rLrfPrkIbe0Y7B0pdKcZngSDrJDw+qAfQYXIBTuXybkAfPqARQZVutg4MCeGJtMcLMgA

### 参考
- [さようなら、TypeScript enum](https://www.kabuku.co.jp/developers/good-bye-typescript-enum)

## オブジェクトの型から1つだけキーを取り除きたい場合
他に代入する都合で、不要なキーだけ取り除きたいが、改めて型定義するのは面倒な場合です。
意外と簡単で、スプレッド構文で残りを受け取るだけで勝手に型推論してくれます（便利！）

```typescript
const obj = {
  a: 10,
  b: 'text',
  c: true,
};

const { a, ...restObj } = obj;
// restObjにはb, cの内容だけ残る
console.log(restObj);
```

### サンプルコード
https://www.typescriptlang.org/play?#code/MYewdgzgLgBCBGArGBeGBvAUDGBDAXDAIwAMANNjPIQORQCmAHlDRTsIVAE4Cu9FAXwDcmTKEix0eMjAB08rvWgB5JDAGo4SEQHodMRSqSBrBkD2DPBnBAdgyBQxUCd2oAMGQIoMgaOtA0QxjwEEABt6snxAAcwAKQyhVRABKESA

# 上級編
## union typeをループさせたい場合
リストデータをまとめて出力するメソッドを作る際に、細かい調整をparserメソッドを通してやれないかと思った時です。

```javascript
const data = {
  price: 1000,
  enabled: true,
  text: 'hogehoge',
};

const items = [
  {
    label: '金額',
    key: 'price',
    // ここのvalueはdata.priceで定義されたnumberで推論されたい
    parser: (value) => value.toLocaleString(),
  },
  {
    label: '可否フラグ',
    key: 'enabled',
    // ここのvalueはdata.enabledで定義されたbooleanで推論されたい
    parser: (value) => value ? '可' : '否',
  },
  {
    label: 'テキスト',
    key: 'text',
  },
];

function outputList(data, items) {
  items.forEach((item) => {
    const text = item.parser ? item.parser(data[item.key]) : data[item.key];
    console.log(item.label, text);
  });
}

outputList(data, items);
```

これに型を書こうとすると結構難しく、直接型を書くと以下のようにできますが、なんとかループで回して汎用的にしたいところです。

```typescript
type Item<T, K extends keyof T> = {
  label: string;
  key: K;
  parser?: (value: T[K]) => string;
}

type SpecifyItem = 
  // keyofで得られた内容をループでunion typeに変換したい
  | Item<typeof data, 'price'>
  | Item<typeof data, 'enabled'>
  | Item<typeof data, 'text'>;

type SpecifyItems = SpecifyItem[];
```

そのやり方はあるようで、以下の記事を参考にして、ループで書くことができました。

[Literal TypeのUnion Typeをリストのように使用する](https://qiita.com/xyx_is/items/4f838579d31fd86bd921#literal-type%E3%81%AEunion-type%E3%82%92%E3%83%AA%E3%82%B9%E3%83%88%E3%81%AE%E3%82%88%E3%81%86%E3%81%AB%E4%BD%BF%E7%94%A8%E3%81%99%E3%82%8B)

```typescript
type MappedTypeItem<T> = { [K in keyof T]: Item<T, K> }[keyof T];

// MappedTypeItem<typeof data> = {
//   price: Item<typeof data, 'price'>;
//   enabled: Item<typeof data, 'enabled'>;
//   text: Item<typeof data, 'text'>;
// }['price' | 'enabled' | 'text']

// MappedTypeItem<typeof data> == SpecifyItem になる
```

### サンプルコード

https://www.typescriptlang.org/play?#code/MYewdgzgLgBAJgQygmBeGBvAsAKBjABwCcBLYAUwC4YBGABgYBpd9ywEAjAG3LmqiIBXcszwwo5AB5RqAcgAWIAOblFK2aIC+Ably4oATwLkYASQkBbADwAVRjADSMKRLBwIMANbkDIAGYwNgB8aJgsMFyc5FzU0KRgSrpi3gbUDkn4BAhEEOREAPzUABQAbghcwtQ2ANoOALoAlGghcSQJSZr6RiYAsggExnA23ebk1sGhGDC1MG1ePv6BddSj4-YOIZrVKYs2dUmGxmaWELYh6H0DvMPGq2fV+3o4oJCwJCcrJ1aH5IuIyOdpuFsGJ8JEONE5IBFxMAshkacL4FJyYhkcjw0GEbK5IjFMoVchNVAhPHCAB0UBAABkQMByuQAMoCNpKIoNUT4TTssIY8GQmCyQD3yoAyFUAqwyAS4ZAA0M6PwiJ8cjYnB4cGlMqyOTyuPKwkJxK1Jny-IFshgciFKs5wIRESiMX5gDGGQC1DIBOhkAEwwq2WpfkSaTm0SPHC4PyCMDAKAkcAwECCKAEaOUkjQM5Ff4IKr2d5jCCfTNnJog-AZiwQUl+EBEACiCGA8iKRULOu5MpgL2g4hcoULpLV2JgBs73byyaQCGqnZSjRN8GHo8spPHGRlLZAPFJXGUddnvK49m9UAaC80+9wnQDOCjMbjCagQ+Q6ZOR5wQA

## 大枠の型を決めつつ、詳細の型は宣言したものにしたい場合
例えばvuexのようにmutationsを定義する際に先に型を指定することで推論する時、便利ですが逆にその型で丸められてしまい、mutation名をkeyofで取得できなくなる問題があります。

```typescript
// vuexのmutationsの型定義
type Mutation<S> = (state: S, payload?: any) => any;
interface MutationTree<S> {
  [key: string]: Mutation<S>;
}

type State = {
  count: number;
}

const mutations: MutationTree<State> = {
  // stateが推論される
  add(state, value: number) {
    state.count += value;
  },
  sub(state, value: number) {
    state.count -= value;
  }
};

// 'add' | 'sub'が欲しいが、string | numberになってしまう
type mutationName = keyof typeof mutations;
```

型を先に決めておいて、最終結果は宣言したものにしたいというなかなか無茶な要求ですが、クロージャを使って上手いことやることができます。

```typescript
// Tに期待する型を先に書く
function typeChecker<T>() {
  // 推論されるUはTの型に内包されているかチェック
  return function check<U extends T>(checkVar: U) {
    return checkVar;
  };
}

const mutations = typeChecker<MutationTree<State>>()({
  // 推論もちゃんと効く
  add(state, value: number) {
    state.count += value;
  },
  sub(state, value: number) {
    state.count -= value;
  }
});

// ちゃんと 'add' | 'sub' が出てくる
type mutationName = keyof typeof mutations;
```

### サンプルコード
https://www.typescriptlang.org/play?#code/C4TwDgpgBAsgrsAhsAlgewHYB4DKA+KAXigAoBnJYCALihwBooxEQAbNRAEwH5bEMQASiIF+IANwAoFBioAnAGaIAxtHiV0GACpyIEXAQDekqFADaAawghaFOTIDmAXVrrkmg1IC+kyQrgYyqiYUKCQAMIAFhDKVnJYWngkwsamusBwchhQ-oHB2crRsVgAqlAQAB5UGJxkUIkkhTEWAGqIcrQlKSamUOmZBUWt7VKmXt6+YdA4lNDEqVDKaAHAtBhwALYARhByE5JLGBRQGwjumHXEU1HNu1hu+Tp6uLN4SYIkC1yc5LOMAG6IVhwGhQdbbXbdXpQCjICAAOiWKygAGpiIDgRBRlAvPQemQ4FtfnCAUCQWtNjs5FDerCqIjlrIoABadFkrE9HxeQRSSRTE5nfIAOUQGzmUCsIDQClC4Ag0oFGguUiAA

### 詳細
ほとんどここで書いた内容が全てですが、こちらにも書いてありますので、興味がある方は読んでください。

https://zenn.dev/wintyo/articles/3901d01fadc1c8

# 終わりに
以上が型推論のTips集でした。結構実装に悩んだものばかりですが、汎用的になっているので結構参考になれる部分が多いかなと思っています。似たようなケースにぶち当たった時に参考になれれば幸いです。