この記事では、ヘッドレスCMSの利用方法・学習コスト・歴史的変遷・Next.js を用いた実装方法を初学者に分かりやすく解説します。

ヘッドレスCMSとは（学習コスト・種類・歴史・実装）


## TL;DR

このページでは、React の`dangerouslySetInnerHTML`の実装方法について解説しますね。一言でいうと`dangerouslySetInnerHTML`とは、React で直接 HTML を描画するための手段です。サードパーティからのコンテンツ表示やリッチテキストエディターなどで使われます。ただし、この名前が示す通り、この属性を使うときは注意が必要です。

以下が、今回使用する開発環境とそのバージョンです。

| 開発環境   | バージョン |
| :--------- | :--------- |
| Next.js    | 13.4.4     |
| TypeScript | 5.0.4      |
| Emotion    | 11.11.0    |
| React      | 18.2.0     |

### 'dangerouslySetInnerHTML' とは？

React では、通常、JSX を使って UI を描画します。しかし、場合によっては直接 HTML を描画したいこともあります。そのときに活用できるのが`dangerouslySetInnerHTML`です。

まずは簡単なコードから始めてみましょう。

```tsx
const Component = () => {
  return <div dangerouslySetInnerHTML={{ __html: '<h1>Hello World</h1>' }} />
}
```

上記のコードは、`<h1>Hello World</h1>`という HTML を直接描画します。このときに使っているのが、`dangerouslySetInnerHTML`属性です。

ただ、この属性の名前にある'dangerously'のとおり、これを使うときは慎重になる必要があります。なぜなら、この属性を使うと XSS（クロスサイトスクリプティング）というセキュリティリスクが生じるからです。XSS とは、不正なスクリプトが実行されてしまう攻撃手法のことで、これを防ぐためには、描画する HTML のエスケープが重要になります。

### どのようなときに使うのか？

`dangerouslySetInnerHTML`を使用する場合は、その HTML 文字列が信頼できるソースから来ているか、または適切にサニタイズ（悪意のあるコードの除去）されていることを確認する必要があります。

`dangerouslySetInnerHTML`の使用は、基本的には HTML コンテンツを直接描画する必要があるケース全般に適用されます。ただし、このプロパティは XSS 攻撃のリスクがあるため、使用は最小限に抑え、適切なサニタイズ処理が行われていることが前提となります。

#### サードパーティからのコンテンツ表示

外部 API から取得した HTML 形式のコンテンツ（ニュース記事、ブログ投稿など）を表示するときなどに使われます。この場合、取得したコンテンツが信頼できるソースから提供されていること、またはサニタイズ処理を行って悪意のあるコードを除去していることが必要です。

#### リッチテキストエディター

リッチテキストエディター（テキストの装飾、リンク、画像の挿入などが可能なエディター）を実装している場合、ユーザーが作成したリッチテキストの内容を HTML として表示する必要があります。そのため、`dangerouslySetInnerHTML`を使うことで HTML タグを含むテキストを適切にレンダリングできます。

#### SVG の挿入

SVG 形式のアイコンや図形を表示する際にも`dangerouslySetInnerHTML`を使用することがあります。ただし、SVG もスクリプトを含むことが可能なので、SVG データが信頼できるソースから得られていることを確認する必要があります。

#### マークダウンを HTML に変換する

マークダウンエディタでユーザーが書いたテキストをウェブページ上でレンダリングしたいとき、そのマークダウンテキストを HTML に変換するライブラリ（例えば、marked や remark など）を使います。この変換された HTML 文字列を`dangerouslySetInnerHTML`でレンダリングすることで、ユーザーが書いたマークダウンテキストが HTML として表示されます。

#### HTML プレビュー

ユーザーが直接 HTML を編集するエディタを提供している場合、その HTML をリアルタイムでプレビュー表示する必要があります。その際に`dangerouslySetInnerHTML`を使用して、ユーザーが編集した HTML をそのままウェブページに表示します。

いずれの場合も、ユーザーが入力した内容が悪意のあるコードを含んでいないか確認するために、入力をサニタイズするなどのセキュリティ対策を講じるべきです。

### 安全に`dangerouslySetInnerHTML`を使うために

TypeScript を使って、`dangerouslySetInnerHTML`をより安全に使うための方法を見ていきます。まずはエスケープ関数を作成します。

```tsx
const escapeHtml = (unsafe: string) => {
  return unsafe.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#039;')
}

const Component = ({ html }: { html: string }) => {
  return <div dangerouslySetInnerHTML={{ __html: escapeHtml(html) }} />
}
```

ここではまず、HTML をエスケープするための関数`escapeHtml`を作りました。この関数は、HTML で特殊な意味を持つ文字（`&`、`<`、`>`、`"`、`'`）を対応する HTML エンティティに置き換えます。これにより、HTML がそのまま描画されるのを防ぐことができます。

次に、この`escapeHtml`関数を使って`dangerouslySetInnerHTML`の HTML をエスケープしています。これにより、コンポーネントに渡される HTML がそのまま描画されるのを防ぐことができます。

### ヘッドレス CMS との連携

次は、microCMS で、記事のコンテンツを出力するためのコードです。

このソースコードの一部である`dangerouslySetInnerHTML`は、React が提供するエスケープされていない HTML をコンポーネントに挿入するためのプロパティです。名前に`dangerously`がついているのは、このプロパティを使用すると、XSS（クロスサイトスクリプティング）のようなセキュリティリスクが生じる可能性があるからです。このため、`dangerouslySetInnerHTML`は制御された状況下で、安全に扱う必要があります。

```tsx
export default function BlogId({ blog }) {
  return (
    <main>
      <h1>{blog.title}</h1>
      <p>{blog.publishedAt}</p>
      <div
        dangerouslySetInnerHTML={{
          __html: `${blog.body}`,
        }}
      />
    </main>
  )
}
```

microCMS というヘッドレス CMS（API ベースの CMS）は、ブログ記事のようなリッチテキスト（フォーマットされたテキストやメディアを含むテキスト）を管理するのに便利です。このようなリッチテキストは、HTML 形式で提供されることが一般的です。

このコードスニペットでは、`blog.body`というプロパティが`dangerouslySetInnerHTML`に渡されています。これは、`blog.body`が HTML 形式であると予想され、そのままレンダリングするために`dangerouslySetInnerHTML`が使用されています。

具体的には次のような構造になります。

```tsx
<div
  dangerouslySetInnerHTML={{
    __html: `${blog.body}`,
  }}
/>
```

ここで、`dangerouslySetInnerHTML`はオブジェクトを受け取ります。その中の`__html`キーは特殊で、これに代入された文字列が HTML として挿入されます。文字列テンプレート`${blog.body}`は`blog.body`を文字列として挿入します。

この方法で、`blog.body`の中身が直接的に HTML として解釈され、描画されます。つまり、もし`blog.body`が`<p>Hello, world!</p>`であれば、これがそのまま HTML としてページに描画され、ユーザーは"Hello, world!"という段落を見ることができます。

ただし、`dangerouslySetInnerHTML`はその名前が示す通り、使用には注意が必要です。不適切に使用すると XSS 攻撃などのセキュリティリスクを生じる可能性があります。なので、挿入する HTML が完全に信頼できる（例えば CMS からの直接の出力など）場合のみ使用すべきであり、ユーザーからの入力をそのまま挿入するような場合には使用すべきではありません。

### 注意点としての HTML エスケープ

ここまでで、`dangerouslySetInnerHTML`を使うための基本的な方法とその注意点を見てきました。しかし、これだけで十分というわけではありません。これからも、さまざまな場面やケースに対応するために、どのような HTML をエスケープするか、どの程度エスケープするかを考える必要があります。

また、エスケープを行うことで安全性は高まりますが、それでもなお完全な安全性を保証するものではありません。可能な限り、`dangerouslySetInnerHTML`の使用は避け、他の手段を考えることも大切です。

以上が、React の`dangerouslySetInnerHTML`とその使い方についての解説です。React を使う上で、この属性を使う機会は少なくないかもしれません。ただ、その際には常に安全性を考えて、注意深く使うようにしましょう。


`dangerouslySetInnerHTML`とは、React で直接 HTML を描画するための手段です。しかし、扱いには注意が必要です。

React の dangerouslySetInnerHTML とは何か？


## TL;DR

このページでは、React JSX.Element の実装方法について解説しますね。一言でいうと、React JSX.Element は React コンポーネントが返すべき型です。

| 開発環境   | バージョン |
| :--------- | :--------- |
| TypeScript | 5.0.4      |
| React      | 18.2.0     |

### JSX.Element とは？

JavaScript の世界において、HTML を直接コード内に記述するためのシンタックスが JSX です。これを使用することで、JavaScript の中で HTML タグを直接扱うことができ、より直感的に UI の記述ができます。React では、JSX を活用して、UI 部品（コンポーネント）を作り出します。

React コンポーネントが返すべきもの、それが JSX.Element 型です。一般的に、React コンポーネントは JSX を返す関数として定義されます。つまり、その関数が返す値の型が、JSX.Element 型となるのです。

例えば、以下のようなコードがあります。

```tsx
const MyComponent = (): JSX.Element => {
  return <div>Hello, World!</div>
}
```

ここで、MyComponent 関数が返している`<div>Hello, World!</div>`が JSX で、その型が JSX.Element です。

### React コンポーネントと JSX.Element

では、React コンポーネントと JSX.Element の関連を深掘りしていきましょう。React コンポーネントは、関数またはクラスとして定義することができます。それらが描画を行う際には、JSX を使用して DOM ツリーを表現します。

以下に、簡単な関数コンポーネントを見てみましょう。

```tsx
type GreetingProps = {
  name: string
}

const Greeting = ({ name }: GreetingProps): JSX.Element => {
  return <h1>Hello, {name}!</h1>
}
```

ここで定義されている Greeting という関数が、React コンポーネントです。そして、その関数が返している`<h1>Hello, {name}!</h1>`が JSX で、その型が JSX.Element となります。

このコンポーネントを使って、HTML の要素を生成することができます。例えば、以下のように記述します。

```tsx
const element = <Greeting name="Alice" />
```

このように、React コンポーネントは JSX.Element を返す関数として定義されます。

### ReactElement と JSX.Element の違い

実際には、`ReactElement`と`JSX.Element`は React コンポーネントが JSX を返す際に頻繁に使用されます。

React と JSX でのエレメントの扱い方には若干の違いがあります。これらの違いを理解するためには、まず React と JSX が何であるかを簡単に説明しましょう。

React は JavaScript のライブラリで、UI コンポーネントを作成するためのものです。React はエレメント（要素）という考え方を基に機能します。エレメントは React アプリケーションの最小の構成要素で、React アプリケーションを構成するツリーの各ノードを表現します。

JSX は JavaScript XML の略で、React エレメントを直感的に書くための JavaScript のシンタックスエクステンションです。これにより、React エレメントを HTML タグのように書くことができます。

```tsx
const element = <h1>Hello, world!</h1>
```

このように、JSX はコードの中に HTML 風のタグを書けるようにします。これが React のコードを書く際に非常に読みやすく、理解しやすいものにしています。

では、`ReactElement`と`JSX.Element`の違いは何でしょうか。

#### ReactElement

`ReactElement`は React のエレメントを表現するための型です。これは React の API を使用してエレメントを作成する際に使用します。たとえば、以下のようなコードでは`React.createElement`関数を使用してエレメントを作成し、その結果は`ReactElement`型です。

```tsx
const element: React.ReactElement = React.createElement('h1', null, 'Hello, world!')
```

ここで作成された`element`は`ReactElement`型であり、このエレメントを React のレンダリング API に渡すことで画面に表示することができます。

#### JSX.Element

一方で、`JSX.Element`は JSX 式から返されるエレメントを表現するための型です。JSX 式を使用してエレメントを作成すると、その結果は`JSX.Element`型になります。

```tsx
const element: JSX.Element = <h1>Hello, world!</h1>
```

ここで作成された`element`は`JSX.Element`型であり、このエレメントも同様に React のレンダリング API に渡すことで画面に表示することができます。

`ReactElement`と`JSX.Element`はどちらも型であり、コンポーネントが返すべき JSX の形状を記述します。あるコンポーネントが特定の形状の JSX を返すことを期待する場合、そのコンポーネントの返り値の型としてこれらのいずれかを指定することができます。

以下に例を示します。

```tsx
function Hello(): React.ReactElement {
  return <h1>Hello, World!</h1>
}
```

この例では、`Hello`コンポーネントは`ReactElement`を返すことを期待しています。つまり、このコンポーネントは JSX を返すことが期待されており、その形状は`ReactElement`であるべきです。

`JSX.Element`も同様に使用できます。

```tsx
function Hello(): JSX.Element {
  return <h1>Hello, World!</h1>
}
```

ここでも、`Hello`コンポーネントは JSX を返し、その形状は`JSX.Element`であることが期待されています。

したがって、`ReactElement`と`JSX.Element`はどちらもコンポーネントが JSX を返すことを記述するために使われます。これらは基本的に同等であり、使用するかどうかは主に開発者の個人的な選択、またはコードベースの既存の規約に依存します。

#### まとめ

要点をまとめると、`ReactElement`と`JSX.Element`はどちらも React のエレメントを表現するための型であり、どちらも React のレンダリング API に渡すことで画面に表示することができます。しかし、`ReactElement`は React の API を使用してエレメントを作成する際に使用され、`JSX.Element`は JSX 式を使用してエレメントを作成する際に使用されるという違いがあります。

つまり、`ReactElement`と`JSX.Element`の主な違いは、どのような手段でエレメントを作成したか、という点にあります。どちらも同じエレメントを表現するためのものであり、どちらも React のレンダリング API に渡すことが可能ですが、エレメントの作成方法が異なるために異なる型が使用されるのです。

### TypeScript と JSX.Element

TypeScript を使うと、JSX.Element の扱いが少し複雑になりますが、TypeScript は JSX を完全にサポートしています。TypeScript における JSX.Element の型は、React コンポーネントが返すべき要素を表しています。

例えば、次のようなコンポーネントがあるとしましょう。

```tsx
const MyComponent = (): JSX.Element => {
  return <div>Hello, World!</div>
}
```

このコンポーネントは JSX 要素を返しており、その型は JSX.Element です。しかし、このコンポーネントに何かのプロパティを追加したい場合、どうすれば良いでしょう？

ここで登場するのが、TypeScript のジェネリクスです。以下のように書くことで、Props の型を定義することができます。

```tsx
type MyComponentProps = {
  message: string
}

const MyComponent = ({ message }: MyComponentProps): JSX.Element => {
  return <div>{message}</div>
}
```

このように、TypeScript は React の JSX.Element 型を効果的に扱い、開発者がより堅牢なコードを書くのを助けてくれます。

以上が、React JSX.Element の基本と、それが React コンポーネントでどのように利用されるのかの解説でした。この知識を基に、より質の高い React コンポーネントの開発を進めていただければと思います。


React JSX.Elementの基本と、それがReactコンポーネントでどのように利用されるのかを解説します。

Reactの JSX.Element とは何か？


## TL;DR

このページでは、ReactElement の実装方法について詳しく解説しますね。一言で言うと、ReactElement とは React の JSX 要素を表現するための型です。React において、UI を構築する際の基礎的な要素を表現するために使われます。

| 開発環境   | バージョン |
| :--------- | :--------- |
| Next.js    | 13.4.4     |
| TypeScript | 5.0.4      |
| Emotion    | 11.11.0    |
| React      | 18.2.0     |

### ReactElement とは？

ReactElement は React の世界で最も基本的な建設ブロックです。それは単なる JavaScript オブジェクトで、React コンポーネントが画面に何を描画すべきかを記述します。具体的には、ReactElement はコンポーネント（または DOM タグ）の型、それが受け取る props、そして子要素を保持します。

以下に、ReactElement の非常に基本的な使用例を示します。

```tsx
const element: ReactElement = <h1>Hello, world</h1>
```

上記のコードでは、ReactElement のインスタンスである `element` を作成しています。このインスタンスは `<h1>` タグとその子要素であるテキスト 'Hello, world' を表現しています。

### ReactNode, ReactChild, ReactElement の違い

以下に、それぞれの型の主な用途を示す表を作成しました。ReactNode, ReactChild, ReactElement の違いです。

| 型           | 使い所                                                                                                                                                          |
| ------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| ReactNode    | 最も包括的な型で、React がレンダリングできる任意の型をカバーします。主にコンポーネントの戻り値の型や、props として子要素を取る場合に使用します。                |
| ReactChild   | React が子要素として取り扱える要素を表す型です。多くの場合、子要素を表現するために用いられます。                                                                |
| ReactElement | JSX 要素または React コンポーネントを表す型です。主に React の`createElement`関数の戻り値として使用され、React コンポーネントがレンダリングする要素を表します。 |

これらの型は、コード内で要素やコンポーネントを適切に型付けするために用いられます。どの型を使用するべきかは、特定の状況や要件によります。

React の主要な型についての関係図は以下のようになります。

```
ReactNode
  └── ReactChild
      ├── ReactElement
      ├── ReactText (string | number)
      └── boolean | null | undefined
```

これらは、React の様々な値がどのように型付けされるかを説明します。

#### ReactNode

これは React が描画することが可能なもの全てを表す型です。具体的には以下のものが含まれます。

- ReactElement
- ReactFragment
- ReactPortal
- string
- number
- boolean
- null
- undefined

#### ReactChild

これは`ReactNode`の一部を表す型で、React が子要素として扱うことが可能なものを示します。

- ReactElement
- string
- number
- boolean
- null
- undefined

#### ReactElement

これは React のコンポーネント（関数コンポーネントやクラスコンポーネント）または DOM 要素（`div`、`span`、`input`など）から生成されるオブジェクトを表します。この型は主に React の`createElement`関数の戻り値として使われます。

これらの型は React の仮想 DOM で非常に重要な役割を果たし、React の描画システムがどのように動作するかを理解するのに役立ちます。

### Next.js で、ReactElement を実装

では、Next.js と TypeScript を使って ReactElement の具体的な使用例を見てみましょう。以下に、シンプルな Next.js ページコンポーネントを示します。

`pages/index.tsx`

```tsx
import { ReactElement } from 'react'

type Props = {
  message: string
}

const HomePage = ({ message }: Props): ReactElement => {
  return <h1>{message}</h1>
}

export default HomePage
```

上記のコードでは、ReactElement を返す関数コンポーネント `HomePage` を定義しています。`HomePage` コンポーネントは `message` という名前の prop を受け取り、そのメッセージを `<h1>` タグの中に描画します。

コンポーネントが `ReactElement` を返すと明示することで、TypeScript はコンポーネントが正しい JSX を返すことを確認します。もしコンポーネントが JSX 以外のもの（例えば数値や文字列など）を返そうとすると、TypeScript はエラーを出します。

### ReactElement のプロパティ

ReactElement は、その要素に関する情報を保持するプロパティをいくつか持っています。以下に、それらの主要なプロパティについて説明します。

```tsx
import React, { ReactElement } from 'react'

const element: ReactElement = <h1>Hello, world</h1>

console.log(element.type) // => 'h1'
console.log(element.props.children) // => 'Hello, world'
```

`type` プロパティは、要素の型を表します。上記の例では、`element.type` は `'h1'` を返します。また、`props` プロパティは、要素に渡された props を格納します。この例では、`element.props.children` は `'Hello, world'` を返します。

### ReactElement の活用

ReactElement は、コンポーネントのレンダリングをカスタマイズする際に有効に活用できます。例えば、子要素を動的に操作したり、ある条件下で特定の要素を描画したりすることができます。

以下に、ReactElement を活用したコンポーネントの例を示します。

`components/CustomComponent.tsx`

```tsx
import { ReactElement, ReactNode } from 'react'

type Props = {
  children: ReactNode
  condition: boolean
}

const CustomComponent = ({ children, condition }: Props): ReactElement => {
  if (condition) {
    return <div>{children}</div>
  } else {
    return <div>条件に合致しませんでした。</div>
  }
}

export default CustomComponent
```

この `CustomComponent` は、`condition` prop が `true` の場合には子要素を描画し、そうでない場合にはデフォルトのメッセージを描画します。このように、ReactElement を使うことで、要素の描画を動的に制御することができます。


ReactElement の扱い方とその具体的な活用方法を Next.js と TypeScript の視点から深掘りします。

React の ReactElement とは何か？


## TL;DR

このページでは、`ReactNode`の実装方法について解説しますね。一言で言うと`ReactNode`とは、React のコンポーネントのレンダリングに使用できる任意の型を表現するための用語です。

| 開発環境   | バージョン |
| :--------- | :--------- |
| Next.js    | 13.4.4     |
| TypeScript | 5.0.4      |
| Emotion    | 11.11.0    |
| React      | 18.2.0     |

### ReactNode の要点

要点をまとめると以下のようになります。

1. React コンポーネントが子要素（children）として受け入れることができるデータ型を表す
2. 文字列、数値、React コンポーネント、配列、null、undefined など、多岐にわたる型を包括する
3. TypeScript で React コンポーネントを定義する際に、`ReactNode`は子要素の型定義としてよく使われる

したがって、`ReactNode`を用いてコンポーネントの props を定義すると、そのコンポーネントは任意の子要素を受け入れることができます。この柔軟性が React の強力な機能の一つとなっています。

### どのような型を持つことができるか

ReactNode は、React の要素（Element）を表現するための用語で、React のコンポーネントツリーを形成します。ReactNode は次のいずれかの型を持つことができます。

- `boolean`
- `null`
- `undefined`
- `number`
- `string`
- `ReactElement`（React コンポーネント自体）
- `ReactFragment`（複数の子要素をまとめる）
- `ReactPortal`（レンダリングされる DOM を特定の場所に設定する）
- `Array<ReactNode>`（ReactNode の配列）

つまり、ReactNode は非常に柔軟で、文字列や数値といったプリミティブ型から、React コンポーネントまで様々な型を含むことができます。これにより、複雑な UI 構造をツリー形式で表現し、それをブラウザ上でレンダリングすることができます。

```tsx
type Props = {
  children: React.ReactNode
}

const Component = ({ children }: Props) => {
  return <div>{children}</div>
}

const App = () => {
  return (
    <Component>
      <h1>Hello, world!</h1>
    </Component>
  )
}
```

この基本的なソースコードでは、`Component`という新しいコンポーネントを定義しています。ここで`children`というプロパティは、ReactNode の型を持ちます。この`children`は、`<Component>`タグの開始タグと終了タグの間に配置された任意の React ノードを表します。

#### interface で ReactNode を定義する

`interface`を使って`ReactNode`を含む props を定義することも可能です。`ReactNode`は任意の子要素を表す型なので、以下のような形でコンポーネントの props を定義できます。

```tsx
interface MyComponentProps {
  children: React.ReactNode
}

const MyComponent = ({ children }: MyComponentProps) => {
  return <div>{children}</div>
}
```

この例では、`MyComponent`は任意の子要素を受け入れ、それを`div`要素の中でレンダリングします。この子要素は`ReactNode`型として定義されているので、テキスト、他の React コンポーネント、配列など、あらゆる種類の React 要素を受け入れます。

### children として受け入れることができるデータ型

`ReactNode`は React コンポーネントが子要素（children）として受け入れることができるデータ型を表現します。子要素とは、コンポーネントを利用する際にその開始タグと終了タグの間に配置される要素のことです。

```jsx
<Component>{/* ここに配置される要素が子要素（children） */}</Component>
```

React の子要素は非常に柔軟で、単純な文字列や数値から、React コンポーネント自体、配列、null や undefined まで、様々な型を含むことができます。これらすべての可能性を包含する型として`ReactNode`が提供されています。

例えば、以下のような`MyComponent`コンポーネントを考えてみましょう。

```tsx
type Props = {
  children: React.ReactNode
}

const MyComponent = ({ children }: Props) => {
  return <div>{children}</div>
}

const App = () => {
  return (
    <MyComponent>
      <h1>Hello, world!</h1>
      <p>Welcome to my app.</p>
    </MyComponent>
  )
}
```

上記の例では、`MyComponent`は`children`という名前の props を受け入れます。この`children`は`ReactNode`型で、`<MyComponent>`タグの開始タグと終了タグの間にあるすべての内容を含みます。この場合、`<h1>Hello, world!</h1>`と`<p>Welcome to my app.</p>`がその子要素となります。

### ReactChild との違い

`ReactChild`と`ReactNode`は、React の型システムにおける重要な型で、それぞれ異なる種類の React 要素を表現します。

#### ReactChild

`ReactChild`は、React コンポーネントがレンダリングできる要素のうち最も基本的な型を表します。具体的には、`ReactChild`は`ReactElement`または`string`または`number`型を取ります。

つまり、単一の React コンポーネント、文字列、または数値は`ReactChild`として扱うことができます。

#### ReactNode

一方で、`ReactNode`は React がレンダリング可能なすべての種類の値を表します。具体的には、`ReactNode`は以下の値を取ることができます。

- `ReactChild`（すなわち、`ReactElement`、`string`、`number`）
- `boolean`（通常、これは意図的にレンダリングされませんが、条件付きレンダリングの結果として生じることがあります）
- `null`（意図的に何もレンダリングしないことを示す）
- `undefined`（意図的に何もレンダリングしないことを示す）
- `ReactFragment`（複数の子要素をグループ化する）
- `ReactPortal`（コンポーネントツリーの外部にレンダリングする）
- 配列（これは複数の`ReactNode`要素のリストを指す）

したがって、`ReactNode`は`ReactChild`よりも幅広い範囲の要素をカバーします。これは、ある React コンポーネントの`children`props の型としてよく使われます。これは、そのコンポーネントが任意の子要素（文字列、別のコンポーネント、配列、など）を受け入れることができることを示します。

### ReactText

`ReactText`は React の型システムにおける基本的な型で、文字列 (`string`) または数値 (`number`) のどちらかを表します。これは、React がテキストノードとしてレンダリングできる唯二の JavaScript の原始的なデータ型を表しています。

具体的には、次のようなコンポーネントがあります。

```jsx
const MyComponent = () => {
  return (
    <div>
      Hello, world! // これはReactTextです (string)
      {2023} // これもReactTextです (number)
    </div>
  )
}
```

上記の例では、"Hello, world!"と 2023 は、どちらも`ReactText`として扱われます。これらは、どちらもブラウザにレンダリングされた時にはテキストノードとして表示されます。

それに対して、`ReactChild`は`ReactText`と`ReactElement`のどちらかを表し、`ReactNode`は`ReactChild`、`boolean`、`null`、`undefined`、`ReactFragment`、`ReactPortal`、または配列を表します。したがって、これらの型は React の要素や子要素を扱う際の複雑さを表現するために存在します。

とどのつまり、`ReactNode`は最も包括的な型であり、React コンポーネントの子要素として渡すことができるほとんど全てのものをカバーします。つまり、`ReactElement`（これが一般的な JSX 要素です）、文字列、数値、boolean、null、undefined、React フラグメント、React ポータル、そしてこれら全てを含む配列などが含まれます。

したがって、React コンポーネントの子要素として許容したいもの全てを許容する場合には、`ReactNode`を使用すると良いでしょう。ただし、特定の型の子要素のみを許容したい場合（例えば、特定の React コンポーネントのみ、または文字列のみなど）には、より具体的な型を使用することもあります。

### Next.js で、ReactNode を実装

続いて Next.js のコンテクストで、ReactNode を用いた実装例を見ていきましょう。

`/components/MyComponent.tsx`:

```tsx
import React from 'react'

type Props = {
  children: React.ReactNode
}

const MyComponent = ({ children }: Props) => {
  return <div>{children}</div>
}

export default MyComponent
```

上記の`MyComponent.tsx`では、ReactNode を活用したコンポーネントを定義しています。ReactNode 型の`children`プロパティは、`<MyComponent>`タグの開始タグと終了タグの間に配置された任意の React ノードを表現します。

次に、この`MyComponent`を使ってページコンポーネントを作成します。

`/pages/index.tsx`:

```tsx
import MyComponent from '../components/MyComponent'

const HomePage = () => {
  return (
    <MyComponent>
      <h1>Welcome to My Site</h1>
      <p>This is a sample text.</p>
    </MyComponent>
  )
}

export default HomePage
```


この記事ではNext.jsとTypeScriptを用いて、ReactNodeの活用方法について解説します。ReactNodeはReactの基本的な構成要素であり、その理解と活用は、より効率的なReact開発に繋がります。

React の ReactNode とは何か？


## TL;DR

このページでは、コールシグネチャの実装方法について解説しますね。簡潔に述べると、コールシグネチャとは、TypeScript における`type`または`interface`内で関数型を定義するための記法です。

| 開発環境   | バージョン |
| :--------- | :--------- |
| Next.js    | 13.4.4     |
| TypeScript | 5.0.4      |
| Emotion    | 11.11.0    |
| React      | 18.2.0     |

### コールシグネチャとは？

コールシグネチャは、TypeScript において、`type`または`interface`内で関数の型を定義する際に使用する記法の一つです。この考え方を理解することで、より厳密に関数の型を制御できるようになります。

TypeScript のコールシグネチャは、特定のオブジェクトが関数として呼び出せることを表します。これは、そのオブジェクトが特定のパラメータを取り、特定の型の結果を返す関数であることを示しています。

つまり、コールシグネチャはオブジェクトが関数として振る舞うための「契約」を定義します。それは、関数が取るべき引数と、その関数が返すべき結果の型を定義します。

例えば、以下のコードでは、`Greeter` 型は一つの文字列をパラメータとして取り、戻り値として文字列を返す関数として定義されています。

```ts
type Greeter = (message: string) => string
```

この`Greeter`型の変数は、文字列をパラメータとして取り、文字列を返す関数として使うことができます。

```ts
const sayHello: Greeter = (name) => `Hello, ${name}!`
```

これが TypeScript のコールシグネチャの基本的な概念で、オブジェクトが関数のように呼び出せることを示しています。

それでは、基本的なコールシグネチャの定義の仕方から見ていきましょう。

```tsx
type MyFunctionType = (param1: number, param2: string) => boolean
```

このコードは、二つのパラメータ（param1 は数値型、param2 は文字列型）を受け取り、boolean 型を返す関数の型を定義しています。これがコールシグネチャの基本的な形式です。

コールシグネチャはさらに高度な型制約も可能です。たとえば、関数が特定のオブジェクトを引数として受け取る場合、そのオブジェクトの型を以下のように定義できます。

```tsx
type User = {
  name: string
  age: number
}

type GreetFunction = (user: User) => string

const greet: GreetFunction = (user) => `Hello, ${user.name}!`
```

このように、コールシグネチャは、関数のパラメータと戻り値の型を柔軟に制御する手段を提供し、コードの予測可能性と安全性を高めます。

### どのような場面でコールシグネチャを使用するか

TypeScript では、主に`type`や`interface`でコールシグネチャを使用します。しかし、それら以外の場所で直接コールシグネチャを使用することは一般的にはありません。一部の特殊な状況を除いて、コールシグネチャは型エイリアスやインターフェースの定義内でのみ通常見られます。

それらを使用する主な場面は次の通りです。

1. 関数型の定義: TypeScript では、関数の型を明示的に定義できます。コールシグネチャは、関数の引数と戻り値の型を指定するのに使用されます。これにより、関数が期待する引数と戻り値の型をコードに明示的に示すことができます。

2. インターフェースでの関数の定義: TypeScript のインターフェースでは、関数を定義するためにコールシグネチャを使用します。これにより、特定の型のオブジェクトが特定の関数を持つことを保証できます。

それら以外のコンテキストでコールシグネチャを直接使用することは稀であり、一般的には型エイリアスやインターフェース内で定義される関数の型を指定するために使用されます。

### コールシグネチャを使うメリット

コールシグネチャを使うと以下のようなメリットがあります。

1. 型の安全性: TypeScript は静的型チェックを提供します。これにより、開発時に型エラーを検出できます。コールシグネチャを使うと、関数が期待する引数と戻り値の型を明示的に宣言することができます。これにより、関数が正しく使用されていることを保証し、型エラーによるバグを予防することができます。

2. 自己文書化: コールシグネチャはコードに含まれるドキュメンテーションの一部と見なすこともできます。関数がどのような引数を取り、何を返すかを示すことで、コードを理解しやすくすることができます。

3. コードの再利用: コールシグネチャを持つインターフェースを定義すると、そのインターフェースに従って複数の関数を作成することができます。これにより、コードの再利用と整合性を保つことが容易になります。

4. 拡張性: コールシグネチャを用いたインターフェースを定義しておけば、後からそのインターフェースを実装したクラスを作成することも可能です。これにより、コードの構造を柔軟に拡張することが可能になります。

以上のような理由から、特に大規模なプロジェクトや複数人での開発においては、コールシグネチャを活用することが有益です。

### オブジェクトでコールシグネチャを定義する

オブジェクトでコールシグネチャを使うと、そのオブジェクトが関数のように呼び出されることを期待する型定義を行うことができます。これは特に、関数の振る舞いを持つオブジェクトを表現する場合や、関数をプロパティとして持つオブジェクトを定義する場合に有用です。

例えば、次のようなオブジェクト型を定義することができます。

```tsx
type GreetingObject = {
  (name: string): string
}
```

ここでは、`GreetingObject` というオブジェクト型を作り、それが関数の形を持つことを定義しています。つまり、このオブジェクトは、引数に文字列を一つ取り、文字列を返す関数として呼び出せるべきであることを示しています。

また、オブジェクト型の中に関数を含むプロパティを持たせることも可能です。これを行うには、各プロパティに対するコールシグネチャを提供します。

```tsx
type Greeter = {
  sayHello: (name: string) => string
  sayGoodbye: (name: string) => string
}
```

ここでは `Greeter` というオブジェクト型は `sayHello` と `sayGoodbye` という 2 つのメソッドを持つことを定義しています。これらのメソッドはどちらも引数に文字列を一つ取り、文字列を返す関数であるべきです。

したがって、オブジェクトでコールシグネチャを使用すると、そのオブジェクトが関数として振る舞うか、または関数を含むプロパティを持つことを定義できます。

### interface でコールシグネチャを定義する

TypeScript の `interface` を用いたコールシグネチャの一例を以下に示します。

```tsx
interface Greeter {
  (message: string): void
}

const greet: Greeter = (message) => {
  console.log(message)
}

greet('Hello, world!') // Hello, world!
```

この例では、`Greeter` という名前のインターフェースを定義し、そのインターフェースには、一つのコールシグネチャが含まれています。そのコールシグネチャは、一つの文字列型の引数を取り、何も返さない（`void`）関数を示しています。

次に、この `Greeter` 型を `greet` という変数の型として使用しています。この `greet` 関数は、インターフェースで定義した通り、一つの文字列型の引数を取り、何も返さない関数として定義されています。

最後に `greet` 関数を呼び出しています。その引数には文字列 "Hello, world!" を渡しています。これにより、コンソールに "Hello, world!" というメッセージが表示されます。

このように、TypeScript のインターフェースとコールシグネチャを組み合わせることで、特定のシグネチャを持つ関数を定義することができます。

### 関数に型をつけるのと、コールシグネチャはどう違うのか？

関数に直接型をつける方法と、コールシグネチャを使用する方法は、一見似ていますが、その使い方と柔軟性に違いがあります。

まず、関数に直接型をつける方法について見てみましょう。

```tsx
function greet(name: string): string {
  return `Hello, ${name}!`
}
```

ここでは、`greet`関数は引数`name`を受け取り、文字列を返すと型定義されています。これは一つの具体的な関数の型を示しています。

一方、コールシグネチャを使用すると、特定の形状の関数すべてを表現することができます。つまり、特定のパラメータを取り、特定の型を返すような関数全般をカバーする型を作成することができます。以下に例を示します。

```tsx
type GreetingFunc = (name: string) => string
```

ここでは、`GreetingFunc`はコールシグネチャを用いて定義されており、任意の関数がこの形状を持つならば、その関数は`GreetingFunc`の型とみなされます。

したがって、以下の 2 つの関数はどちらも`GreetingFunc`型として扱うことができます。

```tsx
const greetEnglish: GreetingFunc = (name) => `Hello, ${name}!`
const greetJapanese: GreetingFunc = (name) => `こんにちは、${name}さん！`
```

このように、コールシグネチャを使用することで、特定の関数形状を持つ全ての関数を表現できる一方、関数に直接型をつける方法は一つの具体的な関数の型を示すのが特徴です。

### Next.js で、コールシグネチャを実装

それでは、Next.js と TypeScript を使って、実際のコンポーネントでコールシグネチャをどのように使うかを見ていきましょう。

#### `/components/UserGreeting.tsx`

```tsx
import React from 'react'

type User = {
  name: string
  age: number
}

type UserGreetingProps = {
  user: User
  greetFunction: (user: User) => string
}

const UserGreeting = ({ user, greetFunction }: UserGreetingProps): JSX.Element => {
  return (
    <div>
      <h2>{greetFunction(user)}</h2>
    </div>
  )
}

export default UserGreeting
```

この`UserGreeting`コンポーネントでは、`greetFunction`という名前の関数をプロップとして受け取ります。この関数の型はコールシグネチャによって定義され、`User`オブジェクトを受け取り、文字列を返すと指定されています。

このように、コールシグネチャを用いることで、関数をプロップとして受け取る際に、その関数がどのような引数と戻り値を持つべきかを厳密に定義できます。

次に、この`UserGreeting`コンポーネントを使用するページコンポーネントを作成しましょう。

#### `/pages/index.tsx`

```tsx
import UserGreeting from '../components/UserGreeting'

const user = {
  name: 'Taro',
  age: 20,
}

const greetFunction = (user) => `Hello, ${user.name}! Welcome to our site!`

const HomePage = () => {
  return (
    <div>
      <UserGreeting user={user} greetFunction={greetFunction} />
    </div>
  )
}

export default HomePage
```

この`HomePage`コンポーネントでは、`UserGreeting`コンポーネントを呼び出し、その必要なプロップを渡しています。`greetFunction`として渡される関数は、`User`オブジェクトを引数に取り、挨拶文を作成して返します。

このように、コールシグネチャを使うことで、関数が持つべきパラメータと戻り値の型を明確に制御でき、コードの安全性と可読性を向上させることができます。

### オプショナルなパラメータ

コールシグネチャでは、関数のパラメータがオプショナル（必須でない）であることを示すこともできます。そのための記法は、パラメータ名の後に`?`を付けます。これは、そのパラメータが省略可能であることを示します。

```tsx
type GreetWithOptionalName = (name?: string) => string

const greet: GreetWithOptionalName = (name = 'Guest') => `Hello, ${name}!`
```


Next.js と TypeScript でコールシグネチャを使う方法について詳しく解説します。コードの例とともに、どのようにそれらが機能し、なぜそのように書かれているのかを理解します。

Next.js と TypeScript で、コールシグネチャを理解する


## TL;DR

このページでは、TypeScript の "型エイリアス（type alias）" の実装方法について解説しますね。一言でいうと、型エイリアスとは、既存の型に`type` キーワードを使用して新しい名前を付け、同じ型を複数回利用させる機能のことです。

| 開発環境   | バージョン |
| :--------- | :--------- |
| Next.js    | 13.4.4     |
| TypeScript | 5.0.4      |
| Emotion    | 11.11.0    |
| React      | 18.2.0     |

### 型エイリアスとは？

型エイリアス（Type Alias）は、TypeScript の重要な特性の一つです。これを理解し、上手く使うことで、コードの可読性や再利用性を向上させ、エラーの可能性を低減することができます。

型エイリアスを理解するための一つの基本的な考え方は、「既存の型に新しい名前を付ける」というものです。それを使うことで、コード全体を通じて型を一貫して使用することができます。

```tsx
type Name = string

let name: Name

name = 'John Doe' // これは正しい
name = 123 // これはエラー
```

上記のコードでは、"Name"という新しい型エイリアスを定義しています。そして、それを使って"name"という変数を宣言しています。この"name"変数は"Name"という型を持っているため、"string"型の値を受け入れます。だから、name 変数に文字列を代入するときはエラーにならないのです。しかし、number 型の値を代入しようとすると、TypeScript はエラーを出します。

### プリミティブ型

プリミティブ型に対する型エイリアスです。文字列や数値、真偽値などの基本的なデータ型に対して新しい名前を定義します。

```tsx
type ID = string
type Age = number
type IsAdult = boolean

let id: ID = '1234'
let age: Age = 25
let isAdult: IsAdult = true
```

ここで定義した `ID`, `Age`, `IsAdult` はそれぞれ `string`, `number`, `boolean` の別名として扱われます。

### ユニオン型

ユニオン型は複数の型のいずれかを表すことができます。ユニオン型の型エイリアスを定義することで、特定の範囲の値のみを許容する型を作ることができます。

```tsx
type Animal = 'Dog' | 'Cat' | 'Bird'

let pet: Animal

pet = 'Dog' // これは正しい
pet = 'Fish' // これはエラー
```

この例では `Animal` という型エイリアスは `'Dog'`, `'Cat'`, `'Bird'` のいずれかの文字列しか許容しません。

### インターセクション型

インターセクション型は複数の型を組み合わせた新しい型を作ることができます。既存の型エイリアスを組み合わせて新しい型エイリアスを作ることができます。

```tsx
type User = {
  name: string
  age: number
}

type Worker = {
  company: string
}

type UserWorker = User & Worker

let userWorker: UserWorker = {
  name: 'John Doe',
  age: 25,
  company: 'Tech Corp',
} // これは正しい
```

ここでは `User` と `Worker` という 2 つの型エイリアスを組み合わせて `UserWorker` という新しい型エイリアスを作成しています。

### タプル

タプルは固定数の要素と各要素の型が指定された配列の型を定義することができます。タプルを表すための型エイリアスを定義することができます。

```tsx
type Point = [number, number]

let p: Point = [10, 20] // これは正しい
```

ここで定義した `Point` は 2 つの数値からなる配列を表します。

### 関数型（アロー関数）

関数型の型エイリアスでは、特定の形式の関数を定義することができます。パラメータと戻り値の型を指定します。

```tsx
type Greeting = (name: string) => string

const hello: Greeting = (name) => `Hello, ${name}`

console.log(hello('World')) // Hello, World
```

この例では、`Greeting` という型エイリアスは `string` を引数に取り `string` を返す関数を表します。

### ジェネリクス

ジェネリクスは特定の型に依存せずに再利用可能なコードを作るための機能です。型エイリアスでジェネリクスを定義することも可能です。

```tsx
type Container<T> = { value: T }

let numberContainer: Container<number> = { value: 1 }
let stringContainer: Container<string> = { value: 'Hello World' }
```

この例では `Container<T>` というジェネリクス型の型エイリアスを作成しています。`T` は任意の型を表すプレースホルダーで、具体的な型は使用する際に指定します。

### アロー関数とジェネリック型の組み合わせ

アロー関数とジェネリック型を組み合わせて利用することで、より汎用性の高いコードを書くことができます。

```tsx
// ファイル名: components/Identity.tsx

type IdentityFunction<T> = (arg: T) => T

const identity: IdentityFunction<number> = (arg) => {
  return arg
}

// 使用例
const result = identity(123)
console.log(result) // 123
```

このコードでは、`IdentityFunction`という型エイリアスを定義しています。その中でジェネリック型`<T>`を使って、引数と戻り値の型が同一であるような関数を表現しています。この`T`は、関数を実際に使用する際に具体的な型（この場合は`number`）に置き換わります。

このようなジェネリック型を使うことで、多様な型に対応する関数を一つの型定義で表現することができます。この例では`number`型に対する`IdentityFunction`を定義していますが、`string`型や自作の型など、様々な型に対して同じ関数を適用できます。

### ネストした型エイリアス

複雑なデータ構造を表現するために、型エイリアスをネストして使用することもあります。

```tsx
type User = {
  id: string
  profile: {
    name: string
    age: number
  }
}

let user: User = {
  id: '1234',
  profile: {
    name: 'John Doe',
    age: 25,
  },
}
```

この例では `User` という型エイリアス内部に `profile` という別のオブジェクトの型を定義しています。

### Next.js で、型エイリアスを実装

基本的な型エイリアスの使い方を理解したところで、それを具体的な Next.js プロジェクトでの使用例を見ていきましょう。この部分では、「UserCard」というコンポーネントとその呼び出し方法を示します。

先ずは、`components/UserCard.tsx` ファイルを作成します。

```tsx
// components/UserCard.tsx

import React from 'react'

type User = {
  name: string
  age: number
  address: string
}

const UserCard = ({ name, age, address }: User) => {
  return (
    <div>
      <h2>{name}</h2>
      <p>{age}歳</p>
      <p>{address}</p>
    </div>
  )
}

export default UserCard
```

上記のコードでは、まず最初に"User"という型エイリアスを定義しています。この"User"型は、"name"、"age"、"address"というプロパティを持つオブジェクトを表しています。それぞれのプロパティは、"string"、"number"、"string"という型を持っています。

次に、"UserCard"という React コンポーネントを定義しています。このコンポーネントは、User 型のプロパティを引数として受け取ります。そして、それらのプロパティを使用して、ユーザーの情報を表示します。

```tsx
// pages/index.tsx

import UserCard from '../components/UserCard'

const Home = () => {
  return (
    <div>
      <UserCard name="John Doe" age={30} address="Tokyo, Japan" />
    </div>
  )
}

export default Home
```

上記のコードでは、UserCard コンポーネントを呼び出しています。それぞれのプロパティに適切な値を渡しています。これにより、Next.js アプリケーションでユーザーの情報を表示することができます。

### 型エイリアスの拡張

型エイリアスは、より複雑な型を作成するためにも使用することができます。たとえば、既存の型エイリアスを合成して、新たな型エイリアスを作成することができます。

以下の例では、「AdminUser」型エイリアスを作成します。これは既存の「User」型エイリアスを拡張し、新たなプロパティ「role」を追加します。

```tsx
// components/AdminUserCard.tsx

import React from 'react'

type User = {
  name: string
  age: number
  address: string
}

type AdminUser = User & {
  role: string
}

const AdminUserCard = ({ name, age, address, role }: AdminUser) => {
  return (
    <div>
      <h2>{name}</h2>
      <p>{age}歳</p>
      <p>{address}</p>
      <p>Role: {role}</p>
    </div>
  )
}

export default AdminUserCard
```


Next.js と TypeScript を使って型エイリアス（type alias）を活用する方法を丁寧に解説します。初学者でも理解できるように各ソースコードの意味を詳しく解説しています。

Next.js と TypeScript で学ぶ、型エイリアス（type alias）の様々なパターン


## TL;DR

このページでは、TypeScript の interface の実装方法について解説しますね。一言でいうと interface とは、型を定義するための仕組みです。

| 開発環境   | バージョン |
| :--------- | :--------- |
| Next.js    | 13.4.4     |
| TypeScript | 5.0.4      |
| Emotion    | 11.11.0    |
| React      | 18.2.0     |

### TypeScript の interface とは？

TypeScript の interface は、型の一種です。プロパティやメソッドの名前と型を組み合わせて新しい型を定義するための仕組みです。これにより、オブジェクトの形状を規定し、エディターやコンパイラーがエラーを検出するための情報を提供します。

では、以下に基本的な interface の使い方について見ていきましょう。

```tsx
interface Person {
  name: string
  age: number
}

const p: Person = {
  name: 'John Doe',
  age: 30,
}
```

このコードでは、`Person`という interface を定義しています。この interface は`name`と`age`というプロパティを持つオブジェクトの型を規定します。この`Person`型の変数`p`を定義し、その値として`name`が"John Doe"、`age`が 30 のオブジェクトを指定しています。

### Optional プロパティを持つ Interface

TypeScript では Interface 内のプロパティを任意にすることができます。プロパティ名の後ろに`?`を付けることで、そのプロパティは存在してもしなくても良いことを示します。これは主にオプションのプロパティを持つオブジェクトに有用です。

```tsx
interface User {
  id: string
  name: string
  age?: number // Optional property
}
```

### Read-Only プロパティを持つ Interface

TypeScript の Interface は、プロパティを読み取り専用にすることもできます。これはプロパティの値が一度設定された後に変更されることを防ぐためです。読み取り専用のプロパティを定義するためには、プロパティ名の前に`readonly`修飾子を付けます。

```tsx
interface Config {
  readonly id: string
  name: string
}
```

### 関数型を持つ Interface

TypeScript の Interface は、関数の型も定義することができます。これは主に特定の形状の関数を期待する関数やメソッドの引数に対して使用されます。

```tsx
interface Greeter {
  (name: string, age: number): string
}

const greet: Greeter = (name, age) => {
  return `Hello, ${name}. You are ${age} years old.`
}
```

### Indexable Types を持つ Interface

TypeScript の Interface は、インデックス可能な型も定義することができます。これは主に、一部または全部が動的に設定されるオブジェクトに対して使用されます。

```tsx
interface StringArray {
  [index: number]: string
}

const myArray: StringArray = ['Bob', 'Fred']
```

### クラスと Interface

TypeScript の Interface は、クラスが特定の契約を満たすことを強制するためにも使用できます。Interface を実装するには、クラス定義の後に`implements`キーワードと Interface の名前を追加します。

```tsx
interface ClockInterface {
  currentTime: Date
  setTime(d: Date): void
}

class Clock implements ClockInterface {
  currentTime: Date = new Date()
  setTime(d: Date) {
    this.currentTime = d
  }
}
```

### ハイブリッド型を持つ Interface

Interface は混合型（またはハイブリッド型）を記述することもできます。これは、オブジェクトが関数であると同時にプロパティを持つことができる JavaScript の特性を反映したものです。

```tsx
interface Counter {
  (start: number): string
  interval: number
  reset(): void
}

function getCounter(): Counter {
  let counter = function (start: number) {} as Counter
  counter.interval = 123
  counter.reset = function () {}
  return counter
}

let c = getCounter()
c(10)
c.reset()
c.interval = 5.0
```

### Interface の拡張

Interface は他の Interface を拡張することができます。これにより、複数の Interface が同じ基本プロパティを共有している場合に、コードの重複を避けることができます。

```tsx
interface Shape {
  color: string
}

interface Square extends Shape {
  sideLength: number
}

let square = {} as Square
square.color = 'blue'
square.sideLength = 10
```

### Interface と型別名の相互適用

Interface と型別名（type aliases）は組み合わせて使用することができます。これにより、より複雑な型の記述が可能となります。

```tsx
type Point = {
  x: number
  y: number
}

interface Circle {
  center: Point
  radius: number
}

let myCircle: Circle = {
  center: { x: 0, y: 0 },
  radius: 5,
}
```

### Interface の合成

Interface は複数の Interface を 1 つに合成することも可能です。この機能はクラスが複数の Interface を実装できるようにすることで特に有用です。

```tsx
interface Animal {
  breathe(): void
}

interface Mammal {
  feedMilk(): void
}

interface Human extends Animal, Mammal {
  speak(): void
}

class Person implements Human {
  breathe() {
    console.log('Breathing...')
  }

  feedMilk() {
    console.log('Feeding milk...')
  }

  speak() {
    console.log('Speaking...')
  }
}
```

### インターフェイスを使用したオブジェクトの配列

TypeScript では、`interface`を使用してカスタム型を定義することができます。これは、オブジェクトが特定の形状（つまり、特定のプロパティとその型）を持つことを保証するための強力な方法です。これを配列と組み合わせて使用すると、オブジェクトの配列を効果的に型付けすることができます。

以下の例では、`User`というインターフェイスを定義し、その配列を`users`という名前の変数で宣言しています。

```tsx
interface User {
  id: number
  name: string
}

const users: User[] = [
  { id: 1, name: 'Alice' },
  { id: 2, name: 'Bob' },
  // more users...
]
```

### インターフェイスで配列を含むオブジェクトの定義

インターフェイスを使用して、配列をプロパティとして持つオブジェクトを定義することも可能です。以下の例では、`Company`というインターフェイスに`employees`というプロパティを持たせ、その型を`User[]`と定義しています。

```tsx
interface User {
  id: number
  name: string
}

interface Company {
  name: string
  employees: User[]
}

const company: Company = {
  name: 'OpenAI',
  employees: [
    { id: 1, name: 'Alice' },
    { id: 2, name: 'Bob' },
    // more employees...
  ],
}
```

### Next.js で、TypeScript の interface を実装

では、次に Next.js のプロジェクトで TypeScript の interface をどのように使うかについて見ていきましょう。

まずは、Next.js のページコンポーネントを作成します。以下のコードは`pages/index.tsx`というファイルで定義します。

```tsx
import type { NextPage } from 'next'
import { UserProfile } from '../components/UserProfile'

type User = {
  name: string
  age: number
}

const HomePage: NextPage = () => {
  const user: User = {
    name: 'John Doe',
    age: 30,
  }

  return <UserProfile user={user} />
}

export default HomePage
```

このコードでは、まず`User`という interface を定義しています。これは先程と同じように、ユーザーを表すオブジェクトの型を規定します。次に`HomePage`というページコンポーネントを定義し、その中で`user`という`User`型の変数を定義し、値としてユーザーの情報を持つオブジェクトを指定しています。そして、この`user`を`UserProfile`というコンポーネントに渡しています。

### コンポーネントのプロパティの型定義

先程作成した`UserProfile`コンポーネントの中身を見てみましょう。以下のコードは`components/UserProfile.tsx`というファイルで定義します。

```tsx
type User = {
  name: string
  age: number
}

type Props = {
  user: User
}

const UserProfile = ({ user }: Props) => {
  return (
    <div>
      <p>Name: {user.name}</p>
      <p>Age: {user.age}</p>
    </div>
  )
}

export { UserProfile }
```

ここでもまた`User`という interface を定義していますが、このコンポーネントが受け取るプロパティの型として、更に`Props`という interface を定義しています。この`Props`は`user`というプロパティを持つことを規定し、その型は先程定義した`User`となります。そして、この`Props`型を引数の型として指定し、`UserProfile`コンポーネントを定義しています。このコンポーネントでは、受け取った`user`の情報を表示します。

### コンポーネント間のデータの型定義

次に、異なるコンポーネント間でデータを渡す際の型定義の例を見てみましょう。以下のコードは`components/UserList.tsx`というファイルで定義します。

```tsx
import { UserProfile } from './UserProfile'

type User = {
  id: number
  name: string
  age: number
}

type Props = {
  users: User[]
}

const UserList = ({ users }: Props) => {
  return (
    <div>
      {users.map((user) => (
        <UserProfile key={user.id} user={user} />
      ))}
    </div>
  )
}

export { UserList }
```

このコードでは、複数のユーザー情報を持つ配列を受け取り、その各ユーザーについて`UserProfile`コンポーネントを表示します。これにより、複数のユーザー情報を一覧として表示することができます。

#### users: User[] はどういう意味？

`User[]`は User 型の配列を表します。つまり、`users`は User 型のオブジェクトが複数含まれる配列を指しています。

まず、最初の`type User`の部分では、`User`という新たな型を定義しています。この`User`型は、`id`（数値）、`name`（文字列）、`age`（数値）というプロパティを持つオブジェクトです。

次に、`type Props`の部分では、`Props`という新たな型を定義しています。この`Props`型は、`User[]`型の`users`というプロパティを持つオブジェクトです。`User[]`は「User 型の配列」という意味になります。つまり、`users`プロパティは User 型のオブジェクトが複数含まれる配列を表すことになります。

以下のようなデータ構造を想像するとわかりやすいかもしれません。

```typescript
let someProps: Props = {
  users: [
    { id: 1, name: 'Alice', age: 20 },
    { id: 2, name: 'Bob', age: 25 },
    { id: 3, name: 'Charlie', age: 30 },
    // more users...
  ],
}
```

上記の例では、`someProps`は`Props`型であり、その`users`プロパティは 3 つの`User`型のオブジェクトを含む配列です。


Next.js と TypeScript を組み合わせて、TypeScript の interface の考え方とその効率的な実装方法について解説します。

Next.js と TypeScript で学ぶ、interface の様々なパターン


## TL;DR

このページでは、一般的な 型定義ではなく、Next.js(Pages Router 版) 専用の型定義の具体的な使い方について解説しますね。Pages Router 版で開発をされている方対象です。

| 開発環境              | バージョン |
| :-------------------- | :--------- |
| Next.js(Pages Router) | 13.4.4     |
| TypeScript            | 5.0.4      |
| Emotion               | 11.11.0    |
| React                 | 18.2.0     |

### Next.js の「型定義」

型定義は TypeScript の重要な機能の一つで、変数や関数の引数、戻り値の型を明示することでコードの安全性を高め、開発者が意図しないデータの操作を防ぎます。また、型を明示することで、エディタの自動補完機能が向上し、開発効率が向上します。

Next.js では様々な型定義が提供されており、それぞれが Next.js の異なる機能に対応しています。これらの型定義を適切に使うことで、Next.js の機能をより効果的に活用することができます。

例えば、Next.js のページコンポーネントの型定義 `NextPage` は以下のように使用します。

```tsx
import type { NextPage } from 'next'

type Props = {
  message: string
}

const HomePage: NextPage<Props> = ({ message }) => {
  return <div>{message}</div>
}

export default HomePage
```

ここで、`NextPage` は Next.js のページコンポーネントを表す型で、Props の型を引数に取ることができます。この `HomePage` コンポーネントは `message` という名前の prop を受け取り、その prop を表示します。

### NextPage

`NextPage` は Next.js のページコンポーネントの型定義です。Props として受け取るデータの型を指定することができます。

```tsx
import type { NextPage } from 'next'

type Props = {
  title: string
}

const HomePage: NextPage<Props> = ({ title }) => {
  return <h1>{title}</h1>
}

export default HomePage
```

このコードでは、`HomePage` コンポーネントが `title` という名前の prop を受け取り、その prop を見出しとして表示します。

### GetStaticPaths

`GetStaticPaths` は静的生成のためのパスを定義する関数の型です。静的生成が必要なパスのリストを返します。

```tsx
import type { GetStaticPaths } from 'next'

export const getStaticPaths: GetStaticPaths = async () => {
  return {
    paths: [{ params: { id: '1' } }, { params: { id: '2' } }],
    fallback: false,
  }
}
```

このコードでは、`getStaticPaths` 関数が `1` と `2` の id を持つパスのリストを返します。返されたパスは静的生成の対象となります。

### GetStaticProps

`GetStaticProps` は静的生成のための props を生成する関数の型です。生成したいページごとに必要な props を返します。

```tsx
import type { GetStaticProps } from 'next'

type Props = {
  data: string
}

export const getStaticProps: GetStaticProps<Props> = async () => {
  const data = 'Hello, Next.js!'
  return { props: { data } }
}
```

このコードでは、`getStaticProps` 関数が `data` を含む props を返します。返された props は静的生成されるページのコンポーネントに渡されます。

### GetStaticPropsContext

`GetStaticPropsContext`は Next.js の型で、静的生成のためのデータ取得関数`getStaticProps`に渡されるパラメータを表現します。この型は、ページのパスパラメータ、プレビューモードの情報、ロケールの情報などを含むオブジェクトを定義します。

```tsx
import { GetStaticProps, GetStaticPropsContext } from 'next'

export const getStaticProps: GetStaticProps = async (context: GetStaticPropsContext) => {
  const id = context.params?.id

  // データ取得処理...

  return {
    props: {
      // ページコンポーネントに渡すプロパティ...
    },
  }
}
```

このコードは、`getStaticProps`関数を定義しています。この関数は、ページのパスパラメータから`id`を取得し、それを使用してデータを取得します。取得したデータは、ページコンポーネントのプロパティとして渡されます。

### GetServerSideProps

`GetServerSideProps` はサーバサイドレンダリングのための props を生成する関数の型です。生成するページごとに必要な props を返します。

```tsx
import type { GetServerSideProps } from 'next'

type Props = {
  data: string
}

export const getServerSideProps: GetServerSideProps<Props> = async () => {
  const data = 'Hello, server side rendering!'
  return { props: { data } }
}
```

このコードでは、`getServerSideProps` 関数が `data` を含む props を返します。返された props はサーバサイドレンダリングされるページのコンポーネントに渡されます。

### NextRequest

`NextRequest`は Next.js の Edge Runtime で使用される型で、クライアントからの HTTP リクエストを表現します。この型は、リクエストの URL、メソッド、ヘッダー、クッキーなどの情報を含むオブジェクトを定義します。

```typescript
import type { NextRequest } from 'next/server'

export const config = {
  runtime: 'edge',
}

export default async function handler(req: NextRequest) {
  const { searchParams } = new URL(req.url)
  const email = searchParams.get('email')
  return new Response(email)
}
```

このコードは、クライアントからのリクエストの URL から email パラメータを取得し、その値をレスポンスとして返す Edge API ルートを定義しています。

### NextResponse

`NextResponse`は Next.js のサーバーコンポーネントで、HTTP レスポンスを表現するためのクラスです。このクラスは、レスポンスのステータスコード、ヘッダー、ボディなどの情報を含むオブジェクトを定義します。

デプロイ時に、Edge 関数を特定のリージョンに制限したい場合があります。これにより、データソースの近くに配置することでレスポンス時間を短縮することが可能になります。以下のように設定することでこれを実現できます。

注：この設定は Next.js のバージョン 12.3.2 以降で利用可能です。

```typescript
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

export const config = {
  regions: ['sfo1', 'iad1'], // デフォルトは 'all'
}

export default async function handler(req: NextRequest) {
  const myData = await getNearbyData()
  return NextResponse.json(myData)
}
```

このコードでは、`config`オブジェクトをエクスポートして、Edge 関数のデプロイ先のリージョンを指定しています。ここでは、`sfo1`（サンフランシスコ）と`iad1`（ノーザンバージニア）の 2 つのリージョンを指定しています。デフォルトでは、すべてのリージョン（`all`）が対象となります。

### NextApiRequest

`NextApiRequest`は API ルートのリクエストオブジェクトの型です。これは、Node.js の HTTP IncomingMessage オブジェクトを拡張したものになります。クエリパラメーターやリクエストボディ、ヘッダーなどを取得する際に使用します。

```tsx
import type { NextApiRequest, NextApiResponse } from 'next'

export default function handler(req: NextApiRequest, res: NextApiResponse) {
  console.log(req.body) // access request body
  console.log(req.query) // access query parameters
  res.status(200).json({ message: 'Hello Next.js!' })
}
```

### NextApiResponse

`NextApiResponse`は API ルートのレスポンスオブジェクトの型です。これは、Node.js の HTTP ServerResponse オブジェクトを拡張したもので、レスポンスを送る際に使用します。

```tsx
import type { NextApiRequest, NextApiResponse } from 'next'

export default function handler(req: NextApiRequest, res: NextApiResponse) {
  res.status(200).json({ message: 'Hello Next.js!' }) // sending response
}
```

### InferGetStaticPropsType

`InferGetStaticPropsType`は`getStaticProps`関数の戻り値型を推論するためのユーティリティ型です。これを使用すると、props の型を明示的に記述せずに済みます。

```tsx
import type { InferGetStaticPropsType } from 'next'

type Post = {
  author: string
  content: string
}

export const getStaticProps = async () => {
  const posts: Post[] = await getDataFromCMS() // fetch posts
  return { props: { posts } }
}

const Blog = ({ posts }: InferGetStaticPropsType<typeof getStaticProps>) => {
  /* render posts */
}

export default Blog
```

### InferGetServerSidePropsType

`InferGetServerSidePropsType`は`getServerSideProps`関数の戻り値型を推論するためのユーティリティ型です。`InferGetStaticPropsType`と同様に、props の型を明示的に記述せずに済みます。

```tsx
import type { InferGetServerSidePropsType } from 'next'

type User = {
  name: string
  email: string
}

export const getServerSideProps = async () => {
  const users: User[] = await getUsersFromDB() // fetch users
  return { props: { users } }
}

const UsersPage = ({ users }: InferGetServerSidePropsType<typeof getServerSideProps>) => {
  /* render users */
}

export default UsersPage
```

### NextApiHandler

`NextApiHandler`は API ルートのハンドラ関数の型です。リクエストとレスポンスの型を引数に取ります。

```tsx
import type { NextApiHandler } from 'next'

const handler: NextApiHandler = (req, res) => {
  res.status(200).json({ message: 'Hello Next.js!' })
}

export default handler
```

### NextComponentType

`NextComponentType`は Next.js のページコンポーネントの型を表します。この型は、`NextPageContext`、`AppInitialProps`、そして任意のページが受け取る props の型を引数に取ります。

```tsx
import type { NextComponentType } from 'next'
import type { NextPageContext } from 'next'
import type { AppInitialProps } from 'next/app'

type PageProps = {
  custom: string
}

const Page: NextComponentType<NextPageContext, AppInitialProps, PageProps> = ({ custom }) => {
  return <div>{custom}</div>
}

export default Page
```

### AppProps

`AppProps`は Next.js のカスタム `_app` コンポーネントの props の型です。これはページの初期 props と、現在のページコンポーネントとその URL に関する情報を提供します。

```tsx
import type { AppProps } from 'next/app'

function MyApp({ Component, pageProps }: AppProps) {
  return <Component {...pageProps} />
}

export default MyApp
```

### AppContext

`AppContext`はカスタム `_app` コンポーネントのコンテキストオブジェクトの型です。これは `getInitialProps` 関数内で利用可能で、現在のページの情報などを提供します。

```tsx
import type { AppContext } from 'next/app'

MyApp.getInitialProps = async (appContext: AppContext) => {
  const appProps = await App.getInitialProps(appContext)

  return { ...appProps }
}
```

### AppInitialProps

`AppInitialProps`は `_app` コンポーネントの初期 props の型です。

```tsx
import type { AppInitialProps } from 'next/app'

MyApp.getInitialProps = async (appContext): Promise<AppInitialProps> => {
  return { pageProps: {} }
}
```

これらの型定義を理解し、適切に使用することで、Next.js の開発をより安全かつ効率的に行うことができます。


Next.js の各種型定義とその具体的な使い方を理解しましょう。本記事では React と Next.js のソースコードとともに、型定義の深層を解き明かします。

Next.js専用の型定義まとめ


## TL;DR

このページでは、タプル型の実装方法について詳しく解説しますね。一言でいうと、タプル型とは異なるデータ型をまとめて管理できる配列のようなものです。

| 開発環境   | バージョン |
| :--------- | :--------- |
| Next.js    | 13.4.4     |
| TypeScript | 5.0.4      |
| Emotion    | 11.11.0    |
| React      | 18.2.0     |

### 「タプル型」とは？

タプル型とは、TypeScript で提供されている特殊な配列の型の一つで、異なる型の要素を一つの配列で管理することができます。通常の配列では、全ての要素が同じ型である必要がありますが、タプルではその限りではありません。これにより、配列の特定の位置に特定の型の値を持つことを保証することができます。

タプル型の基本的な定義方法は以下の通りです。

```tsx
// タプル型の定義
let tuple: [string, number]
tuple = ['hello', 10] // OK
tuple = [10, 'hello'] // Error: 型が一致しないため
```

上記の例では、`tuple`という名前のタプルを定義し、それが`string`と`number`という二つの異なる型の要素を持つことを示しています。このとき、要素の順序も重要です。つまり、最初の要素は`string`型でなければならず、次の要素は`number`型でなければならないということです。逆に並べると型の不一致エラーが発生します。

タプル型は数値、文字列、オブジェクトなど、異なる型の要素を組み合わせた配列を定義するのに役立ちます。さらに、Next.js と TypeScript を組み合わせると、これらの強力な機能を Web 開発に活用することができます。タプル型の他の使い方をいくつか見てみましょう。

### 要素のアクセスと代入

タプルは配列と同じようにアクセスできます。そして、一度定義されたタプルの型を満たす限り、再代入も可能です。

```tsx
let tuple: [string, number]
tuple = ['hello', 10] // OK
console.log(tuple[0]) // 出力: "hello"
console.log(tuple[1]) // 出力: 10

tuple[0] = 'world' // OK
console.log(tuple[0]) // 出力: "world"

tuple[1] = 'foo' // Error: 'foo' の型 'string' は 'number' 型に代入できない
```

### タプルの長さ

タプルの長さは、その定義によって固定されます。

```tsx
let tuple: [string, number]
tuple = ['hello', 10] // OK

console.log(tuple.length) // 出力: 2

tuple = ['hello', 10, 20] // Error: 'string | number' 型の要素が必要ですが、'number' 型の要素が得られました
```

### 異なる型の要素

タプルは、要素ごとに異なる型を持つことができます。

```tsx
let tuple: [string, number, boolean]
tuple = ['hello', 10, true] // OK

console.log(tuple[0]) // 出力: "hello"
console.log(tuple[1]) // 出力: 10
console.log(tuple[2]) // 出力: true
```

### タプル内で配列を使用する

タプルは異なる型の要素を持つことができるため、配列も要素として持つことができます。

```tsx
let tuple: [string, number, string[]]
tuple = ['hello', 10, ['a', 'b', 'c']] // OK

console.log(tuple[0]) // 出力: "hello"
console.log(tuple[1]) // 出力: 10
console.log(tuple[2]) // 出力: ["a", "b", "c"]
```

### タプルの分割代入

タプルは分割代入を利用することもできます。これにより、コードを読みやすくできます。

```tsx
let tuple: [string, number] = ['hello', 10]
let [text, number] = tuple // text = 'hello', number = 10
```

### 結果とエラーのハンドリング

関数が成功したときと失敗したときの結果を返すときにタプル型を使うことがあります。これは特に、非同期処理でよく見られます。以下の例は、Next.js の API ルートで使用できる、エラーハンドリングのためのヘルパー関数です。

```tsx
// /utils/apiHelpers.ts
import { NextApiRequest, NextApiResponse } from 'next'

type Handler = (req: NextApiRequest, res: NextApiResponse) => Promise<void>

export const withErrorHandling = (handler: Handler): Handler => {
  return async (req, res) => {
    try {
      await handler(req, res)
    } catch (error) {
      console.error(error)
      res.status(500).json({ message: 'An unexpected error occurred.' })
    }
  }
}
```

この関数は、API ルートのハンドラを引数として受け取り、エラーをキャッチして 500 エラーレスポンスを送信する新しいハンドラを返します。これにより、API ルートの各ハンドラでエラー処理を個々に行う必要がなくなります。

### 複数の返り値

複数の値を返す関数は、一般的にはオブジェクトを返します。しかし、タプル型を使用すると、返り値の順序を保証することができます。例えば、次のような関数を考えてみてください。

```tsx
// utils.ts
export function divide(a: number, b: number): [number, number] {
  if (b === 0) {
    throw new Error('Cannot divide by zero.')
  }
  const quotient = Math.floor(a / b)
  const remainder = a % b
  return [quotient, remainder]
}
```

この関数は商と余りを返すので、返り値は `number` の 2 つの要素を持つタプル型として定義されます。

### 複数の異なる型

一つのタプル内で複数の異なる型を持つことができます。これは配列ではできないことで、タプルが特に役立つケースです。以下に例を示します。

```tsx
// /components/DisplayUserInfo.tsx
type User = [string, number, Date]

export const DisplayUserInfo = ({ user }: { user: User }) => {
  const [name, age, registrationDate] = user
  return (
    <div>
      <p>{`Name: ${name}`}</p>
      <p>{`Age: ${age}`}</p>
      <p>{`Registered since: ${registrationDate.toISOString()}`}</p>
    </div>
  )
}
```

上記の例では、ユーザー情報を保持する `User` 型をタプル型で定義しています。`User` 型は、文字列の名前、数値の年齢、そして Date オブジェクトの登録日を順番に持つタプル型です。

### Next.js で、タプル型を実装

#### components/TupleDisplay.tsx

```tsx
import { CSSProperties } from 'react'

type TupleDisplayProps = {
  data: [string, number, CSSProperties]
}

const TupleDisplay = ({ data }: TupleDisplayProps) => {
  const [text, number, style] = data

  return (
    <div style={style}>
      <h1>{text}</h1>
      <h2>{number}</h2>
    </div>
  )
}

export default TupleDisplay
```

ここでは`TupleDisplay`という React コンポーネントを作成しています。このコンポーネントは、プロパティとしてタプル型の`data`を受け取ります。この`data`は`string`、`number`、`CSSProperties`の三つの異なる型の要素を持つタプルです。

コンポーネント内部で、配列の分割代入を用いて`data`から各要素を取り出しています。そして、取り出した`text`と`number`を表示し、`style`を div 要素のスタイルとして適用しています。

#### pages/index.tsx

```tsx
import TupleDisplay from '../components/TupleDisplay'

const Home = () => {
  const tupleData: [string, number, React.CSSProperties] = ['Hello Tuple', 12345, { color: 'red' }]

  return <TupleDisplay data={tupleData} />
}

export default Home
```

次に、この`TupleDisplay`コンポーネントを`Home`コンポーネントから呼び出しています。`tupleData`というタプルを定義し、その要素を`'Hello Tuple'`、`12345`、`{ color: 'red' }`としています。この`tupleData`を`TupleDisplay`コンポーネントの`data`プロパティとして渡しています。

これにより、`TupleDisplay`コンポーネントは受け取ったタプルの各要素をそれぞれ適切に扱い、表示することができます。

### タプル型の応用例

タプル型は上記のような単純なケースだけでなく、より複雑なケースでも活用することができます。例えば、異なる型の値のペアを多数管理する場合などに便利です。

```tsx
type Pair = [string, number]

let pairs: Pair[] = []

pairs.push(['one', 1])
pairs.push(['two', 2])

pairs.forEach(([text, number]) => {
  console.log(`${text}: ${number}`)
})
```

このコードでは、まず`Pair`というタプル型を定義し、その配列`pairs`を作成しています。そして、配列に対して`push`メソッドを使ってペアを追加し、その後`forEach`メソッドを使って各ペアを出力しています。

このように、タプル型を活用することで、異なる型の要素を組み合わせて管理することが容易になります。

### まとめ

以上のように、タプル型は TypeScript で提供されている便利な機能の一つです。異なる型の値をまとめて扱うことができるので、様々なケースで活用できます。Next.js と組み合わせることで、より複雑なデータ構造の管理にも役立ちます。


Next.js と TypeScript を活用した、タプル型の使用方法とその具体的な活用例について解説します。

2023-07-19

ヘッドレスCMSとは（学習コスト・種類・歴史・実装）

2023-07-17

React の dangerouslySetInnerHTML とは何か？

2023-07-14

Reactの JSX.Element とは何か？

2023-07-14

React の ReactElement とは何か？

2023-07-14

React の ReactNode とは何か？

2023-07-12

Next.js と TypeScript で、コールシグネチャを理解する

2023-07-11

Next.js と TypeScript で学ぶ、型エイリアス（type alias）の様々なパターン

2023-07-11

Next.js と TypeScript で学ぶ、interface の様々なパターン

2023-07-10

Next.js専用の型定義まとめ

2023-07-10

Next.js と TypeScript で、タプル型を学ぶ