TypeScript②（型の機能）

### この記事について
この記事は私がTypeScriptについて学んだ内容を
[TypeScript①（基礎)](https://qiita.com/zgoovw_/items/7a6fcb18b92c6073f120)
TypeScript②（型の機能）
[TypeScript③（ユーティリティタイプ）](https://qiita.com/zgoovw_/items/2d0236f52e85e78d6109)
の3回に分けて網羅的に紹介していきます。

①（基礎）では導入方法と様々な型について簡単な紹介
③（ユーティリティタイプ）では型変換を容易にするユーティリティ型について

今回は型が実際にどういう働きをするのかについてです。

### 参考リンク

- [TypeScript公式ドキュメント](https://www.typescriptlang.org/docs/)
- [サバイバルTypeScript 〜実務で使うなら最低限ここだけはおさえておきたいTypeScript入門〜
](https://book.yyts.org/)
- [TypeScript Deep Dive 日本語版](https://typescript-jp.gitbook.io/deep-dive/)
- [実践TypeScript ~ BFFとNext.js&Nuxt.jsの型定義~ 単行本](https://www.amazon.co.jp/%E5%AE%9F%E8%B7%B5TypeScript-BFF%E3%81%A8Next-js-Nuxt-js%E3%81%AE%E5%9E%8B%E5%AE%9A%E7%BE%A9-%E5%90%89%E4%BA%95-%E5%81%A5%E6%96%87/dp/483996937X/ref=tmm_pap_swatch_0?_encoding=UTF8&qid=&sr=)


# 型安全
TypeScriptには強力な型推論が備わっており、必ずしも型を定義しないといけないわけではありません。
ですが、場合によって明示的に型を指定して型安全を担保することが必要です。

### nullチェック
次の関数では引数がnullの場合でもコンパイルを通してしまい、エラーの発見が遅れる可能性があります。

```ts
function foo(num) {
  return `${num.toFixed(1)}`;
}
console.log(foo(0.1003)); // 0.1
console.log(foo(null)); // ランタイムエラー(コンパイルは通る)
```

このようなnumberとnullのどちらの値もありえるという状況は`number | null`という型で表すことができます。
number | null型の値はnullかもしれないので、numberとして扱ったりプロパティを参照したりすることができません。

```ts
function foo(num: numbar | null) {
  return `${num.toFixed(1)}`;
}
console.log(foo(0.1003)); // 0.1
console.log(foo(null)); // コンパイルエラー
```
これに対し、nullでなければ処理したいという場面はif文でnullチェックを行う方法があり、TypeScriptはこれを適切に解釈して型を絞り込んでくれます。

```ts
function foo(num: number | null) {
  if (num != null) { // この行でのnullの型推論　num: number | null
    return `${num.toFixed(1)}`; // この行でのnullの型推論　num: number
  } else {
    return 0;
  }
}
console.log(foo(0.1003)); // 0.1
console.log(foo(null)); // 0
```
### 引数をオプションにする
引数に`?`をつけることで引数のない場合を許容する事ができます。
しかし以下の場合にはエラーは発生しませんがundefinedが返されます。

```ts
function greet(name?) {
  console.log(`Hello ${name}`);
}
greet("Mako"); // Hello Mako
greet(); // Hello undefined
```

上記のようにnameの型は自動的に`string | undefined`になるため、undefinedチェックを行う必要があります。

```ts
function greet(name?) {
  return name != null ? console.log(`Hello ${name}`) : console.log("Hell0");
}
greet("Mako"); // Hello Mako
greet(); // Hello
```

### readonly
プロパティに`readonly`をつける事でプロパティへの再代入を防ぐ事できます。

```ts
type Foo = {
  readonly name: string;
};
const foo: Foo = {
  name: "Ken",
};
foo.name = "Reo";
console.log(foo); // コンパイルエラー
```

### アノテーション・アサーション
アノテーションは型の注釈のこと

```ts
num: number;
```

アサーションは下記の右辺の型の宣言のこと

```ts
let num: number = (<string>comment).length;
```

```ts
let num: number = (comment as string).length;
```

### ダウンキャスト
タイプアサーションを使用して、より具体的なタイプを指定するのがダウンキャストです。

```ts
const myCanvas = document.getElementById("main_canvas") as HTMLCanvasElement;
```

### アップキャスト
ダウンキャストの逆に型の抽象度を上げるのがアップキャストです。

```ts
function foo(num: string) {
  return console.log((num as any) * 2);
}
foo("3"); // 6
```

### インデックスシグネチャ
下記の`[k: string]`をンデックスシグネチャといい、定義されていないプロパティを追加する事ができます。

```ts
type Foo = {
    [k: string]: any; 
};
const foo: Foo = {
  name: "Nana",
  age: 20,
};
```

またインデックスシグネチャには様々な制限をかけるができます。

```ts
type Fruit = "apple" | "banana" | "lemon";
type Foo = {
  [k: string]: Function | Promise<any> | Fruit;
};
```

### const
constで適用される型は`Widening Literal Types`という型で、下記のような違いと利用方法があります。

```ts
let foo = "foo"; // stringとして推論される
const bar = "bar"; // "bat"と推論される

const Baz = {
    a: "a", // a: "a"
    b: "b", // b: "b"
    c: "c". // c: "c"  
} as const
```

### Typeof
typeof演算子は与えられた値の型を文字列で返す演算子です。これを利用して安全に処理することができます。

```ts
function foo(value: string | number) {
  if (typeof value === "string") {
    return console.log(value.length);
  }
  return console.log(value * 2);
}
foo("100"); // 3
foo(100); // 200
```

### in
in演算子は与えられた値が型に含まれているかの評価結果をbooleanで返します。in演算子を使うことで型の絞り込みが可能です。

```ts
type Foo = {
  color: string;
  point: number;
};
type Bar = {
  name: string;
  age: number;
};
function log(obj: Foo | Bar) {
  if ("color" in obj) { // obj: Foo | Bar
    return console.log(obj); // obj: Foo
  }
  if ("age" in obj) { // obj: Bar
    return console.log(obj); // obj: Bar
  }
}
```
このほかにinstanceof演算子を利用した絞り込み方法などもあります。

### typeとinterface
型を定義するためにtype、interfaceの二つのの方法がありますが、この二つにはプロパティをオーバーロードできるかどうかという違いがあります。

```ts
interface User {
  name: string;
}
interface User {
  age: number;
}
// Userを利用する際このように結合されます
interface User {
  name: string;
  age: number;
}
```

```ts
type User = { // User重複によるエラー
    name: string
}
type User = { // User重複によるエラー
    age: number
}
```

# Generics
型を変数にすることで様々なコンポーネントで再利用できるようにする事ができます。

```ts
interface Foo<T> {
  foo: T;
}
const bar: Foo<string> = {
  foo: "foo",
};
```

型の初期値を指定

```ts
interface Foo<T = string> {
  foo: T;
}
```

extendsによる型の制約

```ts
function foo<T extends string>(value: T) {
  console.log(value);
}
foo("Hello"); // Hello
```

### keyof と T[K]
`keyof T`で`T`の型が付与され、`T[K]`で`T`の型が持つ`K`の型が付与される。
これによりキャストの省略が可能になる。

```ts
interface Foo {
  bar: string;
  baz: number;
}
type Hoge = keyof Foo;  // string | numbar
type Fuga = Foo["bar"]; // string
type Peyo = Foo["baz"]; // number
```

keyofとT[K]を組み合わせた利用。

```ts
function hoge<T, K extends keyof T>(user: T, key: K): T[K] {
  return user[key];
}
interface User {
  name: string;
  age: number;
}
const user = {
  name: "Takeru",
  age: 25,
};
const foo = hoge(user, "name"); // const foo: string
const bar = hoge(user, "age"); // const bar: number
```

### Mapped Types
Mapped Typesは`{[P in K]: T}`という構文を持つ型です。
これが何をするかというと雑にいえば型世界でのmapメソッドです。

```ts
{[P in K]: T} // Pの中身をK、その型をTにする

type Item = { a: string; b: number; c: boolean; };
type Foo = {[P in keyof Item]: string}
// Pの中身を{a, b, c}にして、その型をstringにする{a: strting, b: string, c:　string}
// それをFooに代入している
// type Foo = {a: strting, b: string, c:　string}
```

### Conditional Types
Conditional Typesは`T extends U ? X : Y`という構文を持つ型です。
三項演算子を利用して条件分岐ができます。

```ts
type Foo<T> = T extends string ? true : false; // string型をture型に変換し、それ以外の型をfalse型に変換します。
type Bar = Foo<"foo">; // type Bar = true
type Baz = Foo<0>; // type Baz = false
```

### Mapped Types × Conditional Types
`{[P in K]: T}`と`T extends U ? X : Y`を組み合わせた例です。

```ts
type Item = { a: string; b: number; c: boolean };
type Foo<T, U> = {
  [K in keyof T]: T[K] extends U ? true : false;
};
type Bar = Foo<Item, string>; // type Bar = {a: true; b: false; c: false; };
type Baz = Foo<Item, number>; // type Baz = { a: false; b: true; c: false; };
```

***

今回は型で型を変換するという複雑な内容でしたが、次の[TypeScript③（ユーティリティタイプ）](https://qiita.com/zgoovw_/items/2d0236f52e85e78d6109)ではスクラッチで型変換ロジックを作成なくても、TypeScriptが元々持っている型変換を容易にできる型（ユーティリティタイプ）のついて紹介します。

### 関連記事
[TypeScript①（基礎)](https://qiita.com/zgoovw_/items/7a6fcb18b92c6073f120)
[TypeScript③（ユーティリティタイプ）](https://qiita.com/zgoovw_/items/2d0236f52e85e78d6109)