
## TL;DR

ユーザーフレンドリーなインターフェースを持つウェブサイトには、タブ切り替えコンポーネントが欠かせません。この記事では、Next.js と TypeScript を使用して独自のタブ切り替えコンポーネントを作成する方法について解説します。

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

### タブ切り替えコンポーネントの実装

まず、具体的なコードを見てみましょう。

```tsx
// components/Tabs.tsx

import { useState } from 'react'
import { css } from '@emotion/react'

type TabProps = {
  tabs: string[]
}

const Tabs = ({ tabs }: TabProps) => {
  const [activeTab, setActiveTab] = useState(tabs[0])

  return (
    <div>
      {tabs.map((tab) => (
        <button
          key={tab}
          onClick={() => setActiveTab(tab)}
          css={css`
            background-color: ${tab === activeTab ? 'blue' : 'white'};
            color: ${tab === activeTab ? 'white' : 'black'};
          `}
        >
          {tab}
        </button>
      ))}
      <div>{activeTab} content</div>
    </div>
  )
}

export default Tabs
```

このコードは、タブのリストを受け取り、各タブをクリックするとアクティブなタブが変更され、その内容が表示されるコンポーネントを定義します。

呼び出し

タブ切り替えコンポーネントを任意のページから利用するためには、以下のようにコンポーネントをインポートし、タブのリストを `tabs` プロパティとして渡します。

```tsx
// pages/index.tsx

import Tabs from '../components/Tabs'

const HomePage = () => {
  return (
    <div>
      <h1>Home Page</h1>
      <Tabs tabs={['Tab1', 'Tab2', 'Tab3']} />
    </div>
  )
}

export default HomePage
```

このように `Tabs` コンポーネントをページに配置し、`tabs` プロパティにタブの名前を配列で渡すだけで、タブ切り替え機能が手に入ります。かなりスッキリと実装できるのが、コンポーネントベースの設計の良いところですよね。

### コード解説

それでは、上記のコードを詳しく見ていきましょう。

まず、`useState` フックを使用して `activeTab` の状態を管理します。初期値は `tabs` 配列の最初の要素とします。

次に、 `tabs` 配列をマップして、各タブに対応するボタンを作成します。ボタンがクリックされると `setActiveTab` が呼び出され、 `activeTab` の値がそのタブに設定されます。

そして、Emotion を用いてボタンの背景色と文字色を設定します。アクティブなタブは背景色が青で文字色が白になり、非アクティブなタブは背景色が白で文字色が黒になります。

最後に、アクティブなタブの内容を表示します。ここではシンプルにタブの名前と "content" を表示していますが、実際のアプリケーションでは、ここにタブに関連するコンポーネントやデータを表示することになります。

### タブ切り替えコンポーネントを学ぶ

さらに深く学びたい方のために、ドキュメントを紹介します。

| タイトル（リンク）                                                  | 説明                            |
| ------------------------------------------------------------------- | ------------------------------- |
| [React 公式ドキュメント](https://reactjs.org/docs/hooks-state.html) | useState フックの詳しい説明     |
| [Next.js 公式ドキュメント](https://nextjs.org/docs)                 | Next.js の詳細なドキュメント    |
| [TypeScript 公式ドキュメント](https://www.typescriptlang.org/docs/) | TypeScript の詳細なドキュメント |
| [Emotion 公式ドキュメント](https://emotion.sh/docs/introduction)    | Emotion の詳細なドキュメント    |

以上、Next.js と TypeScript を使用してタブ切り替えコンポーネントを作成する方法について解説しました。これを使って UI を一段と良くしてみてくださいね。


Next.jsとTypeScriptを用いたタブ切り替えコンポーネントの作成方法について詳しく解説します。

Next.js と TypeScript で、タブ切り替えコンポーネントを作る


## TL;DR

今回は、Next.js と TypeScript を使用してパンくずリストのコンポーネントを作成する手法を詳しく解説します。

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

### パンくずリストのコンポーネントをつくる

初めに、パンくずリストを表示するためのコンポーネントを作成します。以下にそのソースコードを示します。

```tsx
import Link from 'next/link'
import { useRouter } from 'next/router'

type BreadcrumbItem = {
  text: string
  href?: string
}

type BreadcrumbProps = {
  items: BreadcrumbItem[]
}

const Breadcrumb: React.FC<BreadcrumbProps> = ({ items }) => {
  const router = useRouter()

  return (
    <nav aria-label="Breadcrumb">
      <ol>
        {items.map((item, index) => {
          const isCurrent = index === items.length - 1

          if (isCurrent || !item.href) {
            return <li key={index}>{item.text}</li>
          }

          return (
            <li key={index}>
              <Link href={item.href}>
                <a>{item.text}</a>
              </Link>
            </li>
          )
        })}
      </ol>
    </nav>
  )
}

export default Breadcrumb
```

このコンポーネントでは、パンくずリストを生成するために必要な各アイテムが、`BreadcrumbItem` 型の配列として `items` プロパティで渡されます。そして、配列の各アイテムは、表示するテキストとリンク先の URL（必要な場合）を含むオブジェクトになります。

それぞれのアイテムがパンくずリストの最後のアイテムかどうかを判定するために、`isCurrent` を使用しています。これにより、現在のアイテム（最後のアイテム）にリンクを表示しないようにしています。これは一般的なパンくずリストの挙動と合致

します。

### パンくずリストの利用

上記のコンポーネントを用いて、具体的にどのようにパンくずリストを実装できるかを見てみましょう。以下は、その一例です。

```tsx
import Breadcrumb from './Breadcrumb'

const MyPage = () => {
  const breadcrumbItems = [{ text: 'Home', href: '/' }, { text: 'Blog', href: '/blog' }, { text: 'My Article' }]

  return (
    <div>
      <Breadcrumb items={breadcrumbItems} />
      <h1>My Article</h1>
      <p>This is my article.</p>
    </div>
  )
}

export default MyPage
```

`MyPage` コンポーネント内で、`Breadcrumb` コンポーネントを呼び出しています。パンくずリストの各アイテムは `breadcrumbItems` 配列に定義されており、その配列を `Breadcrumb` コンポーネントの `items` プロパティに渡しています。

### パンくずリストを学ぶ

ここまで読んで、「もっと詳しく学びたい！」という方は、以下のリンクを参考にしてみてください。

| リンク                                                                                     | 説明                                                                   |
| ------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------- |
| [Breadcrumb Navigation UX](https://www.nngroup.com/articles/breadcrumb-navigation-useful/) | パンくずリストのユーザーエクスペリエンスについて解説している記事です。 |
| [A Complete Guide to Breadcrumbs](https://css-tricks.com/a-complete-guide-to-breadcrumbs/) | パンくずリストの作成とその使用方法についての詳細なガイドです。         |
| [Breadcrumb in Next.js](https://flaviocopes.com/nextjs-breadcrumb/)                        | Next.js でのパンくずリストの作成について具体的に解説している記事です。 |


この記事では、Next.js と TypeScript を用いて、パンくずリストのコンポーネントを作成する手法を解説します。

Next.js と TypeScript で、パンくずリストを実装する方法


## TL;DR

本記事では Next.js と TypeScript を使って Google Analytics のコンポーネントを作り、ウェブサイトに統合する方法を詳しく説明します。

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

### Google Analytics のコンポーネント作成

まず初めに、Google Analytics のコンポーネントを作成しましょう。具体的には、Google Analytics と通信するためのカスタムフックを作成します。これは、アプリケーションのライフサイクルに応じて Google Analytics へのイベントを送信するために使用されます。

```tsx
// components/GoogleAnalytics.tsx
import { useRouter } from 'next/router'
import { useEffect } from 'react'

const GA_MEASUREMENT_ID = process.env.NEXT_PUBLIC_GA_MEASUREMENT_ID

declare global {
  interface Window {
    gtag: (...args: any[]) => void
  }
}

const GoogleAnalytics = () => {
  const router = useRouter()

  useEffect(() => {
    const handleRouteChange = (url: string) => {
      if (typeof window.gtag === 'function') {
        window.gtag('config', GA_MEASUREMENT_ID, {
          page_path: url,
        })
      }
    }

    router.events.on('routeChangeComplete', handleRouteChange)

    return () => {
      router.events.off('routeChangeComplete', handleRouteChange)
    }
  }, [router.events])

  return null
}

export default GoogleAnalytics
```

こちらのソースコードを解説します。

このコードは、Next.js アプリケーションで Google Analytics(GA4) を利用するためのコンポーネントです。特に、SPA（シングルページアプリケーション）におけるページビューのトラッキングに対応しています。

```tsx
const GA_MEASUREMENT_ID = process.env.NEXT_PUBLIC_GA_MEASUREMENT_ID
```

上記のコードで、環境変数から Google Analytics(GA4) の計測 ID（`GA_MEASUREMENT_ID`）を取得しています。Next.js では、`NEXT_PUBLIC_` で始まる環境変数はブラウザに公開されるため、このようにしてブラウザ側のスクリプトで利用することが可能です。

```tsx
declare global {
  interface Window {
    gtag: (...args: any[]) => void
  }
}
```

Google Analytics(GA4) は、`gtag.js` というグローバルな関数を介して操作します。しかし、この `gtag` 関数はデフォルトの TypeScript の型定義には存在しないため、ここではグローバルな `Window` インターフェースを拡張して `gtag` 関数の型定義を追加しています。

```tsx
const GoogleAnalytics = () => {
  const router = useRouter()

  useEffect(() => {
    const handleRouteChange = (url: string) => {
      if (typeof window.gtag === 'function') {
        window.gtag('config', GA_MEASUREMENT_ID, {
          page_path: url,
        })
      }
    }

    router.events.on('routeChangeComplete', handleRouteChange)

    return () => {
      router.events.off('routeChangeComplete', handleRouteChange)
    }
  }, [router.events])

  return null
}
```

ここが本ソースコードの中心部分です。`useEffect` という React のフックを使って、ルート（ページ）が変わる度に `handleRouteChange` 関数を呼び出します。`handleRouteChange` 関数は `gtag` 関数を用いて Google Analytics(GA4) に新しいページビュー情報を送信します。

Next.js の `useRouter` フックを使って取得した `router` オブジェクトの `events` メソッドを通じて、ルートの変更イベント（具体的には `routeChangeComplete` イベント）を購読しています。

`return` の部分では、このコンポーネントがアンマウントされるとき（つまり、このコンポーネントがページから削除されるとき）に、イベントの購読を解除する関数を返しています。これは React のフックのクリーンアップ関数として機能します。

そして最後に、`GoogleAnalytics` コンポーネントが何も描画しないことを明示するために、`return null` を記述しています。

### .env.local ファイルの作成

`.env.local` に、Google Analytics(GA4) の計測 ID（G-xxxxx） する場合は次のように記述しますが、本番では反映されません。

```bash
# google analytics
NEXT_PUBLIC_GA_MEASUREMENT_ID=ここに GA4 の ID を入力
```

※ だだし、これはローカル用なのでアップロードされません。Vercel にデプロイした後は、Vercel の管理画面から上述した環境変数を設定する必要があります。「=」は含めないでください。

### コンポーネントでの利用

`_document.tsx` で、次のように設定します。

```tsx
import { Html, Head, Main, NextScript } from 'next/document'

export default function Document(this: any) {
  const GA_MEASUREMENT_ID = process.env.NEXT_PUBLIC_GA_MEASUREMENT_ID
  return (
    <Html lang="ja">
      <Head>
        {/* Google Analytics 本番環境のみ動作する。ローカル環境で確認したいときは、{process~  をコメントアウトして確認する */}
        {process.env.NODE_ENV === 'production' && (
          <>
            <script async src={`https://www.googletagmanager.com/gtag/js?id=${GA_MEASUREMENT_ID}`} />
            <script
              dangerouslySetInnerHTML={{
                __html: `
                    window.dataLayer = window.dataLayer || [];
                    function gtag(){dataLayer.push(arguments);}
                    gtag('js', new Date());
                    gtag('config', '${GA_MEASUREMENT_ID}');
                  `,
              }}
            />
          </>
        )}
      </Head>
      <body>
        <Main />
        <NextScript />
      </body>
    </Html>
  )
}
```

あとは `_app.tsx` に作成したカスタムフックを任意のコンポーネントで使用します。

```tsx
import GoogleAnalytics from 'components/GoogleAnalytics'

export default function App({ Component, pageProps }: AppProps) {
  return (
    <Layout>
      <GoogleAnalytics />
      <Component {...pageProps} />
    </Layout>
  )
}
```

以上で Google Analytics のコンポーネント作成は完了しました。

### Google シグナルを有効にする

Google Analytics の Universal Analytics（UA）から Google Analytics 4（GA4）への移行に伴い、Google シグナルのデータ収集を有効にする必要があります。

#### GA4 プロパティの作成

Google Analytics の管理画面に行き、アカウントを選択します。その後、「プロパティ」を選択し、「プロパティの作成」をクリックします。新しい GA4 プロパティを作成します。詳細な設定を選択し、プロパティを作成します。

#### データストリームの設定

GA4 プロパティを作成したら、データストリームを設定します。これは、ウェブサイトやアプリからのデータを収集するためのものです。データストリームを作成し、ウェブサイトの URL やアプリの情報を入力します。

#### トラッキングコードの設定

作成した GA4 プロパティのデータストリームから、新しい GA4 トラッキングコードを取得します。これをウェブサイトの適切な部分に追加します。これにより、新しい GA4 プロパティがデータを収集することができます。

#### UA と GA4 の並行運用

移行期間中は、UA のトラッキングコードを削除せずにそのままにします。これにより、UA と GA4 の両方からデータを収集することができ、比較・検証を行うことができます。

#### イベントと目標の設定

GA4 では、イベントとしてデータを収集し、それを基にレポートを作成します。thanks ページなど、必要に応じて、UA で設定していた目標に相当するイベントを GA4 で設定します。

#### レポートの作成

GA4 では、データの視覚化と分析のためにレポートを作成します。UA で利用していたレポートに相当するものを GA4 で作成します。

これで Next.js の各ページで Google Analytics の情報を収集できるようになりました。

### Google Analytics を学ぶ

ここまで読んで、「もっと詳しく学びたい！」という方は、以下のリンクを参考にしてみてください。

| タイトル                                                                                                              | 説明                                                                                          |
| --------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| [Google Analytics 4 認定試験の全問題を解説！](https://www.webanalytics.jp/work/ga4-questions/)                        | Google Analytics 4 の試験問題とその解答を解説しています。                                     |
| [Google アナリティクス公式ガイド](https://support.google.com/analytics/answer/9304153)                                | Google 自身が提供する公式ガイドです。基本的な使い方から高度な機能まで詳しく説明されています。 |
| [Next.js with Google Analytics Example](https://github.com/vercel/next.js/tree/canary/examples/with-google-analytics) | Next.js 公式の Google Analytics 例です。ソースコードとともに説明がついています。              |

ここまでで、Google Analytics のコンポーネントを Next.js と TypeScript を使って作成する方法を学びました。お疲れ様でした！


Next.js と TypeScript を使用して Google Analytics のコンポーネントを作成し、ウェブサイトに統合する方法を解説します。

Next.js と TypeScript で、Google Analytics(GA4) を導入する


## TL;DR

ユーザーがウェブサイトを共有したときに、その見た目と意味を制御するために、OGP はウェブサイトに欠かせない要素となっています。この記事では、OGP の設定方法を、Next.js と TypeScript を使用して詳しく見ていきましょう。

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

### OGP の説明

OGP（Open Graph Protocol）は、ウェブページがソーシャルメディアプラットフォーム上でどのように表現されるかを定義するためのプロトコルです。これにより、ページのタイトル、説明、イメージ等を適切に設定し、ユーザーがウェブサイトを共有したときの見た目を制御することができます。

OGP は、Facebook がソーシャルメディア上でのコンテンツの表示を制御するために開発したものです。そして今では、Facebook だけでなく、多くのソーシャルメディアプラットフォームや検索エンジンがこれを利用しています。

OGP の設定に関して最新の情報を得るためには、公式 OGP ウェブサイト [https://ogp.me/](https://ogp.me/) をチェックすることをおすすめします。また、Google の構造化データテストツール [https://search.google.com/structured-data/testing-tool](https://search.google.com/structured-data/testing-tool) を使うと、ウェブページの OGP タグが適切に設定されているかを確認することができます。

### OGP の設定方法

では、実際に TypeScript を使って OGP を設定してみましょう。次は簡単な例です。components/Meta.tsx を作成し、次のように記述します。Pages Router を使うバージョンです。

```tsx
// components/Meta.tsx
import React from 'react'
import Head from 'next/head'

interface MetaProps {
  title?: string
  description?: string
  ogImage?: string
  ogUrl?: string
  siteName?: string
  favicon?: string
  twitterCard?: string
  twitterSite?: string
  appleTouchIcons?: { size: string; href: string }[]
  canonicalUrl?: string
  lang?: string
  isHomePage?: boolean
}

const Meta = ({
  title = 'タイトル',
  description = '説明',
  ogImage = '/images/default-og-image.png',
  ogUrl = 'https://xxxx',
  siteName = 'サイトの名前',
  favicon = '/favicon.ico',
  twitterCard = 'summary',
  twitterSite = '@your-default-twitter-handle',
  appleTouchIcons = [
    { size: '32x32', href: '/images/default-apple-touch-icon-32x32.png' },
    { size: '64x64', href: '/images/default-apple-touch-icon-64x64.png' },
    { size: '180x180', href: '/images/default-apple-touch-icon-180x180.png' },
  ],
  canonicalUrl = 'https://xxxx',
  lang = 'ja_JP',
  isHomePage = false,
}: MetaProps) => {
  const pageTitle = isHomePage ? siteName : `${title} - ${siteName}` // 修正

  return (
    <Head>
      <title>{pageTitle}</title>
      <meta name="description" content={description} />
      <meta property="og:type" content="article" />
      <meta property="og:title" content={pageTitle} />
      <meta property="og:description" content={description} />
      <meta property="og:url" content={ogUrl} />
      <meta property="og:image" content={ogImage} />
      <meta property="og:site_name" content={siteName} />
      <meta property="og:locale" content={lang} />

      <meta name="twitter:card" content={twitterCard} />
      <meta name="twitter:site" content={twitterSite} />
      <meta name="twitter:image" content={ogImage} />

      <link rel="shortcut icon" href={favicon} />

      {appleTouchIcons.map(({ size, href }) => (
        <link key={size} rel="apple-touch-icon" sizes={size} href={href} />
      ))}

      <link rel="canonical" href={canonicalUrl} />
      <link rel="icon" href={favicon} />
    </Head>
  )
}

export default Meta
```

トップページ以外では次のように設定します。

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

export default function Home() {
  return (
    <>
      <Meta title="BLOG" description="BLOG ページです。" ogImage="" ogUrl="" canonicalUrl="https://xxxx" />
      {/* 他のページコンテンツ */}
    </>
  )
}
```

トップページのコンポーネントで Meta コンポーネントを呼び出す場合は、isHomePage を true に設定しているかどうかを確認してください。

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

export default function Home() {
  return (
    <>
      <Meta isHomePage={true} />
      {/* 他のページコンテンツ */}
    </>
  )
}
```

このように、Meta コンポーネントを使用する各ページで、isHomePage prop を適切に設定することが重要です。それにより、Meta コンポーネント内の条件分岐が適切に機能し、ページタイトルが期待通りに設定されます。


OGP (Open Graph Protocol) の設定方法を Next.js と TypeScript を使って解説します。この記事は、ウェブサイトの見た目と共有可能性を強化したい開発者に向けたものです。

Next.js と TypeScript で、OGP のセットアップを設定する


## TL;DR

Next.js と TypeScript を使った RSS の設定方法について解説しますね。非常に簡単に設定できます。

RSS（Really Simple Syndication）は、ウェブサイトの更新情報を一覧で知ることができるデータ形式の一つです。これを利用すると、ユーザーは RSS リーダーにウェブサイトの RSS フィードを登録することで、新規記事や更新記事の情報を一元的に取得できます。ユーザーエンゲージメントを高め、定期的な訪問者を増やすためのツールとして大変有用です。

Next.js で RSS を作成するには、サーバーサイドで動作する API エンドポイントを作成してそこから RSS を提供するのが一般的な方法です。次のような URL で RSS フィードを取得できます。

```bash
http://localhost:3000/api/feed
```

それでは、必要なライブラリをインストールします。

### rss インストール

RSS フィードを生成するためには`rss`という名前のパッケージを使うことができます。以下のコマンドでインストールできます。

```bash
npm install rss
```

### 通常の設定

`pages/api`ディレクトリ内に新しいファイルを作成します。例えば、`rss.ts`という名前にすることができます。

このファイル内で`rss`ライブラリを使用して RSS フィードを生成します。一般的には、次のようなコードになります。

Next/プロジェクト名/src/pages/api/feed.ts

```tsx
import { NextApiRequest, NextApiResponse } from 'next'
import RSS from 'rss'

const fetchYourData = async () => {
  return [
    {
      title: 'Example title 1',
      description: 'Example description 1',
      slug: 'example-slug-1',
      author: 'Example author 1',
      date: new Date(),
    },
    // More items...
  ]
}

const handler = async (_: NextApiRequest, res: NextApiResponse) => {
  const feed = new RSS({
    title: 'Your Website Title',
    description: 'Your Website Description',
    feed_url: 'https://yourwebsite.com/api/rss',
    site_url: 'https://yourwebsite.com',
    image_url: 'https://yourwebsite.com/icon.png',
    managingEditor: 'Your Name',
    webMaster: 'Your Name',
    copyright: 'Your Copyright Notice',
    language: 'ja',
    pubDate: new Date().toString(),
    ttl: 60,
  })

  const data = await fetchYourData()

  data.forEach((item: { title: string; description: string; slug: string; author: string; date: Date }) => {
    feed.item({
      title: item.title,
      description: item.description,
      url: `https://yourwebsite.com/${item.slug}`,
      author: item.author,
      date: item.date,
    })
  })

  res.setHeader('Content-Type', 'application/rss+xml')
  res.write(feed.xml())
  res.end()
}

export default handler
```

このスクリプトは API エンドポイントとして動作し、データソースから記事をフェッチしてそれを RSS フィードに追加しています。`fetchYourData`関数はダミーデータの例であり、ここを自分のデータソースからデータを取得するように書き換えてください。

最後に、RSS XML をレスポンスとして返します。このエンドポイントは`https://yourwebsite.com/api/rss`でアクセスできます。RSS リーダーはこの URL から RSS フィードを取得することができます。

注意点としては、サイトのタイトル、説明、URL、記事データなどを正しく設定することが重要です。また、フィード生成に時間がかかる場合は、キャッシュを使用することを検討してください。

### ローカルで開発する場合

ローカルで開発中でも RSS フィードを確認することは可能です。Next.js の API ルーティングはローカル開発サーバでも動作します。

1. まず、`npm run dev`などを使用して Next.js のローカル開発サーバを起動します。
2. 次に、ブラウザを開き、作成した API エンドポイントの URL を指定します。例えば、API エンドポイントを`pages/api/rss.ts`に作成した場合、その URL は`http://localhost:3000/api/rss`となります（3000 は Next.js のデフォルトのポートです。別のポートを設定した場合はそのポートを使用してください）。
3. この URL にアクセスすると、作成した RSS フィードが表示されます。RSS フィードは XML 形式で表示されます。

RSS フィードをパースして人間が読みやすい形式で表示するためには、専用の RSS リーダーを使用することを推奨します。多くのブラウザは XML を構造化して表示しますが、RSS リーダーはフィードの各エントリーに対応する情報を適切に表示します。

### Markdown からの設定

マークダウンファイルからのデータをフィードに反映させるには、まずそれらのマークダウンファイルを解析してデータを取得する必要があります。gray-matter というライブラリを使うことで、マークダウンファイルからメタデータ（フロントマター）と本文を抽出することができます。

それに加え、Next.js では getStaticProps という関数を使って、ビルド時に静的データを取得することができます。この関数の中でマークダウンファイルからデータを取得し、それをフィードに反映させることができます。

マークダウンが格納されている場所を、data/blog だとすると、次のような設定になります。ローカルでの例です。

```tsx
import fs from 'fs'
import path from 'path'
import matter from 'gray-matter'
import { NextApiRequest, NextApiResponse } from 'next'
import RSS from 'rss'

const POSTS_DIRECTORY = path.join(process.cwd(), 'data/blog')

const getAllPosts = () => {
  // Get file names under /posts
  const fileNames = fs.readdirSync(POSTS_DIRECTORY)
  const allPostsData = fileNames.map((fileName) => {
    // Remove ".md" from file name to get id
    const id = fileName.replace(/\.md$/, '')

    // Read markdown file as string
    const fullPath = path.join(POSTS_DIRECTORY, fileName)
    const fileContents = fs.readFileSync(fullPath, 'utf8')

    // Use gray-matter to parse the post metadata section
    const matterResult = matter(fileContents)

    // Combine the data with the id
    return {
      id,
      ...(matterResult.data as { date: string; title: string }),
    }
  })
  return allPostsData.sort((a, b) => {
    if (a.date < b.date) {
      return 1
    } else {
      return -1
    }
  })
}

const handler = async (_: NextApiRequest, res: NextApiResponse) => {
  const feed = new RSS({
    title: 'Your Website Title',
    description: 'Your Website Description',
    feed_url: 'http://localhost:3000/feed',
    site_url: 'http://localhost:3000',
    image_url: 'http://localhost:3000/icon.png',
    managingEditor: 'Your Name',
    webMaster: 'Your Name',
    copyright: 'Your Copyright Notice',
    language: 'ja',
    pubDate: new Date().toString(),
    ttl: 60,
  })

  const data = getAllPosts()

  data.forEach((item: { date: string; title: string; id: string }) => {
    feed.item({
      title: item.title,
      description: '', // descriptionがないので、空文字列を渡します。
      url: `http://localhost:3000/blog/${item.id}`, // slugはidと同じと仮定しています。
      author: '', // authorがないので、空文字列を渡します。
      date: new Date(item.date), // dateをDateオブジェクトに変換します。
    })
  })

  res.setHeader('Content-Type', 'application/rss+xml; charset=utf-8')
  res.write(feed.xml())
  res.end()
}

export default handler
```


Next.js と TypeScript を使って、自分だけの RSS を設定する方法を解説します。

Next.js と TypeScript で、RSS を出力する


## TL;DR

最近のフロントエンドでは、CSS や SCSS を使わずに、CSS-in-JS や Tailwind CSS などの CSS フレームワークを使った開発が主流になってきています。Tailwind CSS は、CSS を効率的に管理できるユーティリティファーストのフレームワークです。特に、マージンやパディングなどのスペーシングの設定が素早く行えます。

Tailwind CSS は効率的に CSS を管理できるユーティリティファーストのフレームワークです。特に、マージンやパディングなどのスペーシングの設定が素早く行えます。

しかし、Tailwind のデフォルトのスペーシングスケールでは対応しきれない場面も出てきます。そんな時はどうすればいいのでしょうか。そこで、今回は Tailwind CSS でカスタムマージンを設定する方法を解説します。

Tailwind CSS では、`tailwind.config.js`という設定ファイルを利用してカスタムマージンを設定できます。それでは早速、設定方法について詳しく見てみましょう。

### @tailwindcss/typography のインストール

ターミナルで以下のコマンドを実行して、`@tailwindcss/typography` をインストールしてください。

```bash
npm install @tailwindcss/typography
```

### .eslintrc.js の設定

.eslintrc.js の設定を行います。

```js
{
  "extends": ["next", "next/core-web-vitals", "prettier", "plugin:prettier/recommended"]
}
```

### tailwind.config.ts の設定

次に、Tailwind の設定ファイル`tailwind.config.js`を開きます。次に、`theme`プロパティの中に`extend`プロパティを追加します。その中に`spacing`プロパティを追加し、そこでカスタムマージンを定義します。

例えば、`margin-top: 80px;` を定義したい場合は、`mt-80`というクラス名を指定できるようにします。

```tsx
/** @type {import('tailwindcss').Config} */
module.exports = {
  content: [
    "./src/pages/**/*.{js,ts,jsx,tsx}",
    "./components/**/*.{js,ts,jsx,tsx}",
    "./src/styles/*.sass",
  ],
  theme: {
    screens: {
      sm: { max: "767px" }, // 768px 以下の画面幅に適用
      // ... 他のブレークポイントも定義できます。
    },
    extend: {
      // margin 関係すべてを px で指定する
      spacing: {
        10: "10px",
        20: "20px",
        30: "30px",
        40: "40px",
        50: "50px",
        60: "60px",
        70: "70px",
        80: "80px",
        90: "90px",
        100: "100px",
        110: "110px",
        120: "120px",
        130: "130px",
        140: "140px",
        150: "150px",
        160: "160px",
        170: "170px",
        180: "180px",
        190: "190px",
        200: "200px",
        210: "210px",
        220: "220px",
        230: "230px",
        240: "240px",
        250: "250px",
        260: "260px",
        270: "270px",
        280: "280px",
        290: "290px",
        300: "300px",
        310: "310px",
        320: "320px",
        330: "330px",
        340: "340px",
        350: "350px",
        360: "360px",
        370: "370px",
        380: "380px",
        390: "390px",
        400: "400px",
      },
    },
  },
  variants: {
    extend: {
      margin: ["responsive"],
    },
  },
  plugins: [require("@tailwindcss/typography")],
};
```

### カスタムマージンの利用

設定が完了したら、CSS クラスとして利用することができます。例えば、`mt-80`と指定することで、上マージンを 80px に設定することができます。他にも、`mb-80`と指定することで、下マージンを 80px に設定することができます。

TypeScript と Next.js を使ったコンポーネントでは、以下のように利用できます。

```tsx
type Props = {
  title: string;
};

const CustomMarginComponent = ({ title }: Props) => {
  return <div className="mt-80">{title}</div>;
};
```

#### メリット

これまで解説した方法には、いくつかのメリットがあります。

- プロジェクト全体で一貫したスペーシングが可能になります。
- 新しい開発者がプロジェクトに参加した場合でも、スペーシングの設定方法を短時間で理解することが可能です。
- スペーシングの変更が必要な場合、一箇所の変更で全体のスペーシングを変更することが可能です。

### 参考資料

ここまで読んで、「もっと詳しく学びたい！」という方は、以下のリンクを参考にしてみてください。

- [Tailwind CSS 公式ドキュメンテーション](https://tailwindcss.com/docs/spacing)
- [Tailwind CSS カスタムスペーシングの設定方法](https://nerdcave.com/tailwind-css-custom-spacing)
- [The Power of Utility-First CSS (by Sarah Dayan, Frontend Developer at Algolia)](https://www.youtube.com/watch?v=I7CfaDYzTVM)

以上が Tailwind CSS でのカスタムマージンの設定方法になります。もしもの時のために心に留めておいてくださいね。


Tailwind CSSを使った開発では、カスタムマージンの設定が頻繁に必要です。この記事では、Next.jsとTypeScriptを使ったプロジェクトでTailwindのカスタムマージンを設定する方法を解説します。

Next.js で、Tailwind カスタムマージンを設定する


## TL;DR

Web サイトの中には数多くのページが存在しますけど、これら全てのページに容易にアクセスできるように、そのリンクを一覧化したものがサイトマップなんですね。SEO 対策にも欠かせないこのサイトマップ、Next.js と TypeScript でどのように作成するのか解説します。

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

`next-sitemap`は、Next.js プロジェクトのためのサイトマップを自動的に生成する npm パッケージです。それを使ってサイトマップを作成する方法は以下の通りです。

### インストール

まずはプロジェクトのルートディレクトリで次のコマンドを実行して、`next-sitemap`パッケージをインストールします:

```bash
npm install next-sitemap
```

もしくは、yarn を使っている場合は:

```bash
yarn add next-sitemap
```

次に、プロジェクトのルートディレクトリに`next-sitemap.config.js`という名前の新しいファイルを作成します。次に示すのは、基本的な設定の例です:

```js
module.exports = {
  siteUrl: 'https://example.com',
  generateRobotsTxt: true, // (optional)
  // ...other options
}
```

上記の`siteUrl`はあなたのウェブサイトの URL に置き換えてください。`generateRobotsTxt`オプションは`robots.txt`ファイルも生成するかどうかを制御します。

最後に、あなたの`package.json`ファイルに`postbuild`スクリプトを追加します。これにより、ビルド後にサイトマップが自動的に生成されます:

```json
"scripts": {
  "build": "next build",
  "postbuild": "next-sitemap"
}
```

以上の設定で、Next.js プロジェクトにサイトマップが追加されます。ビルドを行うと、自動的にサイトマップが生成され、`/public/sitemap.xml`に保存されます。

なお、`next-sitemap`の詳細な設定やオプションについては、公式ドキュメンテーションを参照してください。

## まとめ

Next.js と TypeScript を用いて、サイトマップの生成と設定が行えましたね。これらのステップに従うことで、サイトマップの設定が容易になり、SEO 対策とユーザビリティの向上につながります。

以上がサイトマップの設定方法についての解説です。最後になりますが、以下のリンクは、このトピックに関連する参考資料です。ぜひご覧になってみてください。

- [Google Search Console Help - Learn about sitemaps](https://support.google.com/webmasters/answer/156184?hl=en)
- [MDN Web Docs - Sitemaps](https://developer.mozilla.org/en-US/docs/Glossary/Sitemap)


サイトマップの設定方法について、Next.jsとTypeScriptを用いた実装手順を解説します。SEO対策とユーザビリティの向上に役立つサイトマップの重要性を理解しましょう。

Next.js と TypeScript で、サイトマップを作る


### duck typing（ダックタイピング） とは

duck typing（ダックタイピング） とは、クラスが別でも、同じ名前のメソッドを使用することができるスタイル。共通のメソッドを持ちさえすれば、継承を使わなくても、どのようなオブジェクトでも、これらのメソッドを実行できる。「型」より「ふるまい」に注目したスタイルである。

Luciano Ramalho 著の、[Fluent Python](https://amzn.to/33H2nmj) には次のように書かれている。

> ダックタイピングは、クラスやインターフェースの明示的な宣言にかかわりなく、適切なメソッドを実装するすべてのオブジェクトで関数が動作するポリモーフィズムの一形態。
>
> ダックタイピングとは無理に訳せば「アヒル流型付け」。オブジェクトは定義された型によって規定されるのではなくて、そのメソッドが何をするかで決まるという考え方を指します。100% アヒルであってもなくても（その型でなくても）、「ガーガー」鳴けばよいということです。そういった機能さえあればよい。

例えば、異なる 3 種類の says() メソッドが 3 つのクラスの異なる動作を行うのがポリモーフィズム（多態性）だが、ダックタイピングは、次のコードのように同じメソッドを持てば、どんなオブジェクトでもメソッドの同じ処理を実行できるようになる。

```python
# 1. 血縁関係のある家族クラスを作る
class Parent:
    def __init__(self, words):
        self.words = words
    def says(self):
        return self.words

class Child(Parent):
    def says(self):
        return self.words

class Grandchild(Parent):
    def says(self):
        return self.words

parent = Parent('親')
child = Child('子供')
grandchild = Grandchild('孫')

# 2. 上の家族とは血縁関係のない友人クラスを作る
class Frend:
    def says(self):
        return '友人'

frend = Frend()

# 3. says() を実行する関数を作る
def who_says(obj):
    print('私は、', obj.says(), 'です。')

# 4. 血縁に関係なく同じふるまいをする
who_says(parent)
#私は、 親 です。
who_says(child)
#私は、 子供 です。
who_says(grandchild)
#私は、 孫 です。
who_says(frend)
#私は、 友人 です。
```

### コードの詳説

1.  最初に、 Parent クラスを継承したサブクラスを 2 つ作り、インスタンス化している。
2.  次に、Parent クラスとは無関係の Frend クラスを作る。
3.  そして、共通のメソッドである says() を実行する関数を作り呼び出すと、Parent を継承したオブジェクトと、無関係のクラス Frend のオブジェクトのどちらも同じ動きが実行される。

このように共通のメソッド says() を持ちさえすれば、継承を利用しなくても様々なオブジェクトで同じ操作を切り替えることができる。つまり、ダックタイピングは「型」より「ふるまい」に注目したスタイルなのである。

これらのことを理解すると、公式ドキュメントに書かれていることも理解できる。

> あるオブジェクトが正しいインターフェースを持っているかを決定するのにオブジェクトの型を見ないプログラミングスタイルです。代わりに、単純にオブジェクトのメソッドや属性が呼ばれたり使われたりします。
>
> （「アヒルのように見えて、アヒルのように鳴けば、それはアヒルである。」）
>
> インターフェースを型より重視することで、上手くデザインされたコードは、ポリモーフィックな代替を許して柔軟性を向上させます。ダックタイピングは type() や isinstance() による判定を避けます。 (ただし、ダックタイピングを 抽象基底クラス で補完することもできます。) その代わり、典型的に hasattr() 判定や EAFP プログラミングを利用します。
>
> [duck-typing](https://docs.python.org/ja/3/glossary.html#term-duck-typing)


Python : duck typing（ダックタイピング） とは


### 関数の再帰呼び出し

関数の再帰呼び出しとは、「関数 A の中から、この関数 A 自身を呼び出すこと」である。

「ある手続きを実行している最中に、同じ手続きを、違う対象について行う」といった入れ子構造になった処理。大きな問題が小さな問題に収束するように使う。

### 再帰のルール

1. 再帰終了条件を持つ
2. 状態を変更しながら再帰終了条件に進む
3. 再帰的に関数自身を呼び出す

### 再帰関数の定義

再帰関数の定義は 2 つある。

1. 終了条件。終了条件は、最小の問題を処理する箇所。再帰呼び出しをせずに直接的に値を返す。
2. 再帰条件。再帰条件は「より小さな問題」を処理するための再帰呼び出しを行う。

問題を小さく分解していけば最終的に最小の問題を経由し終了条件が満たされるので、再帰が終了する。

### 関数の再帰呼び出しの例

次は再帰処理のシンプルな例である。引数 n を減算した値を、関数 total で加算しながらループさせ、n が 0 までたどり着いたときに再帰を停止する。

```python
def total(n):
    if n < 1: # 0 の時、再帰を停止
        return 0
    return n + total(n - 1) # 引数を減らしていく

print(total(3))
# 6
# 3 + 2 + 1


## 階乗の計算の例

次は階乗の計算（何通りの組み合わせがあるか？）を計算する例。引数に渡された数値を -1 しながら乗算している。

python
def fac(n):
    if n == 1:
        return 1
    else:
        return n * fac(n - 1)

print(fac(3))
# 6
# 3 * 2 * 1 = 6
```

### リストのリストなど入れ子になったデータを平坦化するコード

```python
def flat(x):
    for i in x:
        if isinstance(i, list):
            for i_in in flat(i):
                yield i_in
        else:
            yield i

x = [1, 2, [3, 4, 5], [6, [7, 8, 9]]]
list(flat(x))

# [1, 2, 3, 4, 5, 6, 7, 8, 9]
```


Python : 再帰は大きな問題が小さな問題に収束するように使う


## TL;DR

f-string は式を埋め込める文字リテラルである。先頭に f を付け、`f{式}`と書く。`{}` の中に、全ての Python 式を書くことができる。

#### セパレーター

`:,` とすると、カンマのセパレーターを入れる。

```python
a = 10000000000
print(f'{a:,}')
# 10,000,000,000

print(f'{a:_}')
# 10_000_000_000
```

#### 文字の位置を指定する

`:` の後ろに整数をつけると、フィールドの最小の文字幅を指定できる。揃えたいときに便利。
`:` の後ろにキャレット、小なり、大なり を置くと文字方向を指定できる。

- `:^` は、文字を中寄せ
- `:<` は、文字を左寄せ
- `:>` は、文字を右寄せ

そして、数値分の残りを指定の文字で繰り返して埋める。

```python
passwd = 'password'

print(f'{passwd:*^20}')
# ******password******

print(f'{passwd:*<20}')
# password************

print(f'{passwd:ば>20}')
# ばばばばばばばばばばばばpassword
```

`:<10` だと、空白 10 個分が埋められる。

```python
key = 'hello'
value = 1.234

f = f'{key} = {value}'
print(f)
# hello = 1.234

f = f'{key:<10} = {value:.4f}'
# :<10     最小フィールド幅
# :.4f     有効桁数（4桁）
print(f)
# 'hello'    = 1.2340
```

#### 改行

冗長なコードは改行して表示することができる。

```python
n = [
    ('a', 1),
    ('b', 2),
    ('c', 3),
]
for i, (item, count) in enumerate(n):
    print(f'{i}: '
          f'{item:<10} = '
          f'{count}')

# 0: a          = 1
# 1: b          = 2
# 2: c          = 3
```

#### フォーマット指定

フォーマットを指定する。

```python
fl = 1111
print(f'値は{fl:.3f}である！')
# 値は1111.000である！
```

#### 入れ

子
入れ子 `{{}}` でフォーマットを指定する。

```python
point = 3
fv = 222.1111999

print(f'{fv:.{point}f}')
# 222.111
```

#### バイナリデータ変換

バイナリデータに変換する。

```python
fl = 45
print(f'bit は {fl:b}')
# bit は 101101

print(f'hex は {fl:x}')
# hex は 2d

print(f'int は {fl:d}')
# int は 45
```

#### 日付の整形

日付を整形する。

```python
import datetime
d = datetime.datetime(2022, 1, 4, 3, 15, 59)
print(f'{d:%Y-%m-%d %H:%M:%S}')
# 2022-01-04 03:15:59
```

#### 置換 (conversion)

値に対して str() を呼ぶ `!s` 、 repr() を呼ぶ `!r` 、 ascii() を呼ぶ `!a` がサポートされている。

```python
name = '12345'
print(f'hello {name!r}')
# hello '12345'

print(f'hello {name}')
# hello 12345
```

> 置換 (conversion) フィールドにより書式変換前に型の強制変換が実施されます。通常、値の書式変換は `__format__()` によって実施されます。しかしながら、場合によっては、文字列として変換することを強制したり、書式指定の定義をオーバーライドしたくなることもあります。 `__format__()` の呼び出し前に値を文字列に変換すると、通常の書式変換の処理は飛ばされます。現在 3 つの変換フラグがサポートされています: 値に対して str() を呼ぶ `!s` 、 repr() を呼ぶ `!r` 、 ascii() を呼ぶ `!a`。 [string --- 一般的な文字列操作 — Python 3.10.0b2 ドキュメント](https://docs.python.org/ja/3/library/string.html)

#### 計算

計算を行う。

```python
s = 10
print(f'{s + 1}')
# 11

w = 'world '
f'hello {w * 3}'
# 'hello world world world'

import math
print(f'{math.pi:.2f}')
# 3.14
```

#### テキスト

テキストを代入する。

````python
w = 'world'
f'hello {w}'
# 'hello world'

file_name = 'flower.jpg'
alt_name = '花の写真です'
f'<img src="{file_name}" alt="{alt_name}">'
# <img src="flower.jpg" alt="花の写真です">
``

`

#### 式をそのまま表示する
`=` は名前を表示する。`=`` の直後に `:` を入れると、配置や幅を指定できる。
```python
a = 'apple'
b = 'banana'

print(f'{a}, {b}')
# apple, banana

# = を付ける
print(f'{a=}, {b=}')
# a ='apple', b ='banana'

# 配置.幅
print(f'{a=:10.2}, {b=:.3}')
# a = ap        , b =ban
````

#### 関数

関数の結果を返す。

```python
def func():
    return 'hoge'

print(f'{func()}')
# hoge
```

#### リスト

リストの要素を返すこともできる。

```python
img = ['flower.jpg', '花の写真です']
f'<img src="{img[0]}" alt="{img[1]}">'
# <img src="flower.jpg" alt="花の写真です">

w = ['apple', 'banana', 'cherry']
f'{w[1].title()}'
# 'Banana'
```

式を複数入れられる。

```python
w = ['apple', 'banana', 'cherry']
f'{w[0].capitalize()} is not the same as...{w[1].rjust(20)}.'
# 'Apple is not the same as...              banana.'
```


2023-05-24

Next.js と TypeScript で、タブ切り替えコンポーネントを作る

2023-05-23

Next.js と TypeScript で、パンくずリストを実装する方法

2023-05-23

Next.js と TypeScript で、Google Analytics(GA4) を導入する

2023-05-23

Next.js と TypeScript で、OGP のセットアップを設定する

2023-05-23

Next.js と TypeScript で、RSS を出力する

2023-05-23

Next.js で、Tailwind カスタムマージンを設定する

2023-05-22

Next.js と TypeScript で、サイトマップを作る

2022-1-22

Python : duck typing（ダックタイピング）とは

2022-1-14

Python : 再帰は大きな問題が小さな問題に収束するように使う

2021-12-7

Python: f-string（f 文字列）と「:」の便利な使い方

2023-05-24

Next.js と TypeScript で、タブ切り替えコンポーネントを作る

2023-05-23

Next.js と TypeScript で、パンくずリストを実装する方法

2023-05-23

Next.js と TypeScript で、Google Analytics(GA4) を導入する

2023-05-23

Next.js と TypeScript で、OGP のセットアップを設定する

2023-05-23

Next.js と TypeScript で、RSS を出力する

2023-05-23

Next.js で、Tailwind カスタムマージンを設定する

2023-05-22

Next.js と TypeScript で、サイトマップを作る

2022-1-22

Python : duck typing（ダックタイピング） とは

2022-1-14

Python : 再帰は大きな問題が小さな問題に収束するように使う

2021-12-7

Python: f-string（f 文字列）と「:」の便利な使い方

Python : duck typing（ダックタイピング）とは