Node.js を使った Web 開発において、Express は最も人気の高いフレームワークの一つです。シンプルで軽量でありながら、強力な API サーバーを短時間で構築できる魅力があります。

本記事では、Express を使った API サーバー開発の基礎から実践まで、段階的に学んでいきましょう。初心者の方でも安心して取り組めるよう、環境構築から始まり、実際に動く API サーバーの構築まで、丁寧に解説していきます。

Express とは何か

Web フレームワークの役割

Web フレームワークは、Web アプリケーション開発を効率化するためのツールセットです。HTTP リクエストの処理、ルーティング、レスポンスの生成など、Web 開発で頻繁に行う作業を簡単に実装できるよう設計されています。

フレームワークを使わない場合、Node.js の標準モジュールだけで Web サーバーを構築することも可能ですが、多くのボイラープレートコードを書く必要があります。Express のようなフレームワークを使うことで、開発者はビジネスロジックに集中できるのです。

Express の特徴と利点

Express は「Fast, unopinionated, minimalist web framework for Node.js」として開発されました。この説明に含まれる 3 つのキーワードが、Express の特徴を表しています。

#	特徴	説明
1	Fast（高速）	軽量で高速な動作を実現
2	Unopinionated（非独断的）	開発者に実装方法の自由度を提供
3	Minimalist（最小限）	必要最小限の機能でシンプルな設計

Express の主な利点は以下の通りです。

学習コストの低さ Express の API は直感的で理解しやすく、Node.js の基本的な知識があれば短時間で習得できます。

豊富なミドルウェア 認証、ログ出力、CORS 対応など、様々な機能を提供するミドルウェアが豊富に用意されています。

柔軟性の高さ 特定の設計パターンを強制せず、プロジェクトの要件に応じて自由に構成できます。

Node.js と Express の関係性

Node.js は JavaScript の実行環境であり、Express はその上で動作する Web フレームワークです。Node.js が提供するhttpモジュールを基盤として、Express はより使いやすい API を提供しています。

javascriptCopy code// Node.js 標準モジュールでのHTTPサーバー
const http = require('http');

const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('Hello World\n');
});

server.listen(3000);

上記のコードを Express で書き直すと、以下のようになります。

javascriptCopy code// Express を使った場合
const express = require('express');
const app = express();

app.get('/', (req, res) => {
  res.send('Hello World');
});

app.listen(3000);

Express を使うことで、コードがより簡潔で読みやすくなることがわかります。

開発環境のセットアップ

プロジェクト初期化

Express を使った API サーバー開発を始めるために、まずは新しいプロジェクトを作成しましょう。

bashCopy code# 新しいディレクトリを作成
mkdir express-api-server
cd express-api-server

# package.json を作成
yarn init -y

yarn init -yコマンドで、デフォルト設定で package.json ファイルが生成されます。このファイルは、プロジェクトの依存関係や設定を管理する重要なファイルです。

Express のインストール

Express とその他の必要なパッケージをインストールします。

bashCopy code# Express をインストール
yarn add express

# 開発用の依存関係をインストール
yarn add -D nodemon

nodemonは開発時にファイルの変更を監視し、自動的にサーバーを再起動してくれる便利なツールです。

package.json にスクリプトを追加して、開発を効率化しましょう。

jsonCopy code{
  "name": "express-api-server",
  "version": "1.0.0",
  "main": "index.js",
  "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js"
  },
  "dependencies": {
    "express": "^4.18.2"
  },
  "devDependencies": {
    "nodemon": "^3.0.1"
  }
}

基本的なフォルダ構成

効率的な開発のために、適切なフォルダ構成を作成します。以下の構成は、小規模から中規模の API プロジェクトに適しています。

bashCopy codeexpress-api-server/
├── index.js          # エントリーポイント
├── routes/           # ルーティング定義
│   ├── api.js
│   └── users.js
├── middleware/       # カスタムミドルウェア
│   └── auth.js
├── utils/           # ユーティリティ関数
│   └── helpers.js
├── package.json
└── README.md

必要なディレクトリを作成しましょう。

bashCopy code# ディレクトリを作成
mkdir routes middleware utils

# 基本ファイルを作成
touch index.js routes/api.js routes/users.js
touch middleware/auth.js utils/helpers.js

最初の API サーバー構築

Hello World API

最初のステップとして、シンプルな Hello World API を作成します。index.jsファイルに以下のコードを記述しましょう。

javascriptCopy code// Express モジュールを読み込み
const express = require('express');

// Express アプリケーションを作成
const app = express();

// ポート番号を設定（環境変数または3000番）
const PORT = process.env.PORT || 3000;

// ルートエンドポイント
app.get('/', (req, res) => {
  res.json({
    message: 'Hello World! Express API Server is running.',
    timestamp: new Date().toISOString(),
    version: '1.0.0',
  });
});

// サーバーを起動
app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
  console.log(`Visit: http://localhost:${PORT}`);
});

サーバーを起動してみましょう。

bashCopy code# 開発モードでサーバーを起動
yarn dev

ブラウザでhttp:​/​​/​localhost:3000にアクセスするか、curl コマンドで API を確認できます。

bashCopy code# curlでAPIをテスト
curl http://localhost:3000

ルーティングの基本

Express のルーティングは、特定のエンドポイント（URL パス）に対する HTTP リクエストに応答する仕組みです。基本的なルーティングの構文は以下の通りです。

javascriptCopy codeapp.METHOD(PATH, HANDLER);

• METHOD: HTTP メソッド（GET、POST、PUT、DELETE など）
• PATH: サーバー上のパス
• HANDLER: ルートがマッチした時に実行される関数

複数のルートを追加してみましょう。

javascriptCopy code// 既存のコードに追加

// 健康チェック用エンドポイント
app.get('/health', (req, res) => {
  res.json({
    status: 'OK',
    uptime: process.uptime(),
    timestamp: new Date().toISOString(),
  });
});

// API情報を返すエンドポイント
app.get('/api/info', (req, res) => {
  res.json({
    name: 'Express API Server',
    version: '1.0.0',
    description:
      'A simple API server built with Express.js',
    endpoints: ['GET /', 'GET /health', 'GET /api/info'],
  });
});

// 404エラーハンドリング（全てのルートの最後に配置）
app.use('*', (req, res) => {
  res.status(404).json({
    error: 'Not Found',
    message: `Route ${req.originalUrl} not found`,
    timestamp: new Date().toISOString(),
  });
});

レスポンス形式の設定

API サーバーでは、一貫したレスポンス形式を保つことが重要です。JSON 形式でのレスポンスが一般的で、Express ではres.json()メソッドを使用します。

javascriptCopy code// 成功レスポンスの例
app.get('/api/success', (req, res) => {
  res.json({
    success: true,
    data: {
      message: 'Operation completed successfully',
    },
    timestamp: new Date().toISOString(),
  });
});

// エラーレスポンスの例
app.get('/api/error', (req, res) => {
  res.status(400).json({
    success: false,
    error: {
      code: 'INVALID_REQUEST',
      message: 'Invalid request parameters',
    },
    timestamp: new Date().toISOString(),
  });
});

レスポンス形式を統一するためのヘルパー関数を作成することも有効です。

javascriptCopy code// utils/helpers.js
const createResponse = (success, data, error = null) => {
  return {
    success,
    data: success ? data : null,
    error: !success ? error : null,
    timestamp: new Date().toISOString(),
  };
};

module.exports = { createResponse };

RESTful API の実装

GET、POST、PUT、DELETE の実装

RESTful API では、HTTP メソッドを使い分けてリソースの操作を表現します。ユーザー管理を例に、CRUD（Create、Read、Update、Delete）操作を実装してみましょう。

まず、routes​/​users.jsファイルを作成します。

javascriptCopy code// routes/users.js
const express = require('express');
const router = express.Router();
const { createResponse } = require('../utils/helpers');

// ユーザーデータ（実際の開発ではデータベースを使用）
let users = [
  {
    id: 1,
    name: '田中太郎',
    email: 'tanaka@example.com',
    age: 28,
  },
  {
    id: 2,
    name: '佐藤花子',
    email: 'sato@example.com',
    age: 25,
  },
  {
    id: 3,
    name: '山田次郎',
    email: 'yamada@example.com',
    age: 32,
  },
];

// GET /api/users - 全ユーザー取得
router.get('/', (req, res) => {
  res.json(createResponse(true, users));
});

// GET /api/users/:id - 特定ユーザー取得
router.get('/:id', (req, res) => {
  const userId = parseInt(req.params.id);
  const user = users.find((u) => u.id === userId);

  if (!user) {
    return res.status(404).json(
      createResponse(false, null, {
        code: 'USER_NOT_FOUND',
        message: 'ユーザーが見つかりません',
      })
    );
  }

  res.json(createResponse(true, user));
});

// POST /api/users - 新規ユーザー作成
router.post('/', (req, res) => {
  const { name, email, age } = req.body;

  // バリデーション
  if (!name || !email || !age) {
    return res.status(400).json(
      createResponse(false, null, {
        code: 'VALIDATION_ERROR',
        message: 'name、email、age は必須項目です',
      })
    );
  }

  // 新しいユーザーを作成
  const newUser = {
    id: users.length + 1,
    name,
    email,
    age: parseInt(age),
  };

  users.push(newUser);

  res.status(201).json(createResponse(true, newUser));
});

// PUT /api/users/:id - ユーザー更新
router.put('/:id', (req, res) => {
  const userId = parseInt(req.params.id);
  const userIndex = users.findIndex((u) => u.id === userId);

  if (userIndex === -1) {
    return res.status(404).json(
      createResponse(false, null, {
        code: 'USER_NOT_FOUND',
        message: 'ユーザーが見つかりません',
      })
    );
  }

  const { name, email, age } = req.body;

  // ユーザー情報を更新
  users[userIndex] = {
    ...users[userIndex],
    ...(name && { name }),
    ...(email && { email }),
    ...(age && { age: parseInt(age) }),
  };

  res.json(createResponse(true, users[userIndex]));
});

// DELETE /api/users/:id - ユーザー削除
router.delete('/:id', (req, res) => {
  const userId = parseInt(req.params.id);
  const userIndex = users.findIndex((u) => u.id === userId);

  if (userIndex === -1) {
    return res.status(404).json(
      createResponse(false, null, {
        code: 'USER_NOT_FOUND',
        message: 'ユーザーが見つかりません',
      })
    );
  }

  const deletedUser = users.splice(userIndex, 1)[0];

  res.json(
    createResponse(true, {
      message: 'ユーザーが削除されました',
      deletedUser,
    })
  );
});

module.exports = router;

リクエスト・レスポンスの処理

Express では、リクエストオブジェクト（req）とレスポンスオブジェクト（res）を通じて、HTTP 通信を処理します。

リクエストオブジェクトの主要プロパティ

#	プロパティ	説明	例
1	req.params	URL パラメータ	/users/ の
2	req.query	クエリパラメータ	?page=1&limit=10
3	req.body	リクエストボディ	POST データ
4	req.headers	HTTP ヘッダー	Content-Type など

レスポンスオブジェクトの主要メソッド

#	メソッド	説明	例
1	res.json()	JSON レスポンス	res.json({data: 'value'})
2	res.status()	ステータスコード設定	res.status(404)
3	res.send()	テキストレスポンス	res.send('Hello')
4	res.redirect()	リダイレクト	res.redirect('/login')

JSON データの扱い方

Express で JSON データを扱うには、express.json()ミドルウェアを使用します。index.jsを更新しましょう。

javascriptCopy code// index.js を更新
const express = require('express');
const usersRouter = require('./routes/users');

const app = express();
const PORT = process.env.PORT || 3000;

// JSON パースミドルウェア
app.use(express.json());

// URL エンコードされたデータのパース
app.use(express.urlencoded({ extended: true }));

// ルーターを使用
app.use('/api/users', usersRouter);

// 既存のルート
app.get('/', (req, res) => {
  res.json({
    message: 'Hello World! Express API Server is running.',
    timestamp: new Date().toISOString(),
    version: '1.0.0',
  });
});

app.get('/health', (req, res) => {
  res.json({
    status: 'OK',
    uptime: process.uptime(),
    timestamp: new Date().toISOString(),
  });
});

// 404エラーハンドリング
app.use('*', (req, res) => {
  res.status(404).json({
    error: 'Not Found',
    message: `Route ${req.originalUrl} not found`,
    timestamp: new Date().toISOString(),
  });
});

app.listen(PORT, () => {
  console.log(`Server is running on port ${PORT}`);
  console.log(`Visit: http://localhost:${PORT}`);
});

API をテストしてみましょう。

bashCopy code# 全ユーザー取得
curl http://localhost:3000/api/users

# 特定ユーザー取得
curl http://localhost:3000/api/users/1

# 新規ユーザー作成
curl -X POST http://localhost:3000/api/users \
  -H "Content-Type: application/json" \
  -d '{"name":"新井三郎","email":"arai@example.com","age":30}'

# ユーザー更新
curl -X PUT http://localhost:3000/api/users/1 \
  -H "Content-Type: application/json" \
  -d '{"age":29}'

# ユーザー削除
curl -X DELETE http://localhost:3000/api/users/3

ミドルウェアの活用

ミドルウェアの概念

ミドルウェアは、リクエストとレスポンスの間で実行される関数です。リクエストの前処理、レスポンスの後処理、認証、ログ出力など、様々な用途で使用されます。

Express のミドルウェアは以下の特徴を持ちます。

実行順序 ミドルウェアは定義された順序で実行されます。

next() 関数 次のミドルウェアに制御を渡すために使用します。

リクエスト・レスポンスオブジェクトへのアクセス リクエストやレスポンスオブジェクトを変更できます。

javascriptCopy code// ミドルウェアの基本構造
const myMiddleware = (req, res, next) => {
  // 前処理
  console.log('ミドルウェアが実行されました');

  // 次のミドルウェアまたはルートハンドラーに制御を渡す
  next();
};

よく使われるミドルウェア

Express エコシステムには、多くの便利なミドルウェアが存在します。代表的なものを紹介しましょう。

bashCopy code# よく使われるミドルウェアをインストール
yarn add cors helmet morgan compression

各ミドルウェアを設定してみましょう。

javascriptCopy code// index.js にミドルウェアを追加
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
const compression = require('compression');

const usersRouter = require('./routes/users');

const app = express();
const PORT = process.env.PORT || 3000;

// セキュリティヘッダーを設定
app.use(helmet());

// CORS を有効化
app.use(cors());

// レスポンス圧縮
app.use(compression());

// リクエストログ出力
app.use(morgan('combined'));

// JSON パースミドルウェア
app.use(express.json());
app.use(express.urlencoded({ extended: true }));

// カスタムミドルウェア（リクエスト時間計測）
app.use((req, res, next) => {
  req.startTime = Date.now();
  next();
});

// レスポンス時間をヘッダーに追加
app.use((req, res, next) => {
  res.on('finish', () => {
    const duration = Date.now() - req.startTime;
    console.log(
      `${req.method} ${req.originalUrl} - ${duration}ms`
    );
  });
  next();
});

// ルーターを使用
app.use('/api/users', usersRouter);

// 既存のルート...

カスタムミドルウェアの作成

プロジェクト固有の要件に対応するため、カスタムミドルウェアを作成することも重要です。

認証ミドルウェアを作成してみましょう。

javascriptCopy code// middleware/auth.js
const authenticateToken = (req, res, next) => {
  const authHeader = req.headers['authorization'];
  const token = authHeader && authHeader.split(' ')[1]; // Bearer TOKEN

  if (!token) {
    return res.status(401).json({
      success: false,
      error: {
        code: 'NO_TOKEN',
        message: 'アクセストークンが必要です',
      },
      timestamp: new Date().toISOString(),
    });
  }

  // 実際の開発では JWT の検証を行う
  if (token !== 'valid-token') {
    return res.status(403).json({
      success: false,
      error: {
        code: 'INVALID_TOKEN',
        message: '無効なトークンです',
      },
      timestamp: new Date().toISOString(),
    });
  }

  // ユーザー情報をリクエストオブジェクトに追加
  req.user = {
    id: 1,
    name: '認証済みユーザー',
    role: 'user',
  };

  next();
};

// 管理者権限チェックミドルウェア
const requireAdmin = (req, res, next) => {
  if (!req.user || req.user.role !== 'admin') {
    return res.status(403).json({
      success: false,
      error: {
        code: 'INSUFFICIENT_PERMISSIONS',
        message: '管理者権限が必要です',
      },
      timestamp: new Date().toISOString(),
    });
  }

  next();
};

module.exports = { authenticateToken, requireAdmin };

リクエストバリデーションミドルウェアも作成しましょう。

javascriptCopy code// middleware/validation.js
const validateUserInput = (req, res, next) => {
  const { name, email, age } = req.body;
  const errors = [];

  // 名前のバリデーション
  if (
    !name ||
    typeof name !== 'string' ||
    name.trim().length < 2
  ) {
    errors.push('名前は2文字以上で入力してください');
  }

  // メールアドレスのバリデーション
  const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
  if (!email || !emailRegex.test(email)) {
    errors.push('有効なメールアドレスを入力してください');
  }

  // 年齢のバリデーション
  if (!age || isNaN(age) || age < 0 || age > 120) {
    errors.push('年齢は0から120の間で入力してください');
  }

  if (errors.length > 0) {
    return res.status(400).json({
      success: false,
      error: {
        code: 'VALIDATION_ERROR',
        message: 'バリデーションエラーが発生しました',
        details: errors,
      },
      timestamp: new Date().toISOString(),
    });
  }

  next();
};

module.exports = { validateUserInput };

作成したミドルウェアを使用してみましょう。

javascriptCopy code// routes/users.js を更新
const express = require('express');
const router = express.Router();
const { createResponse } = require('../utils/helpers');
const { authenticateToken } = require('../middleware/auth');
const {
  validateUserInput,
} = require('../middleware/validation');

// 既存のユーザーデータ...

// 保護されたルート例
router.get('/profile', authenticateToken, (req, res) => {
  res.json(
    createResponse(true, {
      message: 'プロフィール情報',
      user: req.user,
    })
  );
});

// バリデーション付きユーザー作成
router.post('/', validateUserInput, (req, res) => {
  // バリデーションを通過した場合のみ実行される
  const { name, email, age } = req.body;

  const newUser = {
    id: users.length + 1,
    name: name.trim(),
    email: email.toLowerCase(),
    age: parseInt(age),
  };

  users.push(newUser);

  res.status(201).json(createResponse(true, newUser));
});

// 既存のルート...

module.exports = router;

エラーハンドリング

エラー処理の基本

適切なエラーハンドリングは、信頼性の高い API サーバーを構築するために不可欠です。Express では、同期エラーと非同期エラーの両方を適切に処理する必要があります。

同期エラーの処理 Express は同期エラーを自動的にキャッチします。

javascriptCopy codeapp.get('/sync-error', (req, res) => {
  // このエラーは Express が自動的にキャッチする
  throw new Error('同期エラーが発生しました');
});

非同期エラーの処理 非同期エラーは明示的にnext()関数に渡す必要があります。

javascriptCopy codeapp.get('/async-error', async (req, res, next) => {
  try {
    // 非同期処理
    await someAsyncOperation();
    res.json({ success: true });
  } catch (error) {
    // エラーを next() に渡す
    next(error);
  }
});

HTTP ステータスコードの使い分け

適切な HTTP ステータスコードを使用することで、クライアントがエラーの性質を理解しやすくなります。

#	ステータスコード	説明	使用例
1	200 OK	成功	データ取得成功
2	201 Created	作成成功	ユーザー作成成功
3	400 Bad Request	リクエストエラー	バリデーションエラー
4	401 Unauthorized	認証エラー	ログインが必要
5	403 Forbidden	認可エラー	権限不足
6	404 Not Found	リソース未発見	ユーザーが存在しない
7	500 Internal Server Error	サーバーエラー	予期しないエラー

カスタムエラークラスを作成して、エラー処理を整理しましょう。

javascriptCopy code// utils/errors.js
class AppError extends Error {
  constructor(message, statusCode, code = null) {
    super(message);
    this.statusCode = statusCode;
    this.code = code;
    this.isOperational = true; // 運用上のエラーかどうか

    Error.captureStackTrace(this, this.constructor);
  }
}

class ValidationError extends AppError {
  constructor(message, details = []) {
    super(message, 400, 'VALIDATION_ERROR');
    this.details = details;
  }
}

class NotFoundError extends AppError {
  constructor(resource = 'リソース') {
    super(`${resource}が見つかりません`, 404, 'NOT_FOUND');
  }
}

class UnauthorizedError extends AppError {
  constructor(message = '認証が必要です') {
    super(message, 401, 'UNAUTHORIZED');
  }
}

class ForbiddenError extends AppError {
  constructor(message = '権限が不足しています') {
    super(message, 403, 'FORBIDDEN');
  }
}

module.exports = {
  AppError,
  ValidationError,
  NotFoundError,
  UnauthorizedError,
  ForbiddenError,
};

グローバルエラーハンドラー

全てのエラーを一元的に処理するグローバルエラーハンドラーを作成します。

javascriptCopy code// middleware/errorHandler.js
const { AppError } = require('../utils/errors');

const errorHandler = (err, req, res, next) => {
  let error = { ...err };
  error.message = err.message;

  // ログ出力（本番環境では適切なロガーを使用）
  console.error('エラーが発生しました:', {
    message: err.message,
    stack: err.stack,
    url: req.originalUrl,
    method: req.method,
    timestamp: new Date().toISOString(),
  });

  // MongoDB のCastError（無効なObjectId）
  if (err.name === 'CastError') {
    const message = '無効なリソースIDです';
    error = new AppError(message, 400, 'INVALID_ID');
  }

  // MongoDB の重複キーエラー
  if (err.code === 11000) {
    const message = '重複するデータが存在します';
    error = new AppError(message, 400, 'DUPLICATE_FIELD');
  }

  // バリデーションエラー
  if (err.name === 'ValidationError') {
    const message = 'バリデーションエラーが発生しました';
    const details = Object.values(err.errors).map(
      (val) => val.message
    );
    error = new ValidationError(message, details);
  }

  // レスポンス送信
  res.status(error.statusCode || 500).json({
    success: false,
    error: {
      code: error.code || 'INTERNAL_SERVER_ERROR',
      message:
        error.message || 'サーバー内部エラーが発生しました',
      ...(error.details && { details: error.details }),
    },
    timestamp: new Date().toISOString(),
    // 開発環境でのみスタックトレースを含める
    ...(process.env.NODE_ENV === 'development' && {
      stack: err.stack,
    }),
  });
};

// 存在しないルートのハンドリング
const notFound = (req, res, next) => {
  const error = new AppError(
    `Route ${req.originalUrl} not found`,
    404,
    'ROUTE_NOT_FOUND'
  );
  next(error);
};

module.exports = { errorHandler, notFound };

非同期エラーを簡単に処理するためのヘルパー関数も作成しましょう。

javascriptCopy code// utils/asyncHandler.js
const asyncHandler = (fn) => (req, res, next) => {
  Promise.resolve(fn(req, res, next)).catch(next);
};

module.exports = asyncHandler;

最終的なindex.jsを更新して、エラーハンドリングを統合します。

javascriptCopy code// index.js 最終版
const express = require('express');
const cors = require('cors');
const helmet = require('helmet');
const morgan = require('morgan');
const compression = require('compression');

const usersRouter = require('./routes/users');
const {
  errorHandler,
  notFound,
} = require('./middleware/errorHandler');

const app = express();
const PORT = process.env.PORT || 3000;

// セキュリティとパフォーマンス関連のミドルウェア
app.use(helmet());
app.use(cors());
app.use(compression());

// ログ出力
if (process.env.NODE_ENV !== 'test') {
  app.use(morgan('combined'));
}

// リクエスト解析
app.use(express.json({ limit: '10mb' }));
app.use(express.urlencoded({ extended: true }));

// カスタムミドルウェア
app.use((req, res, next) => {
  req.startTime = Date.now();
  next();
});

// ルート
app.get('/', (req, res) => {
  res.json({
    message: 'Express API Server is running!',
    version: '1.0.0',
    timestamp: new Date().toISOString(),
    uptime: process.uptime(),
  });
});

app.get('/health', (req, res) => {
  res.json({
    status: 'OK',
    uptime: process.uptime(),
    timestamp: new Date().toISOString(),
    memory: process.memoryUsage(),
  });
});

// API ルート
app.use('/api/users', usersRouter);

// 404エラーハンドリング
app.use(notFound);

// グローバルエラーハンドラー
app.use(errorHandler);

// サーバー起動
app.listen(PORT, () => {
  console.log(`🚀 Server is running on port ${PORT}`);
  console.log(`📍 Visit: http://localhost:${PORT}`);
  console.log(
    `🏥 Health check: http://localhost:${PORT}/health`
  );
  console.log(
    `👥 Users API: http://localhost:${PORT}/api/users`
  );
});

まとめ

本記事では、Express を使った API サーバーの基本的な構築方法から、実践的な機能実装まで段階的に学んできました。

習得した主要な技術

Express の基本概念と Node.js との関係性を理解し、効率的な Web 開発の基盤を築くことができました。プロジェクトの初期化からパッケージ管理まで、開発環境の適切なセットアップ方法も身につきました。

RESTful API の設計原則に基づいて、CRUD 操作を実装する方法を学びました。HTTP メソッドの使い分けや、適切なレスポンス形式の設計も重要なポイントでした。

ミドルウェアの活用

Express の強力な機能であるミドルウェアシステムを活用することで、認証、バリデーション、ログ出力などの横断的な関心事を効率的に処理できるようになりました。

エラーハンドリングの重要性も理解し、グローバルエラーハンドラーを使った一元的なエラー処理の実装方法を学びました。適切な HTTP ステータスコードの使用により、クライアントとの円滑なコミュニケーションが可能になります。

今後の学習方向性

本記事で学んだ基礎知識を基に、データベース連携、認証システムの本格実装、テスト駆動開発などに挑戦していくことをお勧めします。Express エコシステムの豊富なミドルウェアやツールを活用することで、より高度な API サーバーを構築できるでしょう。

実際のプロジェクトでは、セキュリティ対策、パフォーマンス最適化、ログ管理なども重要な要素となります。継続的な学習を通じて、実用的な API サーバー開発のスキルを向上させていきましょう。

関連リンク

• Express.js 公式サイト
• Express.js 公式ドキュメント
• Node.js 公式サイト
• MDN Web Docs - HTTP
• REST API Design Guide
• HTTP Status Codes
• Yarn 公式サイト
• Express Middleware List