Next.jsで学ぶReact講座 90日コース | Next.js基礎 - Day 48:Next.jsミニプロジェクト①

React Next.jsで学ぶReact講座90日コース
スポンサーリンク
スポンサーリンク
  1. Day 48:Next.jsミニプロジェクト① ― 記事一覧・詳細・カテゴリー・検索のあるブログサイトを作る
  2. 今回の完成形を確認する
    1. 今回の学習で特に大切なこと
  3. 今回の設計を決める
    1. 記事を識別する「slug」とは
    2. Server ComponentとClient Componentの設計
  4. プロジェクトを準備する
    1. 既存プロジェクトを使う場合の注意
  5. 完成時のファイル構成
  6. Step 1:記事とカテゴリーのデータを用意する
    1. src/data/posts.ts
    2. categoryを単なるstringにしない理由
  7. Step 2:検索とURL作成の処理をまとめる
    1. src/lib/blog.ts
    2. URLの値をいきなり文字列だと思わない
    3. 検索とカテゴリーはAND条件にする
    4. 不正なカテゴリーをどう扱うか決める
  8. Step 3:RootLayoutを作る
    1. src/app/layout.tsx
  9. Step 4:トップページを作る
    1. src/app/page.tsx
  10. Step 5:検索フォームを作る
    1. src/components/SearchForm.tsx
    2. nameがURLのキーになる
    3. Day 47のClient Componentとの違い
  11. Step 6:記事カードを作る
    1. src/components/PostCard.tsx
  12. Step 7:検索・カテゴリー付きの記事一覧を作る
    1. src/app/blog/page.tsx
    2. ページ全体の処理を読み解く
    3. カテゴリー変更時もキーワードを残す
    4. 「すべて」と「条件をすべて解除」は別の操作
    5. 検索結果0件でnotFound()を呼ばない理由
  13. Step 8:Dynamic Routesで記事詳細を作る
    1. src/app/blog/[slug]/page.tsx
    2. [slug]とparams.slugを対応させる
    3. generateStaticParams()の役割
    4. Metadataと本文で同じ記事取得関数を使う
  14. Step 9:記事が見つからない場合の画面を作る
    1. src/app/not-found.tsx
  15. Step 10:CSSで見た目を整える
    1. src/app/globals.css
  16. 実際の動作を順番に確認する
    1. URLを直接入力する確認が大切
  17. 機能のつながりを整理する
    1. キーワードとカテゴリーを指定して検索する場合
    2. 記事詳細を開く場合
  18. 検索機能の設計をもう一段深く理解する
    1. paramsとsearchParamsを混同しない
    2. なぜ検索用APIを作っていないのか
    3. なぜ記事本文を検索していないのか
    4. 記事データを更新したらどうなるか
  19. セキュリティで特に注意すること
    1. URLの値は外部入力として扱う
    2. 検索キーワードへ秘密情報を入れない
    3. データベースへ発展させるときは処理を見直す
  20. よくあるつまずきと確認方法
  21. 本番ビルドでも確認する
  22. 完成後の練習問題
    1. 練習問題①:記事を1件追加する
    2. 練習問題②:本文も検索対象にする
    3. 練習問題③:新しいカテゴリーを追加する
    4. 練習問題④:並び替えを追加する
  23. 22. Day 48の完成チェックリスト
  24. まとめ

Day 48:Next.jsミニプロジェクト① ― 記事一覧・詳細・カテゴリー・検索のあるブログサイトを作る

Day 48では、これまで学んだルーティング、レイアウト、Server Components、404処理、Metadata、URL検索を組み合わせて、ひとつのブログサイトを完成させます。

今回は、「記事データを用意する」「一覧を表示する」「URLから記事を選ぶ」「カテゴリーとキーワードで絞り込む」という順番で実装します。外部APIやデータベースは使わず、まずはアプリ全体の構造を理解できる構成にします。

今回の完成形を確認する

完成するブログサイトでは、記事一覧から記事詳細へ移動でき、カテゴリーとキーワードを組み合わせて記事を検索できます。

機能URLの例動作
記事一覧/blogすべての記事を表示します
記事詳細/blog/react-basics指定した記事を表示します
カテゴリー/blog?category=reactReactカテゴリーの記事を表示します
キーワード検索/blog?keyword=stateタイトルや説明文で検索します
条件の組み合わせ/blog?keyword=state&category=react両方に一致する記事を表示します
存在しない記事/blog/unknown-post見つからないことを案内します

カテゴリーは、今回は独立したページではなく、記事一覧の絞り込み条件として実装します。

また、記事詳細には[slug]という動的ルートを使います。Next.jsでは、角かっこ付きのフォルダー名でURLの可変部分を表します。(🔗 nextjs.org)

今回の学習で特に大切なこと

  • 記事データを一覧用と詳細用に分けず、同じデータから表示します。
  • 検索条件とカテゴリーをURLに保存します。
  • 検索結果が0件の場合と、記事自体が存在しない場合を区別します。
  • 機能を増やす前に、URLと画面の対応関係を決めます。
  • 必要のないClient ComponentやAPIを無理に作りません。

今回の設計を決める

記事を識別する「slug」とは

今回は、記事のURLに数字のIDではなく、react-basicsのような文字列を使います。このようなURL向けの識別文字列を、一般に**slug(スラッグ)**と呼びます。

たとえば、次のURLではreact-basicsがslugです。

/blog/react-basics

この記事とは別に、Stateの記事を作る場合は、次のように区別します。

/blog/react-state

このプロジェクトでは、slugを「記事を探すための一意な値」として使います。同じslugを複数の記事に付けないようにします。

Server ComponentとClient Componentの設計

今回は、作成する画面部品をServer Componentとして実装します。

検索フォームも、通常のHTMLフォームで送信すれば、useStateやonSubmitを使わずに実装できます。method="get"のフォームでは、入力項目のnameと値がURLのクエリ文字列として送信されます。(🔗 developer.mozilla.org)

部品今回の設計役割
RootLayoutServer Component全体のヘッダー・本文領域・フッター
記事一覧ページServer ComponentURLの条件を読み取って記事を絞り込む
検索フォームServer Component通常のGETフォームを表示する
記事カードServer Component記事の見出しと説明を表示する
記事詳細ページServer Componentslugに一致する記事を表示する

入力欄があるだけで、必ずClient Componentになるわけではありません。 ReactのStateやイベントハンドラーが必要かどうかで判断します。ページやレイアウトは、App Routerでは既定でServer Componentsです。(🔗 nextjs.org)

プロジェクトを準備する

すでに学習用プロジェクトがある場合は、そのプロジェクトでも実装できます。ただし、過去のファイルとの衝突を避けるには、新しく作ると取り組みやすくなります。

# 学習用のNext.jsプロジェクトを作成します
npx create-next-app@latest day48-blog

# 作成したフォルダーへ移動します
cd day48-blog

# 開発サーバーを起動します
npm run dev

作成時は、次の設定を選ぶ想定です。質問の表示順や選択肢は、利用するバージョンによって異なる場合があります。(🔗 nextjs.org)

設定今回の選択
TypeScript使用します
ESLint使用します
Tailwind CSS使用しません
src/ディレクトリ使用します
App Router使用します
import alias既定のままで構いません

この記事では、キャッシュの追加設定を行わず、cacheComponents: trueを有効にしていない構成を前提とします。

既存プロジェクトを使う場合の注意

過去にsrc/app/blog/[id]/page.tsxを作っている場合は、今回の[slug]へ置き換えます。

同じblogフォルダーの下に、同じURL位置を表す[id]と[slug]を両方残さないようにしてください。 今回は[slug]に統一します。

完成時のファイル構成

これから、次のファイルを順番に作ります。

src/
├── app/
│   ├── blog/
│   │   ├── [slug]/
│   │   │   └── page.tsx
│   │   └── page.tsx
│   ├── globals.css
│   ├── layout.tsx
│   ├── not-found.tsx
│   └── page.tsx
├── components/
│   ├── PostCard.tsx
│   └── SearchForm.tsx
├── data/
│   └── posts.ts
└── lib/
    └── blog.ts

役割は、次のように分けます。

  • data:記事やカテゴリーの元データを置きます。
  • lib:記事検索やURL作成などの共通処理を置きます。
  • components:複数の場所で使いやすい表示部品を置きます。
  • app:URLに対応するページやレイアウトを置きます。

Step 1:記事とカテゴリーのデータを用意する

最初に、画面へ表示するデータを作ります。

ここを先に決めておくと、一覧ページと詳細ページで「どの値を表示すればよいか」が明確になります。

src/data/posts.ts

// ブログで使用するカテゴリー一覧です
export const categories = [
  { slug: "react", name: "React" },
  { slug: "nextjs", name: "Next.js" },
  { slug: "typescript", name: "TypeScript" },
] as const;

// カテゴリーのslugを型として取り出します
export type CategorySlug = (typeof categories)[number]["slug"];

// 記事1件分の型です
export type Post = {
  slug: string;
  title: string;
  description: string;
  category: CategorySlug;
  publishedAt: string;
  body: string[];
};

// 学習用の記事データです
export const posts: Post[] = [
  {
    slug: "react-basics",
    title: "Reactの基本を学ぶ",
    description: "コンポーネントとJSXの考え方を整理します。",
    category: "react",
    publishedAt: "2026-10-01",
    body: [
      "Reactでは、画面をコンポーネントという部品に分けて考えます。",
      "見出し、ボタン、記事カードなどを部品にすると、画面の役割を整理できます。",
      "最初は小さなコンポーネントを作り、組み合わせて表示する練習から始めます。",
    ],
  },
  {
    slug: "react-state",
    title: "ReactのStateを理解する",
    description: "useStateを使って、変化する値を管理する方法を学びます。",
    category: "react",
    publishedAt: "2026-10-03",
    body: [
      "Stateは、画面の表示に関係する値を管理するための仕組みです。",
      "入力欄の文字やボタンを押した回数などを管理するときに使います。",
      "Next.jsでuseStateを使う部品は、Client Componentとして作成します。",
    ],
  },
  {
    slug: "nextjs-routing",
    title: "Next.jsのルーティング入門",
    description: "フォルダーとURLの対応関係を学びます。",
    category: "nextjs",
    publishedAt: "2026-10-05",
    body: [
      "App Routerでは、appディレクトリのフォルダー構成でURLを定義します。",
      "page.tsxは、そのURLで表示するページを表します。",
      "動的ルートを使うと、ひとつのページファイルで複数の記事を表示できます。",
    ],
  },
  {
    slug: "nextjs-server-components",
    title: "Server Componentsの役割",
    description: "サーバー側で表示を組み立てる設計を整理します。",
    category: "nextjs",
    publishedAt: "2026-10-07",
    body: [
      "App Routerでは、ページやレイアウトは既定でServer Componentsです。",
      "表示やサーバー側のデータ取得を担当する部分に適しています。",
      "Stateやブラウザーのイベントが必要な部分だけをClient Componentに分けます。",
    ],
  },
  {
    slug: "typescript-types",
    title: "TypeScriptの型の基本",
    description: "文字列、数値、オブジェクトの型を学びます。",
    category: "typescript",
    publishedAt: "2026-10-09",
    body: [
      "TypeScriptでは、値の種類を型として表せます。",
      "記事データの型を決めると、必要な項目の書き忘れに気づきやすくなります。",
      "型は開発を助けますが、外部から届くデータの実行時検証とは別のものです。",
    ],
  },
  {
    slug: "typescript-functions",
    title: "TypeScriptで関数を整理する",
    description: "引数と戻り値の型を使って、処理の役割を明確にします。",
    category: "typescript",
    publishedAt: "2026-10-11",
    body: [
      "同じ処理を繰り返す場合は、関数としてまとめると整理しやすくなります。",
      "引数は関数が受け取る値で、戻り値は関数が返す値です。",
      "検索処理やURL作成処理も、関数に分けると再利用できます。",
    ],
  },
];
TypeScript

categoryを単なるstringにしない理由

CategorySlugは、今回であれば次の3種類の文字列を表す型です。

// CategorySlugは、次のような文字列の組み合わせになります
type ExampleCategorySlug = "react" | "nextjs" | "typescript";
TypeScript

これにより、記事データにcategory: "raect"のような書き間違いがあると、TypeScriptで気づきやすくなります。

カテゴリーの表示名とURL用の値も分けています。画面ではNext.jsと表示し、URLではnextjsを使う設計です。

Step 2:検索とURL作成の処理をまとめる

次に、記事を探す処理、検索する処理、URLを作る処理をまとめます。

画面の中にすべて書くこともできますが、共通処理を関数にしておくと、ページのコードを読みやすくできます。

src/lib/blog.ts

// 記事・カテゴリーのデータと型を読み込みます
import {
  categories,
  posts,
  type CategorySlug,
} from "../data/posts";

// 検索キーワードの最大文字数です
export const MAX_KEYWORD_LENGTH = 100;

// URLから受け取る値の型です
export type QueryValue = string | string[] | undefined;

// アプリ内で使用する検索条件です
export type BlogFilters = {
  keyword: string;
  category: CategorySlug | "";
};

// 同じパラメータが複数ある場合は、最初の値を採用します
function getFirstValue(value: QueryValue): string {
  if (Array.isArray(value)) {
    return value[0] ?? "";
  }

  return value ?? "";
}

// URLから受け取った値を、アプリで使う形へ整えます
export function parseBlogFilters(
  rawKeyword: QueryValue,
  rawCategory: QueryValue,
): BlogFilters {
  // 前後の空白を除去し、長すぎるキーワードは切り詰めます
  const keyword = getFirstValue(rawKeyword)
    .trim()
    .slice(0, MAX_KEYWORD_LENGTH);

  // 定義済みのカテゴリーかどうかを確認します
  const categoryValue = getFirstValue(rawCategory);
  const matchedCategory = categories.find(
    (category) => category.slug === categoryValue,
  );

  return {
    keyword,
    // 不明なカテゴリーは「すべて」として扱います
    category: matchedCategory?.slug ?? "",
  };
}

// slugに一致する記事を1件探します
export function getPostBySlug(slug: string) {
  return posts.find((post) => post.slug === slug);
}

// キーワードとカテゴリーで記事を絞り込みます
export function searchPosts({ keyword, category }: BlogFilters) {
  // 大文字・小文字を区別しない検索にします
  const normalizedKeyword = keyword.toLowerCase();

  return posts
    .filter((post) => {
      // 今回はタイトルと説明文を検索対象にします
      const targetText =
        `${post.title} ${post.description}`.toLowerCase();

      const matchesKeyword =
        normalizedKeyword === "" ||
        targetText.includes(normalizedKeyword);

      const matchesCategory =
        category === "" || post.category === category;

      // 両方の条件に一致した記事だけを残します
      return matchesKeyword && matchesCategory;
    })
    .sort((a, b) => {
      // YYYY-MM-DD形式の日付を、新しい順に並べます
      return b.publishedAt.localeCompare(a.publishedAt);
    });
}

// カテゴリー名を取得します
export function getCategoryName(slug: CategorySlug): string {
  return (
    categories.find((category) => category.slug === slug)?.name ??
    slug
  );
}

// 検索条件から記事一覧のURLを作ります
export function buildBlogUrl({
  keyword = "",
  category = "",
}: Partial<BlogFilters> = {}): string {
  // 特殊文字も扱えるよう、URLSearchParamsを使います
  const params = new URLSearchParams();

  if (keyword !== "") {
    params.set("keyword", keyword);
  }

  if (category !== "") {
    params.set("category", category);
  }

  const query = params.toString();

  // 条件がない場合は、末尾に?を付けません
  return query === "" ? "/blog" : `/blog?${query}`;
}
TypeScript

URLの値をいきなり文字列だと思わない

たとえば、次のURLも利用者が入力できます。

/blog?keyword=react&keyword=next

この場合、ページのsearchParamsでは、keywordが配列になる場合があります。そのため、今回の型はstringだけではなく、string[]とundefinedも扱っています。Next.jsのページに渡されるsearchParamsはPromiseであり、その中身は通常のオブジェクトです。(🔗 nextjs.org)

今回は、同じパラメータが複数ある場合に「最初の値を使う」というルールを決めました。

検索とカテゴリーはAND条件にする

今回の中心になるのは、次の1行です。

// キーワードとカテゴリーの両方に一致した場合だけ表示します
return matchesKeyword && matchesCategory;
TypeScript

&&は、両方の条件を満たす場合にtrueになります。

たとえば、キーワードがstate、カテゴリーがreactなら、「Stateに関係する記事」であり、かつ「Reactカテゴリーの記事」を表示します。

ここを||にすると、どちらか一方に一致した記事まで表示されるため、意図した絞り込みになりません。

不正なカテゴリーをどう扱うか決める

今回は、category=unknownのような未定義のカテゴリーを「すべて」として扱います。

これは今回の仕様です。不正なカテゴリーをエラー表示にする設計もありますが、どちらにしても、想定外の値が来たときの動作を明確に決めておくことが大切です。

キーワードが100文字を超えた場合は、先頭100文字だけを使います。ただし、この処理は検索に使う値を整えるものであり、アドレスバーのURL自体を書き換えるわけではありません。

Step 3:RootLayoutを作る

次に、サイト全体の共通部分を作ります。

今回は、RootLayoutにヘッダー、本文領域、フッターを置きます。ページ側では<main>を重ねず、<section>や<article>を使います。

src/app/layout.tsx

// MetadataとReactの型を読み込みます
import type { Metadata } from "next";
import type { ReactNode } from "react";

// 内部リンクと共通CSSを読み込みます
import Link from "next/link";
import "./globals.css";

// サイト全体のMetadataです
export const metadata: Metadata = {
  title: {
    default: "Next.js学習ブログ",
    template: "%s | Next.js学習ブログ",
  },
  description:
    "React、Next.js、TypeScriptを学ぶための学習用ブログです。",
};

// サイト全体で共有するレイアウトです
export default function RootLayout({
  children,
}: {
  children: ReactNode;
}) {
  return (
    <html lang="ja">
      <body>
        {/* 全ページ共通のヘッダーです */}
        <header className="site-header">
          <div className="container header-inner">
            <Link className="site-logo" href="/">
              Next.js学習ブログ
            </Link>

            <nav aria-label="メインメニュー">
              <Link href="/blog">記事一覧</Link>
            </nav>
          </div>
        </header>

        {/* ページ本体はここへ入ります */}
        <main className="container main-content">
          {children}
        </main>

        {/* 全ページ共通のフッターです */}
        <footer className="site-footer">
          <div className="container">
            <small>Next.js ミニプロジェクト①</small>
          </div>
        </footer>
      </body>
    </html>
  );
}
TSX

記事詳細のタイトルは、後ほどgenerateMetadataで設定します。Metadata APIを使うと、ページごとのタイトルや説明文を管理できます。なお、title.templateは子セグメント向けに適用され、同じセグメントのページタイトルには適用されません。(🔗 nextjs.org)

Step 4:トップページを作る

トップページは、ブログ一覧への入口にします。

src/app/page.tsx

// 記事一覧へのリンクを読み込みます
import Link from "next/link";

// トップページです
export default function HomePage() {
  return (
    <section className="panel">
      <h1>Next.js学習ブログ</h1>

      <p>
        React、Next.js、TypeScriptの学習記事をまとめたブログです。
      </p>

      <p>
        記事一覧から、カテゴリーやキーワードで記事を探せます。
      </p>

      {/* ブログ一覧へ移動します */}
      <Link className="button" href="/blog">
        記事一覧を見る
      </Link>
    </section>
  );
}
TSX

ここまで作ると、サイト全体の枠と、ブログへの入口ができます。

Step 5:検索フォームを作る

次に、キーワード入力とカテゴリー選択をひとつのフォームにまとめます。

両方を同じフォームに入れることで、検索時にカテゴリーが消えたり、カテゴリー変更時にキーワードが消えたりする問題を避けやすくなります。

src/components/SearchForm.tsx

// カテゴリーと検索条件の型を読み込みます
import { categories } from "../data/posts";
import {
  MAX_KEYWORD_LENGTH,
  type BlogFilters,
} from "../lib/blog";

// 通常のHTMLフォームなので、"use client"は不要です
export default function SearchForm({
  keyword,
  category,
}: BlogFilters) {
  return (
    <form
      className="search-form"
      action="/blog"
      method="get"
      role="search"
    >
      <div className="form-field">
        <label htmlFor="keyword">キーワード</label>

        <input
          id="keyword"
          // このnameがURLのパラメータ名になります
          name="keyword"
          type="search"
          defaultValue={keyword}
          maxLength={MAX_KEYWORD_LENGTH}
          placeholder="例:React、State"
        />
      </div>

      <div className="form-field">
        <label htmlFor="category">カテゴリー</label>

        <select
          id="category"
          // 選択値はcategoryという名前で送信されます
          name="category"
          defaultValue={category}
        >
          <option value="">すべて</option>

          {categories.map((item) => (
            <option key={item.slug} value={item.slug}>
              {item.name}
            </option>
          ))}
        </select>
      </div>

      {/* GET送信でURLに検索条件を反映します */}
      <button className="button" type="submit">
        検索する
      </button>
    </form>
  );
}
TSX

nameがURLのキーになる

入力欄には、次の指定があります。

// nameの値が、送信時のパラメータ名になります
<input name="keyword" type="search" />
TSX

ここへreactと入力して送信すると、keyword=reactという形式で送信されます。

また、カテゴリーでReactを選ぶと、category=reactも送信されます。通常のGETフォームでは、空欄の項目も含まれ、次のようなURLになることがあります。(🔗 developer.mozilla.org)

/blog?keyword=react&category=

今回のプログラムでは空文字を「条件なし」として扱うため、このURLでも正常に動きます。

Day 47のClient Componentとの違い

Day 47では、useRouterなどを使ってURLを書き換えるフォームを学びました。今回は仕組みを絞り、通常のHTMLフォームを使います。

通常のフォーム送信なので、検索時は文書全体の読み込みが発生します。これは今回の簡潔な構成を優先した設計です。入力中のリアルタイム検索や、検索中の状態表示を細かく制御したい場合は、フォームをClient Componentへ発展させます。

Step 6:記事カードを作る

記事一覧に表示する、記事1件分の部品を作ります。

src/components/PostCard.tsx

// 内部リンクと記事の型を読み込みます
import Link from "next/link";
import type { Post } from "../data/posts";

// カテゴリー名とURL作成の関数を読み込みます
import {
  buildBlogUrl,
  getCategoryName,
} from "../lib/blog";

// 記事カードです
export default function PostCard({ post }: { post: Post }) {
  return (
    <article className="post-card">
      <div className="post-meta">
        {/* カテゴリー別の記事一覧へ移動します */}
        <Link
          className="category-badge"
          href={buildBlogUrl({ category: post.category })}
        >
          {getCategoryName(post.category)}
        </Link>

        {/* 機械にも日付を伝えられるtime要素を使います */}
        <time dateTime={post.publishedAt}>
          {post.publishedAt}
        </time>
      </div>

      <h2>
        {/* slugに対応する動的ルートへ移動します */}
        <Link href={`/blog/${post.slug}`}>
          {post.title}
        </Link>
      </h2>

      <p>{post.description}</p>

      <Link href={`/blog/${post.slug}`}>
        続きを読む
      </Link>
    </article>
  );
}
TSX

このカードは、記事の中身を自分で持ちません。親から渡されたpostを表示するだけです。

このようにすると、記事一覧ページは「何件表示するか」、記事カードは「1件をどう表示するか」という役割分担になります。

Step 7:検索・カテゴリー付きの記事一覧を作る

ここが、今回の一覧機能をまとめるページです。

URLから条件を受け取り、検索し、その結果をカードとして表示します。

src/app/blog/page.tsx

// ページのMetadata型を読み込みます
import type { Metadata } from "next";

// リンクと表示部品を読み込みます
import Link from "next/link";
import PostCard from "../../components/PostCard";
import SearchForm from "../../components/SearchForm";

// カテゴリーと共通処理を読み込みます
import { categories } from "../../data/posts";
import {
  buildBlogUrl,
  getCategoryName,
  parseBlogFilters,
  searchPosts,
  type QueryValue,
} from "../../lib/blog";

// ブログ一覧のMetadataです
export const metadata: Metadata = {
  title: "記事一覧",
  description:
    "React、Next.js、TypeScriptの記事をカテゴリーとキーワードで検索できます。",
};

// URLのクエリ文字列を受け取る型です
type BlogPageProps = {
  searchParams: Promise<{
    keyword?: QueryValue;
    category?: QueryValue;
  }>;
};

// 記事一覧ページです
export default async function BlogPage({
  searchParams,
}: BlogPageProps) {
  // URLの条件を受け取ります
  const query = await searchParams;

  // 配列や不明な値を処理し、条件を整えます
  const filters = parseBlogFilters(
    query.keyword,
    query.category,
  );

  // 条件に一致した記事を取得します
  const filteredPosts = searchPosts(filters);

  return (
    <section>
      <header className="page-heading">
        <h1>記事一覧</h1>
        <p>カテゴリーやキーワードで記事を探せます。</p>
      </header>

      {/* URLの条件が変わったとき、入力欄の初期値も更新します */}
      <SearchForm
        key={JSON.stringify(filters)}
        keyword={filters.keyword}
        category={filters.category}
      />

      <nav
        className="category-nav"
        aria-label="カテゴリーで絞り込む"
      >
        <ul>
          <li>
            {/* キーワードは保持し、カテゴリーだけ解除します */}
            <Link
              href={buildBlogUrl({
                keyword: filters.keyword,
              })}
              aria-current={
                filters.category === "" ? "page" : undefined
              }
            >
              すべて
            </Link>
          </li>

          {categories.map((category) => (
            <li key={category.slug}>
              <Link
                href={buildBlogUrl({
                  keyword: filters.keyword,
                  category: category.slug,
                })}
                aria-current={
                  filters.category === category.slug
                    ? "page"
                    : undefined
                }
              >
                {category.name}
              </Link>
            </li>
          ))}
        </ul>
      </nav>

      <div className="results-summary">
        <p>
          検索キーワード:
          <strong>{filters.keyword || "指定なし"}</strong>
        </p>

        <p>
          カテゴリー:
          <strong>
            {filters.category
              ? getCategoryName(filters.category)
              : "すべて"}
          </strong>
        </p>

        <p>{filteredPosts.length}件の記事があります。</p>

        {/* キーワードとカテゴリーを両方解除します */}
        <Link href="/blog">条件をすべて解除する</Link>
      </div>

      {filteredPosts.length === 0 ? (
        <div className="panel">
          <h2>該当する記事はありません</h2>
          <p>
            キーワードを短くするか、カテゴリーを変更してください。
          </p>
        </div>
      ) : (
        <ul className="post-list">
          {filteredPosts.map((post) => (
            <li key={post.slug}>
              <PostCard post={post} />
            </li>
          ))}
        </ul>
      )}
    </section>
  );
}
TSX

ページ全体の処理を読み解く

ページの冒頭では、次の順番で処理しています。

  • await searchParamsでURLの条件を取得します。
  • parseBlogFilters()で、受け取った値を使いやすい形にします。
  • searchPosts()で、条件に一致する記事を取り出します。
  • 結果をPostCardとして表示します。

URLの条件を読む処理と記事を探す処理が分かれているため、ページには表示の流れがまとまっています。

カテゴリー変更時もキーワードを残す

カテゴリーリンクでは、現在のキーワードも渡しています。

// キーワードを残しながら、カテゴリーだけを変更します
href={buildBlogUrl({
  keyword: filters.keyword,
  category: category.slug,
})}
TSX

ここでカテゴリーだけを渡してしまうと、それまで入力していたキーワードが消えます。

「条件を追加したとき、既存のどの条件を維持するか」は、検索画面で特に重要な設計です。

「すべて」と「条件をすべて解除」は別の操作

今回の画面では、次のように意味を分けています。

  • カテゴリーの「すべて」:カテゴリーだけを解除し、キーワードは残します。
  • 「条件をすべて解除する」:カテゴリーとキーワードを両方解除します。

表示する文言と実際の動作をそろえると、利用者が迷いにくくなります。

検索結果0件でnotFound()を呼ばない理由

検索結果が0件でも、/blogというページ自体は存在しています。

そのため、今回は404ではなく、「該当する記事はありません」と案内します。一方、記事詳細で指定されたslugの記事が存在しない場合には、次のステップでnotFound()を使います。

Step 8:Dynamic Routesで記事詳細を作る

次に、/blog/react-basicsなどのURLで記事を表示します。

src/app/blog/[slug]/page.tsx

// Metadataとリンクを読み込みます
import type { Metadata } from "next";
import Link from "next/link";

// 存在しない記事を扱う関数を読み込みます
import { notFound } from "next/navigation";

// 元データと共通処理を読み込みます
import { posts } from "../../../data/posts";
import {
  buildBlogUrl,
  getCategoryName,
  getPostBySlug,
} from "../../../lib/blog";

// 動的ルートから受け取る値の型です
type BlogDetailPageProps = {
  params: Promise<{
    slug: string;
  }>;
};

// 公開記事のパラメータ一覧を返します
export function generateStaticParams() {
  return posts.map((post) => ({
    slug: post.slug,
  }));
}

// 記事ごとのMetadataを生成します
export async function generateMetadata({
  params,
}: BlogDetailPageProps): Promise<Metadata> {
  const { slug } = await params;
  const post = getPostBySlug(slug);

  // Metadata生成時にも、記事の存在を確認します
  if (!post) {
    notFound();
  }

  return {
    title: post.title,
    description: post.description,
  };
}

// 記事詳細ページです
export default async function BlogDetailPage({
  params,
}: BlogDetailPageProps) {
  // URLのslugを取得します
  const { slug } = await params;

  // 対応する記事を探します
  const post = getPostBySlug(slug);

  // 記事がなければ、not-found.tsxへ切り替えます
  if (!post) {
    notFound();
  }

  return (
    <article className="article-detail">
      <p>
        <Link href="/blog">← 記事一覧へ</Link>
      </p>

      <header className="article-header">
        <Link
          className="category-badge"
          href={buildBlogUrl({ category: post.category })}
        >
          {getCategoryName(post.category)}
        </Link>

        <h1>{post.title}</h1>

        <time dateTime={post.publishedAt}>
          公開日:{post.publishedAt}
        </time>

        <p className="article-description">
          {post.description}
        </p>
      </header>

      <div className="article-body">
        {post.body.map((paragraph, index) => (
          // 今回は順序が固定された段落なのでindexを使います
          <p key={`${post.slug}-${index}`}>
            {paragraph}
          </p>
        ))}
      </div>
    </article>
  );
}
TSX

[slug]とparams.slugを対応させる

[slug]というフォルダー名にしたため、ページではparamsからslugを取り出します。

// /blog/react-basicsならslugは"react-basics"になります
const { slug } = await params;
TSX

フォルダー名を[id]にした場合は、取り出す名前もidです。フォルダー名とコードの変数名をそろえることが重要です。(🔗 nextjs.org)

generateStaticParams()の役割

今回は記事データがあらかじめ分かっているため、generateStaticParams()で記事のslug一覧を返しています。

Next.jsは、この一覧を動的ルートのビルド時生成に利用できます。ただし、この関数は、一覧ページの検索やカテゴリー絞り込みを行うものではありません。 対象は記事詳細の動的ルートです。(🔗 nextjs.org)

Metadataと本文で同じ記事取得関数を使う

generateMetadataとページ本体の両方でgetPostBySlug()を使っています。

今回の処理はローカル配列からの記事検索なので、構成を単純に保つことを優先しています。将来データベースへ変更する場合は、取得回数やキャッシュも含めて見直します。

Step 9:記事が見つからない場合の画面を作る

存在しない記事へアクセスされた場合に備えて、not-found.tsxを作ります。

src/app/not-found.tsx

// 記事一覧へ戻るためのリンクを読み込みます
import Link from "next/link";

// 見つからない場合の案内画面です
export default function NotFound() {
  return (
    <section className="panel">
      <h1>ページが見つかりません</h1>

      <p>
        指定されたページや記事は存在しないか、
        公開が終了した可能性があります。
      </p>

      {/* 利用者が次の操作へ進めるようにします */}
      <Link className="button" href="/blog">
        記事一覧へ戻る
      </Link>
    </section>
  );
}
TSX

notFound()は、見つからないリソースの描画を打ち切り、対応する見つからない画面を表示するための関数です。return notFound()と書く必要はありません。(🔗 nextjs.org)

なお、HTTPステータスは、ストリーミング開始前なら404、開始後なら200のまま見つからない画面が表示される場合があります。「404用UIが表示されたら必ずHTTPステータスも404」とは限らない点は、公開時の確認事項です。(🔗 nextjs.org)

Step 10:CSSで見た目を整える

最後に、共通CSSを設定します。

既存のglobals.cssに学習用スタイルが多くある場合は、今回は内容を置き換えると、意図しない競合を避けやすくなります。

src/app/globals.css

/* 要素の幅にpaddingやborderを含めます */
* {
  box-sizing: border-box;
}

/* ページ全体の基本設定です */
body {
  margin: 0;
  color: #1f2937;
  background: #f8fafc;
  font-family: sans-serif;
  line-height: 1.8;
}

/* リンクの基本設定です */
a {
  color: #1d4ed8;
  text-underline-offset: 0.2em;
}

/* キーボード操作時の位置を見やすくします */
a:focus-visible,
button:focus-visible,
input:focus-visible,
select:focus-visible {
  outline: 3px solid #f59e0b;
  outline-offset: 3px;
}

/* 画面の最大幅と左右の余白です */
.container {
  width: min(100% - 32px, 1000px);
  margin-inline: auto;
}

/* サイト全体のヘッダーです */
.site-header {
  background: #ffffff;
  border-bottom: 1px solid #dbe2ea;
}

.header-inner {
  display: flex;
  align-items: center;
  justify-content: space-between;
  gap: 16px;
  padding-block: 20px;
}

.site-logo {
  color: #111827;
  font-weight: 700;
  text-decoration: none;
}

/* 本文領域の余白です */
.main-content {
  min-height: 70vh;
  padding-block: 40px;
}

.page-heading {
  margin-bottom: 24px;
}

h1,
h2 {
  line-height: 1.5;
}

h1 {
  margin-top: 0;
}

/* 共通パネルです */
.panel {
  padding: 24px;
  background: #ffffff;
  border: 1px solid #dbe2ea;
  border-radius: 12px;
}

/* 検索フォームです */
.search-form {
  display: flex;
  align-items: end;
  flex-wrap: wrap;
  gap: 16px;
  padding: 20px;
  background: #ffffff;
  border: 1px solid #dbe2ea;
  border-radius: 12px;
}

.form-field {
  display: grid;
  flex: 1 1 220px;
  gap: 6px;
}

label {
  font-weight: 700;
}

input,
select,
button {
  font: inherit;
}

input,
select {
  width: 100%;
  padding: 10px 12px;
  color: #111827;
  background: #ffffff;
  border: 1px solid #94a3b8;
  border-radius: 6px;
}

/* リンクとボタンに共通する見た目です */
.button {
  display: inline-block;
  padding: 10px 16px;
  color: #ffffff;
  background: #1d4ed8;
  border: 1px solid #1d4ed8;
  border-radius: 6px;
  text-align: center;
  text-decoration: none;
  cursor: pointer;
}

/* カテゴリーの切り替えです */
.category-nav {
  margin-block: 24px;
}

.category-nav ul {
  display: flex;
  flex-wrap: wrap;
  gap: 12px;
  margin: 0;
  padding: 0;
  list-style: none;
}

.category-nav a {
  display: inline-block;
  padding: 6px 12px;
  background: #ffffff;
  border: 1px solid #cbd5e1;
  border-radius: 999px;
  text-decoration: none;
}

.category-nav a[aria-current="page"] {
  color: #ffffff;
  background: #1d4ed8;
  border-color: #1d4ed8;
}

/* 現在の条件と検索件数です */
.results-summary {
  margin-bottom: 24px;
  overflow-wrap: anywhere;
}

.results-summary p {
  margin-block: 4px;
}

/* 記事一覧をカード状に並べます */
.post-list {
  display: grid;
  grid-template-columns: repeat(2, minmax(0, 1fr));
  gap: 20px;
  margin: 0;
  padding: 0;
  list-style: none;
}

.post-card {
  height: 100%;
  padding: 24px;
  background: #ffffff;
  border: 1px solid #dbe2ea;
  border-radius: 12px;
  overflow-wrap: anywhere;
}

.post-card h2 {
  margin-block: 16px 12px;
  font-size: 1.2rem;
}

.post-meta {
  display: flex;
  align-items: center;
  flex-wrap: wrap;
  gap: 12px;
  color: #475569;
  font-size: 0.9rem;
}

.category-badge {
  display: inline-block;
  padding: 2px 10px;
  color: #1e40af;
  background: #dbeafe;
  border-radius: 999px;
  text-decoration: none;
}

/* 記事詳細です */
.article-detail {
  max-width: 760px;
  margin-inline: auto;
  padding: 28px;
  background: #ffffff;
  border: 1px solid #dbe2ea;
  border-radius: 12px;
  overflow-wrap: anywhere;
}

.article-header {
  margin-bottom: 32px;
}

.article-header h1 {
  margin-top: 16px;
}

.article-description {
  color: #475569;
}

.article-body p {
  margin-block: 24px;
}

/* 共通フッターです */
.site-footer {
  padding-block: 24px;
  color: #475569;
  border-top: 1px solid #dbe2ea;
}

/* 狭い画面では1列にします */
@media (max-width: 640px) {
  .header-inner {
    align-items: flex-start;
    flex-direction: column;
  }

  .post-list {
    grid-template-columns: 1fr;
  }

  .article-detail {
    padding: 20px;
  }

  .search-form .button {
    width: 100%;
  }
}

ここまでで、記事一覧、詳細、カテゴリー、検索、存在しない記事の案内までそろいます。

実際の動作を順番に確認する

まずはブラウザーで、次のページを開きます。

http://localhost:3000

その後、記事一覧へ移動し、以下の項目を確認します。

確認項目操作・URL期待する結果
全件表示/blog6件表示されます
表示順/blog公開日が新しい記事から並びます
詳細表示/blog/react-basicsReactの基本の記事が表示されます
カテゴリー/blog?category=reactReactの記事が2件表示されます
キーワード/blog?keyword=stateStateの記事が1件表示されます
組み合わせ/blog?keyword=state&category=reactStateの記事が1件表示されます
条件不一致/blog?keyword=state&category=typescript0件の案内が表示されます
大文字・小文字/blog?keyword=REACTReactの記事が2件表示されます
未定義カテゴリー/blog?category=unknown全カテゴリーとして扱われます
存在しない記事/blog/unknown-post見つからない画面になります
複数の同名条件/blog?keyword=state&keyword=next最初のstateで検索されます

URLを直接入力する確認が大切

クリック操作だけでなく、URLを直接入力しても同じ画面になるか確認します。

今回の設計では、検索条件がReactのStateだけにあるのではなく、URLにあります。そのため、URLを共有したり、再読み込みしたりしても、同じ条件から検索結果を作れます。

機能のつながりを整理する

ここまで作った機能を、ひとつの流れとして確認します。

キーワードとカテゴリーを指定して検索する場合

  • 利用者がキーワードを入力し、カテゴリーを選びます。
  • フォームを送信すると、条件がクエリ文字列としてURLへ入ります。
  • app/blog/page.tsxがsearchParamsから条件を読み取ります。
  • parseBlogFilters()が値を整えます。
  • searchPosts()が記事を絞り込みます。
  • 検索結果がPostCardとして表示されます。

記事詳細を開く場合

  • 記事カードのリンクを押します。
  • /blog/react-basicsなどの記事URLへ移動します。
  • app/blog/[slug]/page.tsxがslugを受け取ります。
  • getPostBySlug()が該当記事を探します。
  • 記事があれば本文を表示し、なければnotFound()を呼びます。

一覧は条件で複数の記事を探し、詳細はslugで1件の記事を探す。 この違いを理解すると、商品一覧と商品詳細などにも応用できます。

検索機能の設計をもう一段深く理解する

paramsとsearchParamsを混同しない

今回のURLには、2種類の値があります。

種類例取得するもの
パスの動的な値/blog/react-basicsparams.slug
クエリ文字列/blog?keyword=reactsearchParams.keyword

記事の識別にはparams、記事一覧の条件にはsearchParamsを使っています。どちらもページで受け取れますが、役割が異なります。(🔗 nextjs.org)

なぜ検索用APIを作っていないのか

Day 46ではRoute Handlersを学びましたが、今回は検索用APIを作っていません。

Server Componentでローカルの記事データを直接扱えるため、わざわざ自分の/api/postsを経由する必要がないからです。

Next.js公式でも、Server Componentからのデータ取得では、不要な内部HTTPリクエストを増やさず、データソースへ直接アクセスする方法が案内されています。(🔗 nextjs.org)

APIは、ブラウザーから部分的にデータを取得したい場合や、別のアプリにもデータを提供したい場合などに検討します。

なぜ記事本文を検索していないのか

今回の検索対象は、タイトルと説明文だけです。

// 今回は、この2項目だけを検索対象にしています
const targetText =
  `${post.title} ${post.description}`.toLowerCase();
TypeScript

本文も検索したい場合は、次のように置き換えられます。

// 本文の段落も文字列としてまとめ、検索対象へ加えます
const targetText = [
  post.title,
  post.description,
  ...post.body,
]
  .join(" ")
  .toLowerCase();
TypeScript

ただし、この変更により、一覧で見えていない本文の言葉でも検索に一致するようになります。検索結果が変わるため、テストの期待値も見直します。

記事データを更新したらどうなるか

今回の記事はソースコード内にあるため、新しい記事を追加するにはposts.tsを編集します。

公開サイトでは、その変更を反映するためにビルド・デプロイを行う運用を想定しています。ブラウザーから投稿する機能や、データベースへの永続保存は今回の範囲に含めていません。

セキュリティで特に注意すること

URLの値は外部入力として扱う

今回の検索欄にはmaxLengthを設定していますが、利用者はアドレスバーから長い文字列を直接指定できます。

そのため、フォームの制限だけに頼らず、parseBlogFilters()でも文字数とカテゴリーを処理しています。

ただし、この文字数制限は今回の入力ルールであり、これだけで大量リクエストなどへの対策が完成するわけではありません。

検索キーワードへ秘密情報を入れない

検索条件はURLへ残す設計です。公開ブログの一般的なキーワード検索には便利ですが、パスワードやトークンなどの秘密情報を検索条件として扱わないようにします。

データベースへ発展させるときは処理を見直す

今回のincludes()による配列検索を、SQL文字列の連結へそのまま置き換えてはいけません。データベースへ移行するときは、利用する仕組みに合わせて、パラメーター化された問い合わせ、アクセス権限、取得件数の制限などを設計します。

表示方法も必要最小限にする

今回は、記事本文を文字列として表示しています。記事本文にHTMLを直接埋め込む機能は作っていません。

本文をHTML対応にする場合

将来、CMSのHTMLや利用者投稿を表示する場合は、今回とは別の安全性確認が必要です。

安易に追加しないもの

「改行や装飾を付けたい」という理由だけで、未検証の内容をdangerouslySetInnerHTMLへ渡す設計に変更しないようにします。今回は段落を配列で持ち、それぞれを<p>として表示する形を維持します。

よくあるつまずきと確認方法

症状確認すること修正の方向
記事一覧が表示されないsrc/app/blog/page.tsxがあるかURLに対応する位置へ配置します
詳細がすべて見つからないslugの綴りとデータが一致するかリンク・データ・検索処理を照合します
動的ルートでエラーになる[id]と[slug]が残っていないか今回は[slug]へ統一します
キーワードがURLへ入らない入力欄にname="keyword"があるかidだけでなくnameも設定します
カテゴリーが検索に反映されないselectのnameとvaluecategoryとカテゴリーslugを使います
Reactで検索できない検索対象が何か今回はタイトルと説明文が対象です
条件変更後も入力欄が古いSearchFormのkeyがあるか条件に応じてフォームを再作成します
結果が広すぎる条件を`
本文領域が不自然<main>が入れ子になっていないかRootLayoutだけに<main>を置きます

本番ビルドでも確認する

開発サーバーで動いたら、最後に本番ビルドも確認します。

開発サーバーを停止してから、次のコマンドを実行します。

# 本番用にビルドします
npm run build

# ビルド成功後、本番用サーバーを起動します
npm run start

表示されたローカルのURLを開き、一覧、検索、カテゴリー、詳細、存在しない記事をもう一度確認します。

今回の一覧はリクエスト時の検索条件を読むため、動的な処理を含みます。学習時はnpm run startで動かす構成とし、静的ファイルだけを配信する構成への変更は別途検討します。(🔗 nextjs.org)

完成後の練習問題

練習問題①:記事を1件追加する

posts.tsへ記事を1件追加します。既存の記事とは異なるslugを設定し、一覧と詳細の両方へ反映されることを確認します。

  • 一覧の件数が増えているか確認します。
  • 公開日の順序が正しいか確認します。
  • 新しい記事のURLを直接開けるか確認します。
  • タイトルや説明文を使って検索できるか確認します。

練習問題②:本文も検索対象にする

searchPosts()を変更して、記事本文も検索対象に加えます。

一覧には見えていない本文の言葉を入力し、その記事が検索結果に出ることを確認します。

練習問題③:新しいカテゴリーを追加する

categoriesへ、たとえばcssカテゴリーを追加します。

今回のカテゴリー選択欄とリンクは配列から生成しているため、カテゴリーを増やしたときに、どの表示が自動で増えるか確認できます。

練習問題④:並び替えを追加する

発展として、sort=oldestのような条件を追加します。

その際は、検索キーワードやカテゴリーを変更しても、並び替え条件が意図せず消えない設計を考えます。

22. Day 48の完成チェックリスト

  • 記事一覧にすべての記事が表示されます。
  • 記事が公開日の新しい順に並びます。
  • 記事カードから記事詳細へ移動できます。
  • 動的ルートのslugから記事を取得できます。
  • カテゴリーで絞り込めます。
  • キーワードで検索できます。
  • カテゴリーとキーワードを組み合わせられます。
  • 検索条件がURLに残ります。
  • 検索URLを直接開いても結果を再現できます。
  • 検索結果0件を通常の画面として案内できます。
  • 存在しない記事には見つからない画面を表示できます。
  • 記事ごとにタイトルとdescriptionを設定できます。
  • 本番ビルド後も主要機能が動きます。

まとめ

Day 48では、記事一覧、記事詳細、カテゴリー、検索、Dynamic Routesを組み合わせて、ひとつのブログサイトを作りました。

今回の中心となる設計は、「記事の識別はslug」「一覧の条件はクエリ文字列」「表示と検索処理は分離する」という3点です。検索フォームは入力をURLへ送り、一覧ページはURLから条件を読み取り、詳細ページはslugから1件の記事を探します。

まずは、この構成を自分で修正できる状態を目指します。記事を増やす、検索対象を変える、カテゴリーを追加するという練習ができれば、コードを写す段階から、機能のつながりを理解してアプリを組み立てる段階へ進めます。

タイトルとURLをコピーしました