【基礎から学ぶ】Node.js入門！JavaScriptでサーバーサイド開発

By /

はい、承知いたしました。【基礎から学ぶ】Node.js入門！JavaScriptでサーバーサイド開発 の詳細な説明を含む約5000語の記事を直接表示します。

【基礎から学ぶ】Node.js入門！JavaScriptでサーバーサイド開発

はじめに：サーバーサイドJavaScriptの世界へようこそ

Web開発の世界は日々進化しており、特にフロントエンドではJavaScriptが必須の技術となっています。しかし、JavaScriptの活躍の場はもうブラウザの中だけではありません。Node.jsの登場により、JavaScriptを使ってサーバーサイドアプリケーション、コマンドラインツール、デスクトップアプリケーションなど、あらゆるものが開発できるようになりました。

このNode.jsを学ぶことで、これまでフロントエンド開発しか経験がなかった方も、同じ言語を使ってサーバーサイドのロジックやデータベース連携を実装できるようになります。これにより、学習コストを抑えつつ、Webアプリケーション全体の開発（フルスタック開発）に挑戦することが可能になります。

本記事では、Node.jsを使ったサーバーサイド開発の基本を、JavaScriptの基礎知識がある方を対象に、丁寧に解説していきます。Node.jsのインストール方法から始まり、その特徴、基本的な使い方、HTTPサーバーの構築、そしてデファクトスタンダードとなっているフレームワーク「Express」を使った開発までを網羅します。

Node.jsはなぜ高いパフォーマンスを発揮できるのか？ イベントループとは？ 非同期処理の肝は？ といった、Node.jsの根幹をなす重要な概念についても詳しく解説します。

さあ、JavaScriptでサーバーサイド開発を行う新たな扉を開きましょう。

Node.jsとは何か？

Node.jsを一言で説明すると、「サーバーサイドでJavaScriptを実行するための実行環境」です。

元々JavaScriptはWebブラウザの中で動くために作られた言語でした。しかし、Node.jsはGoogle Chromeに搭載されている高性能なJavaScriptエンジンである「V8エンジン」をブラウザの外に持ち出すことで、JavaScriptを汎用的なプログラミング言語として利用できるようにしました。

Node.jsの最も重要な特徴は以下の3点です。

  1. V8エンジンによる高速な実行: Google Chromeのために開発されたV8エンジンは、JavaScriptコードを機械語に直接コンパイルするため、非常に高速に動作します。
  2. イベント駆動・ノンブロッキングI/O: Node.jsは基本的にイベント駆動型のアーキテクチャを採用しており、I/O（ファイル読み書き、ネットワーク通信、データベースアクセスなど）処理をノンブロッキングで行います。これにより、多数の同時接続リクエストを効率的に処理できます。これは、後ほど詳しく解説する「イベントループ」という仕組みによって実現されています。
  3. npm (Node Package Manager): 世界最大のソフトウェアレジストリであるnpmを通じて、膨大な数のオープンソースライブラリ（パッケージ）を簡単に入手・利用できます。これにより、様々な機能の開発を効率的に進めることができます。

これらの特徴から、Node.jsはリアルタイムアプリケーション（チャットなど）、シングルページアプリケーションのバックエンドAPI、マイクロサービス、コマンドラインツールなど、幅広い用途で利用されています。

Node.jsのインストール

Node.jsを使った開発を始めるには、まずNode.js実行環境をコンピューターにインストールする必要があります。公式ウェブサイトからインストーラーをダウンロードする方法と、バージョン管理ツールを使う方法があります。初心者には、複数のプロジェクトで異なるNode.jsバージョンが必要になる可能性も考慮し、NVM (Node Version Manager) の利用を強く推奨します。

1. NVM (Node Version Manager) を使ったインストール（推奨）

NVMは、複数のNode.jsバージョンを簡単にインストール、切り替え、管理できるツールです。

  • macOS / Linux:
    ターミナルを開き、以下のコマンドを実行します。

    bash
    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
    または wget を使用する場合:
    bash
    wget -qO- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash

    インストールスクリプトは、~/.bash_profile, ~/.zshrc, ~/.profile のいずれかにNVMの設定を追加します。スクリプトの実行後にターミナルを再起動するか、以下のコマンドを実行して設定を反映させてください。

    bash
    source ~/.bash_profile # または ~/.zshrc など、設定が追加されたファイル

    NVMがインストールされたら、以下のコマンドでNode.jsの最新安定版 (LTS – Long Term Support) をインストールします。

    bash
    nvm install --lts

    特定バージョンを指定してインストールすることも可能です。

    bash
    nvm install 18.18.0 # 例: v18.18.0をインストール

    インストール済みのバージョンを確認するには:

    bash
    nvm ls

    使用するバージョンを切り替えるには:

    bash
    nvm use <バージョン番号> # 例: nvm use 18.18.0

    プロジェクトごとに .nvmrc ファイルを作成し、使用するバージョンを記述しておくと、そのディレクトリで nvm use を実行したときに自動的に指定されたバージョンに切り替わるようになります。

  • Windows:
    Windowsでは、nvm-windows という別のプロジェクトが提供されています。GitHubリリースページからインストーラー (.zipファイル) をダウンロードし、指示に従ってインストールしてください。

    インストール後、コマンドプロンプトやPowerShellで以下のコマンドが使えるようになります。

    bash
    nvm install latest # 最新版をインストール
    nvm install lts # 最新LTS版をインストール
    nvm list # インストール済みバージョン一覧
    nvm use <バージョン番号> # 使用バージョン切り替え

2. 公式インストーラーを使ったインストール

NVMを使わず、単一のNode.jsバージョンだけをインストールしたい場合は、Node.js公式ウェブサイト (https://nodejs.org/) からお使いのOS用のインストーラーをダウンロードして実行します。LTS版と最新版がありますが、通常はLTS版を選択するのが推奨されます。

インストール確認

インストールが完了したら、ターミナルまたはコマンドプロンプトで以下のコマンドを実行し、Node.jsとnpm（Node.jsに付属するパッケージマネージャー）のバージョンが表示されることを確認してください。

bash
node -v
npm -v

バージョンが表示されれば、Node.js環境の準備は完了です。

Node.jsの基本

インストールが完了したところで、Node.jsの基本的な使い方を見ていきましょう。

1. REPL (Read-Eval-Print Loop) の使い方

Node.jsには対話型の実行環境であるREPLが付属しています。簡単なJavaScriptコードの動作確認や、Node.jsの組み込み機能を試すのに便利です。

ターミナルで node と入力してEnterを押すとREPLが起動します。

“`bash
$ node

console.log(‘Hello, Node.js!’);
Hello, Node.js!
undefined
1 + 10
11
let name = ‘Alice’;
undefined
name
‘Alice’
.help # ヘルプ表示
.exit # REPL終了
“`

REPLでは、入力したJavaScriptコードが即座に評価され、結果が表示されます。変数定義なども可能です。終了するには .exit コマンドを入力するか、Ctrl+Cを2回押します。

2. シンプルなJavaScriptファイルの実行

通常、Node.jsはJavaScriptファイルを指定して実行します。
例えば、以下のような内容の hello.js ファイルを作成します。

javascript
// hello.js
console.log('Hello from file!');

ターミナルでこのファイルがあるディレクトリに移動し、以下のコマンドを実行します。

bash
node hello.js

実行結果:
Hello from file!

このように、node コマンドの後にファイル名を指定することで、Node.jsがそのファイル内のJavaScriptコードを実行します。

3. モジュールシステム

Node.jsの重要な概念の一つがモジュールシステムです。Node.jsでは、機能をモジュールとして分割し、必要なモジュールを読み込んで利用します。これにより、コードの再利用性や保守性が高まります。

Node.jsでは、歴史的にCommonJSというモジュールシステムが使われてきましたが、近年ではブラウザでも標準となっているES Modulesもサポートされています。

  • CommonJS (require と module.exports)
    Node.jsの初期から使われているモジュールシステムです。

    モジュールを公開（エクスポート）するには module.exports を使います。

    ``javascript
    // myModule.js
    function greet(name) {
    return    Hello, ${name}!`;
    }

    const version = ‘1.0.0’;

    module.exports = {
    greet: greet,
    version: version
    };
    // またはショートハンドで module.exports = { greet, version };
    “`

    他のファイルでこのモジュールを利用（インポート）するには require を使います。

    “`javascript
    // app.js
    const myModule = require(‘./myModule’); // ファイルパスを指定

    console.log(myModule.greet(‘Bob’));
    console.log(Module version: ${myModule.version});
    “`

    組み込みモジュールやnpmでインストールしたパッケージも require で読み込みますが、ファイルパスではなくモジュール名（パッケージ名）を指定します。

    javascript
    const fs = require('fs'); // 組み込みモジュール
    const express = require('express'); // npmでインストールしたパッケージ

  • ES Modules (import と export)
    ECMAScriptの標準として定められたモジュールシステムです。Node.jsではv12以降でサポートされ、v14以降で安定版となりました。デフォルトではCommonJSが使われますが、package.json ファイルに "type": "module" を追加するか、.mjs という拡張子を使用することでES Modulesを使うことができます。

    モジュールを公開（エクスポート）するには export を使います。

    ``javascript
    // myModule.mjs または package.json に "type": "module" がある場合の myModule.js
    export function greet(name) {
    return    Hello, ${name}!`;
    }

    export const version = ‘1.0.0’;

    // デフォルトエクスポートも可能
    // export default class MyClass { … }
    “`

    他のファイルでモジュールを利用（インポート）するには import を使います。

    “`javascript
    // app.mjs または package.json に “type”: “module” がある場合の app.js
    import { greet, version } from ‘./myModule.js’; // 拡張子が必要な場合がある

    console.log(greet(‘Charlie’));
    console.log(Module version: ${version});

    // デフォルトエクスポートのインポート
    // import MyClass from ‘./myModule.js’;
    “`

    組み込みモジュールやnpmパッケージも import で読み込めます。

    javascript
    import fs from 'fs'; // 組み込みモジュール
    import express from 'express'; // npmパッケージ

    CommonJSとES Modulesは混在させることが可能ですが、少し複雑になるため、プロジェクト内ではどちらか一方に統一するのが望ましいです。新しいプロジェクトではES Modulesを採用するケースが増えています。

4. 組み込みモジュール

Node.jsには、ファイルシステム操作、ネットワーク通信、パス解決など、基本的な機能を提供する多数の組み込みモジュールが用意されています。これらはNode.jsのインストール時に含まれており、追加インストールなしで利用できます。

よく使われる組み込みモジュール:

  • http: HTTPサーバーやクライアントを構築するための機能。
  • https: HTTPSサーバーやクライアントを構築するための機能。
  • fs: ファイルシステム（ファイルやディレクトリ）を操作するための機能。
  • path: ファイルやディレクトリのパスを操作するための機能。
  • os: オペレーティングシステム関連の情報や機能。
  • events: イベントエミッターを扱うための機能。
  • stream: ストリームデータを扱うための機能。

例：fs モジュールを使ったファイルの読み込み

“`javascript
const fs = require(‘fs’); // CommonJSの場合
// import fs from ‘fs’; // ES Modulesの場合

fs.readFile(‘example.txt’, ‘utf8’, (err, data) => {
if (err) {
console.error(‘ファイルの読み込み中にエラーが発生しました:’, err);
return;
}
console.log(‘ファイル内容:’, data);
});

console.log(‘ファイル読み込みをリクエストしました。’); // こちらが先に実行される
“`

上記の例では、fs.readFile は非同期関数です。ファイル読み込みが完了するのを待たずに次の行が実行されるため、「ファイル読み込みをリクエストしました。」というメッセージが先に表示されます。読み込み完了後、コールバック関数が実行され、ファイルの内容が表示されます。Node.jsではこのように非同期処理が多用されます。

5. npm (Node Package Manager)

npmはNode.jsのパッケージマネージャーであり、世界中の開発者が作成した便利なライブラリ（パッケージ）を共有・利用するための仕組みです。Node.jsをインストールするとnpmも一緒にインストールされます。

  • package.json ファイル:
    npmを使った開発において中心となるのが package.json ファイルです。プロジェクトのメタデータ（名前、バージョン、説明など）や、依存しているパッケージの情報、実行可能なスクリプトなどを管理します。

    プロジェクトのルートディレクトリで以下のコマンドを実行すると、対話形式で package.json ファイルを生成できます。

    bash
    npm init

    または、デフォルト設定で素早く生成するには以下のコマンドを使います。

    bash
    npm init -y

    生成された package.json の例:

    json
    {
    "name": "my-node-project",
    "version": "1.0.0",
    "description": "",
    "main": "index.js", // エントリーポイントとなるファイル
    "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "node index.js" // npm start で index.js が実行される
    },
    "keywords": [],
    "author": "",
    "license": "ISC",
    "dependencies": {
    // プロジェクトの実行に必要なパッケージ
    },
    "devDependencies": {
    // 開発・テストに必要なパッケージ
    }
    }

  • 依存関係の管理 (npm install)
    プロジェクトで外部パッケージを利用するには、npm install コマンドを使います。

    例えば、WebアプリケーションフレームワークであるExpressをインストールする場合:

    bash
    npm install express

    このコマンドを実行すると、express パッケージがダウンロードされ、プロジェクトルートに node_modules ディレクトリが作成されてそこに保存されます。同時に、package.json の dependencies フィールドに Express が追加されます。

    開発時のみ必要なパッケージ（テストフレームワーク、コード整形ツールなど）は、--save-dev オプションを付けてインストールします。これにより、devDependencies フィールドに追加されます。

    “`bash
    npm install jest –save-dev

    またはショートハンド

    npm install jest -D
    “`

    package.json が存在するプロジェクトで npm install とだけ実行すると、package.json に記述されているすべての依存パッケージがインストールされます。プロジェクトを他の開発者と共有する際に、node_modules ディレクトリを含めずに package.json だけを共有し、受け取った側が npm install で必要なパッケージをインストールするというのが一般的なワークフローです。

    npm install 実行時には、インストールされたパッケージとその依存関係の正確なバージョン情報を記録した package-lock.json ファイルも生成されます。これにより、他の環境で同じコマンドを実行した際に、全く同じバージョンのパッケージ構成を再現できるようになります。

  • スクリプトの実行 (npm run)
    package.json の scripts フィールドに定義したコマンドは、npm run <スクリプト名> で実行できます。

    例えば、package.json に以下のスクリプトがある場合:

    json
    "scripts": {
    "start": "node index.js",
    "dev": "nodemon index.js", // nodemonはファイルの変更を監視して自動再起動するツール
    "test": "jest"
    }

    それぞれのスクリプトは以下のように実行します。

    bash
    npm start # index.js を実行（startは run なしで実行できる特殊なスクリプト）
    npm run dev # nodemon index.js を実行
    npm run test # jest を実行

    scripts を使うことで、複雑なコマンドを短い名前で実行したり、開発ワークフローを標準化したりできます。

Node.jsの心臓部：イベント駆動とノンブロッキングI/O

Node.jsが多数の同時接続を効率的に処理できる秘訣は、「イベント駆動」と「ノンブロッキングI/O」、そしてそれを支える「イベントループ」という仕組みにあります。

ブロッキングI/O vs ノンブロッキングI/O

まずは、I/O処理における「ブロッキング」と「ノンブロッキング」の違いを理解しましょう。

  • ブロッキングI/O:
    あるI/O処理（例: ファイル読み込み、ネットワークリクエスト送信）を開始した場合、その処理が完了するまでプログラムの実行が停止（ブロック）されます。処理結果（読み込んだデータやレスポンス）が返ってくるまで、他の処理に進めません。
    マルチスレッドの場合、I/O処理中に他のスレッドが別の処理を行うことができますが、一つのリクエスト内で見ると、I/O待ちの間はリソースが無駄になります。

    例:
    1. ファイルAを読み込む (時間がかかる)
    2. ファイルAの読み込みが完了するまで待つ
    3. ファイルAの内容を使って処理を行う
    4. ファイルBを読み込む (時間がかかる)
    5. ファイルBの読み込みが完了するまで待つ
    6. ファイルBの内容を使って処理を行う

    この間、CPUはほとんど何もしていません。

  • ノンブロッキングI/O:
    あるI/O処理を開始した場合、プログラムはすぐに次の処理に進みます。I/O処理の完了は待たずに、「完了したら教えてね」とだけ伝えておきます。I/O処理がバックグラウンドで実行され、完了した際にその結果が通知されます（イベント発生やコールバック実行など）。

    例:
    1. ファイルAの読み込みをリクエストする
    2. すぐに次の処理に進む
    3. ファイルBの読み込みをリクエストする
    4. すぐに次の処理に進む
    5. 他の処理を行う…
    6. ファイルAの読み込み完了通知が来る
    7. ファイルAの内容を使って処理を行う
    8. ファイルBの読み込み完了通知が来る
    9. ファイルBの内容を使って処理を行う

    Node.jsは基本的にノンブロッキングI/Oを採用しているため、I/O待ちの時間に他のリクエストを処理したり、別のタスクを実行したりできます。これにより、シングルスレッドでも多数の同時接続を効率的に捌くことが可能になります。

イベントループ

Node.jsのノンブロッキングI/Oを可能にしているのがイベントループという仕組みです。Node.jsはシングルスレッドで動作しますが、このイベントループによって非同期処理を管理し、効率的な並行処理を実現しています。

イベントループのイメージ:

  1. タスクキュー (Callback Queue): I/O処理などの非同期処理が完了すると、その完了通知（イベント）と、実行すべき処理（コールバック関数）がタスクキューに追加されます。
  2. イベントループ: Node.jsのコア部分であり、常にタスクキューを監視しています。
  3. コールスタック: 現在実行中のJavaScriptコードの呼び出しスタックです。同期的な関数呼び出しなどがここで行われます。

イベントループは、コールスタックが空になったら（つまり、現在実行中の同期的な処理が全て終わったら）、タスクキューの中から待機しているコールバック関数を取り出し、コールスタックに乗せて実行します。

これにより、時間がかかるI/O処理がメインスレッド（イベントループが動作しているスレッド）をブロックすることなく、完了した順にコールバックが実行されるという仕組みになっています。

例:

“`javascript
console.log(‘Start’); // 同期処理

fs.readFile(‘file1.txt’, (err, data) => {
console.log(‘File 1 read complete’); // 非同期処理完了後のコールバック
});

fs.readFile(‘file2.txt’, (err, data) => {
console.log(‘File 2 read complete’); // 非同期処理完了後のコールバック
});

console.log(‘End’); // 同期処理
“`

実行順序:

  1. 'Start' が出力される。（コールスタックに乗る）
  2. fs.readFile('file1.txt', ...) が実行される。（コールスタックに乗るが、I/O処理はバックグラウンドへ。コールバック関数はタスクキュー行きを待つ）
  3. fs.readFile('file2.txt', ...) が実行される。（同様にバックグラウンドへ）
  4. 'End' が出力される。（コールスタックに乗る）
  5. コールスタックが空になる。
  6. イベントループがタスクキューを見る。
  7. file1.txt の読み込みが完了していれば、そのコールバック関数がタスクキューから取り出され、コールスタックに乗って実行される -> 'File 1 read complete' が出力。
  8. 再びコールスタックが空になる。
  9. イベントループがタスクキューを見る。
  10. file2.txt の読み込みが完了していれば、そのコールバック関数がタスクキューから取り出され、コールスタックに乗って実行される -> 'File 2 read complete' が出力。

このように、'End' はファイル読み込み完了メッセージよりも先に表示されます。これは、fs.readFile がノンブロッキングであり、コールバックがイベントループによって後から実行されるためです。

非同期処理のパターン：コールバック、Promise, async/await

Node.jsでは非同期処理が基本ですが、その記述方法は時代と共に進化してきました。

  • コールバック:
    最も基本的な非同期処理のパターンです。非同期関数の最後の引数として、処理完了後に実行される関数（コールバック関数）を渡します。エラーが発生した場合、コールバック関数の第一引数にエラーオブジェクトを渡すのがNode.jsの慣習です ((err, data) => { ... })。

    javascript
    fs.readFile('file.txt', 'utf8', (err, data) => {
    if (err) {
    console.error(err);
    return;
    }
    console.log(data);
    });

    複数の非同期処理を順番に実行する場合、コールバックの中にさらにコールバックを書くという形で記述することになり、「コールバック地獄（Callback Hell）」と呼ばれる可読性・保守性の低いコードになりがちでした。

  • Promise:
    コールバック地獄を解決するために登場したのがPromiseです。非同期処理の結果を表現するオブジェクトで、「成功」または「失敗」のいずれかの状態を取ります。

    Node.jsの組み込みモジュールには、Promiseを返すバージョンが require('fs').promises のように提供されています。

    “`javascript
    const fsPromises = require(‘fs’).promises; // Promise版のfsモジュール

    fsPromises.readFile(‘file.txt’, ‘utf8’)
    .then((data) => {
    console.log(data);
    })
    .catch((err) => {
    console.error(err);
    });
    “`

    Promiseを使うと、.then() で成功時の処理、.catch() で失敗時の処理をチェーンのように繋げて書くことができます。これにより、コールバック地獄よりも見通しの良いコードになります。複数のPromiseを並列で実行し、全て完了するのを待つ Promise.all() など、便利なメソッドも提供されています。

  • async/await:
    Promiseをさらに分かりやすく、同期的なコードに近い記述で扱えるようにしたのが async/await です。Promiseを返す関数の呼び出しの前に await キーワードを置くと、そのPromiseが解決（成功または失敗）するまで待つことができます。await は async 関数の中でしか使えません。

    “`javascript
    const fsPromises = require(‘fs’).promises;

    async function readFileContent() {
    try {
    const data = await fsPromises.readFile(‘file.txt’, ‘utf8’);
    console.log(data);
    } catch (err) {
    console.error(err);
    }
    }

    readFileContent();
    “`

    await fsPromises.readFile(...) の行は、ファイル読み込みが完了してPromiseが解決するまで処理が一時停止されます。しかし、これはイベントループをブロックするわけではなく、内部的にはPromiseの解決を待ってコールバックを実行するのと同等の処理が行われています。try...catch ブロックで同期的なエラーハンドリングのように非同期処理のエラーを扱えるのも大きな利点です。

    現在のNode.js開発では、async/awaitが非同期処理の推奨される記述方法となっています。

簡単なHTTPサーバーの構築

Node.jsの http 組み込みモジュールを使うと、Webサーバーを構築できます。まずは最も基本的な例を見てみましょう。

server.js ファイルを作成します。

“`javascript
// server.js
const http = require(‘http’);

const hostname = ‘127.0.0.1’; // localhost
const port = 3000;

const server = http.createServer((req, res) => {
// リクエストを受け取ったときの処理
console.log(リクエスト受信: ${req.method} ${req.url});

// レスポンスヘッダーの設定
res.writeHead(200, { ‘Content-Type’: ‘text/plain; charset=utf-8’ });

// レスポンスボディの送信とリクエストの終了
res.end(‘Hello, Node.js Server!\n’);
});

server.listen(port, hostname, () => {
// サーバー起動時の処理
console.log(サーバーが http://${hostname}:${port}/ で起動しました。);
});
“`

このコードをターミナルで実行します。

bash
node server.js

サーバーが起動すると、「サーバーが http://127.0.0.1:3000/ で起動しました。」というメッセージが表示されます。
Webブラウザを開き、アドレスバーに http://localhost:3000/ と入力してアクセスしてみてください。「Hello, Node.js Server!」というテキストが表示されるはずです。ターミナルには「リクエスト受信: GET /」のようなログが表示されます。

コードの解説:

  • require('http'): Node.jsの http モジュールを読み込みます。
  • http.createServer(...): HTTPサーバーを作成します。引数には、クライアントからリクエストが来るたびに実行されるコールバック関数を指定します。このコールバック関数は req (Request) と res (Response) という2つの引数を受け取ります。
  • req: クライアントからのリクエストに関する情報（URL、メソッド、ヘッダーなど）を持つオブジェクトです。
  • res: クライアントへのレスポンスを構築するためのオブジェクトです。
  • res.writeHead(statusCode, headers): レスポンスのステータスコード（例: 200 OK, 404 Not Found）とヘッダーを設定します。
  • res.end(data): レスポンスボディを送信し、リクエスト・レスポンスサイクルを終了します。引数として送信するデータを指定できます。
  • server.listen(port, hostname, callback): 指定したポート番号とホスト名でサーバーを起動し、リクエストを受け付けるようにします。サーバーが起動したら、オプションのコールバック関数が実行されます。

簡単なルーティング

アクセスされたURL（パス）によって返す内容を変えることを「ルーティング」と呼びます。req.url を使って簡単なルーティングを実装してみましょう。

server.js を以下のように修正します。

“`javascript
const http = require(‘http’);
const url = require(‘url’); // urlモジュールを読み込む

const hostname = ‘127.0.0.1’;
const port = 3000;

const server = http.createServer((req, res) => {
console.log(リクエスト受信: ${req.method} ${req.url});

// リクエストURLを解析
const parsedUrl = url.parse(req.url, true); // trueを指定するとクエリパラメータも解析

res.writeHead(200, { ‘Content-Type’: ‘text/plain; charset=utf-8’ });

// URLのパスによって応答を変える
if (parsedUrl.pathname === ‘/’) {
res.end(‘ここはトップページです。\n’);
} else if (parsedUrl.pathname === ‘/about’) {
res.end(‘このサーバーについて。\n’);
} else {
// 存在しないパスの場合
res.writeHead(404, { ‘Content-Type’: ‘text/plain; charset=utf-8’ });
res.end(‘お探しのページは見つかりませんでした。\n’);
}
});

server.listen(port, hostname, () => {
console.log(サーバーが http://${hostname}:${port}/ で起動しました。);
});
“`

サーバーを再起動（Ctrl+Cで停止し、node server.js で再度起動）し、http://localhost:3000/ と http://localhost:3000/about、そしてそれ以外のURL（例: http://localhost:3000/contact）にアクセスしてみてください。それぞれ異なる応答が得られるはずです。

http モジュールは基本的なHTTPサーバー機能を提供しますが、ルーティングやリクエスト・レスポンスの複雑な処理、ミドルウェアの組み込みなど、実際のWebアプリケーション開発に必要な多くの機能は自前で実装する必要があります。これは非常に手間がかかるため、通常は後述するExpressのようなWebアプリケーションフレームワークが利用されます。

Expressフレームワークの紹介と使用

Webアプリケーションフレームワークは、Web開発で共通して必要となる機能（ルーティング、テンプレートエンジン連携、データベース連携、セキュリティ対策など）をあらかじめ提供し、開発効率を向上させるためのツールです。Node.jsで最も人気があり、広く使われているWebアプリケーションフレームワークがExpressです。

Expressを使うことで、http モジュールだけを使うよりも遥かに少ないコード量で、より構造化されたWebアプリケーションを開発できます。

Expressのインストール

Expressを使うには、まずプロジェクトにインストールする必要があります。

“`bash

プロジェクトのルートディレクトリで実行

npm install express
“`

Expressを使ったシンプルなサーバー構築

Expressを使った基本的なHTTPサーバーは以下のようになります。

app.js ファイルを作成します。

“`javascript
// app.js
const express = require(‘express’);
const app = express(); // Expressアプリケーションのインスタンスを作成
const port = 3000;

// トップページへのGETリクエストに対するルーティング
app.get(‘/’, (req, res) => {
res.send(‘Hello from Express!’); // レスポンスを送信
});

// サーバーを指定したポートで起動
app.listen(port, () => {
console.log(Expressサーバーがポート ${port} で起動しました。);
});
“`

このコードをターミナルで実行します。

bash
node app.js

サーバーが起動したら、ブラウザで http://localhost:3000/ にアクセスしてください。「Hello from Express!」と表示されるはずです。

コードの解説:

  • const express = require('express');: Expressモジュールを読み込みます。
  • const app = express();: Expressアプリケーションのインスタンスを作成します。これがサーバーアプリケーション全体を表すオブジェクトになります。
  • app.get(path, handler): 指定したパスへのGETリクエストに対するルートハンドラ（処理関数）を定義します。他のHTTPメソッド（POST, PUT, DELETEなど）に対しても app.post(), app.put(), app.delete() のように同様に定義できます。
  • handler = (req, res) => { ... }: リクエストが来たときに実行される関数です。http モジュールのコールバックと同様に req と res オブジェクトを受け取りますが、Expressによって機能が拡張されています。
  • res.send(data): 様々な型のデータを自動的に検出し、適切な Content-Type ヘッダーを設定してレスポンスとして送信する便利なメソッドです。HTML文字列、JSONオブジェクト、配列、バッファなどを送信できます。
  • app.listen(port, callback): 指定したポートでサーバーを起動します。

ルーティングの詳細

Expressでは、より柔軟なルーティングが可能です。

  • パスパラメータ: URLの一部を変数として取得できます。

    javascript
    app.get('/users/:userId/books/:bookId', (req, res) => {
    const userId = req.params.userId;
    const bookId = req.params.bookId;
    res.send(`ユーザー ${userId} の書籍 ${bookId} の情報`);
    });
    例: /users/123/books/abc にアクセスすると req.params は { userId: '123', bookId: 'abc' } となります。

  • クエリパラメータ: URLの ?key1=value1&key2=value2 の部分を取得できます。

    javascript
    app.get('/search', (req, res) => {
    const query = req.query.q; // 例: /search?q=nodejs
    res.send(`検索キーワード: ${query}`);
    });
    例: /search?q=nodejs&category=web にアクセスすると req.query は { q: 'nodejs', category: 'web' } となります。

  • ルーターオブジェクト: 関連するルートをまとめて管理するために express.Router() を使えます。

    “`javascript
    const express = require(‘express’);
    const router = express.Router();

    // /api/users 以下のルートを定義
    router.get(‘/’, (req, res) => {
    res.send(‘全ユーザー一覧’);
    });

    router.get(‘/:userId’, (req, res) => {
    res.send(ユーザーID: ${req.params.userId});
    });

    // アプリケーションにルーターをマウント
    app.use(‘/api/users’, router); // /api/users というプレフィックスでルーターを使用
    ``
    これにより、    /api/usersや/api/users/123` といったURLに対応できるようになります。

ミドルウェア

Expressのもう一つの強力な機能がミドルウェアです。ミドルウェアは、リクエストが最終的なルートハンドラに到達するまでの間に実行される関数です。認証、ロギング、ボディ解析、静的ファイル配信など、様々な共通処理に使われます。

ミドルウェア関数は通常、(req, res, next) という3つの引数を受け取ります。処理が完了したら、次のミドルウェアまたはルートハンドラに処理を渡すために next() 関数を呼び出します。next() を呼ばないと、そこでリクエスト処理が停止してしまいます。

ミドルウェアは app.use() メソッドを使ってアプリケーションに組み込みます。

“`javascript
const express = require(‘express’);
const app = express();

// ログ出力ミドルウェアの例
app.use((req, res, next) => {
console.log([${new Date().toISOString()}] ${req.method} ${req.url});
next(); // 次の処理へ
});

// POSTリクエストのJSONボディを解析する組み込みミドルウェア
app.use(express.json());

// publicディレクトリにある静的ファイルを配信する組み込みミドルウェア
app.use(express.static(‘public’));

// ルートハンドラ
app.get(‘/’, (req, res) => {
res.send(‘トップページ’);
});

app.post(‘/submit’, (req, res) => {
console.log(‘POSTデータ:’, req.body); // express.json() ミドルウェアによって req.body にデータが入る
res.send(‘データを受信しました’);
});

app.listen(3000, () => console.log(‘サーバー起動’));
“`

この例では、最初のリクエストログミドルウェアが全てのリクエストに対して実行され、次に express.json() がPOSTリクエストなどのボディを解析し、express.static('public') が /public 以下の静的ファイルリクエストに応答します。これらのミドルウェアを通過した後、対応するルートハンドラ（/ や /submit）が実行されます。

express.json() や express.static() のように、Express自身が提供する組み込みミドルウェアや、npmで入手できるサードパーティ製ミドルウェア（例: cors for CORS対応, morgan for 高機能ロギング）が多く存在します。

テンプレートエンジン

Webアプリケーションでは、サーバー側でHTMLを生成してクライアントに返すことがよくあります。このとき、テンプレートエンジンを使うと、動的なデータを埋め込んだHTMLを効率的に生成できます。Expressは様々なテンプレートエンジン（EJS, Pug, Handlebarsなど）をサポートしています。

例として、EJS (Embedded JavaScript templates) を使う場合:

  1. EJSをインストール: npm install ejs
  2. Expressアプリケーションで設定:
    javascript
    app.set('view engine', 'ejs'); // テンプレートエンジンとしてejsを設定
    app.set('views', './views'); // テンプレートファイルがあるディレクトリを指定 (デフォルトは views)
  3. views ディレクトリにテンプレートファイル (index.ejs など) を作成:
    html
    <!-- views/index.ejs -->
    <!DOCTYPE html>
    <html>
    <head>
    <title><%= title %></title>
    </head>
    <body>
    <h1><%= message %></h1>
    </body>
    </html>
    <%= ... %> の部分にサーバー側から渡されたデータが埋め込まれます。
  4. ルートハンドラでテンプレートをレンダリング:
    javascript
    app.get('/', (req, res) => {
    res.render('index', { title: 'Express App', message: 'EJSテンプレートからの応答です' });
    });
    res.render(templateName, data) メソッドで指定したテンプレートファイルをレンダリングし、その結果をクライアントに返します。第二引数のオブジェクトはテンプレートファイル内で利用できます。

このように、Expressを使うことで、ルーティング、ミドルウェア、テンプレートエンジンといったWebアプリケーション開発に必要な基盤を簡単に構築できます。

データベース連携（簡単な例）

サーバーサイドアプリケーションでは、通常データベースを使ってデータを永続化します。Node.jsからデータベースに接続し操作するには、それぞれのデータベースに対応したnpmパッケージ（ドライバーやORM/ODM）を利用します。

データベースの種類は、リレーショナルデータベース（RDBMS、例: PostgreSQL, MySQL, SQLite）やNoSQLデータベース（例: MongoDB, Redis）など、様々なものがあります。

ここでは、ファイルベースで手軽に使えるリレーショナルデータベース、SQLite3 を例に、Node.jsからの簡単な接続とデータ読み込みを示します。

  1. SQLite3 ドライバーをインストール:
    bash
    npm install sqlite3

  2. データベース操作のコード例:

    “`javascript
    const sqlite3 = require(‘sqlite3’).verbose(); // verboseモードで詳細なログを出力

    // データベースファイルに接続 (存在しない場合は新規作成される)
    const db = new sqlite3.Database(‘./mydatabase.db’, (err) => {
    if (err) {
    console.error(‘データベース接続エラー:’, err.message);
    } else {
    console.log(‘データベースに接続しました。’);
    // 接続成功後にテーブル作成などの初期化処理を行うことが多い
    db.run(‘CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT, age INTEGER)’, (err) => {
    if (err) {
    console.error(‘テーブル作成エラー:’, err.message);
    } else {
    console.log(‘usersテーブルが存在することを確認または作成しました。’);
    // ここでデータの挿入やクエリ実行などを行う
    insertUser(‘Alice’, 30);
    insertUser(‘Bob’, 25);
    getAllUsers();
    }
    });
    }
    });

    // データの挿入 (INSERT)
    function insertUser(name, age) {
    const sql = INSERT INTO users (name, age) VALUES (?, ?);
    db.run(sql, [name, age], function(err) { // functionを使うとthisでidが取れる
    if (err) {
    console.error(‘データ挿入エラー:’, err.message);
    } else {
    console.log(ユーザー ${name} をID ${this.lastID} で挿入しました。);
    }
    });
    }

    // 全データの取得 (SELECT)
    function getAllUsers() {
    const sql = SELECT id, name, age FROM users;
    db.all(sql, [], (err, rows) => {
    if (err) {
    console.error(‘データ取得エラー:’, err.message);
    } else {
    console.log(‘— ユーザー一覧 —‘);
    rows.forEach((row) => {
    console.log(ID: ${row.id}, 名前: ${row.name}, 年齢: ${row.age});
    });
    console.log(‘——————-‘);
    }
    db.close((err) => { // データベース接続を閉じる
    if (err) {
    console.error(‘データベース切断エラー:’, err.message);
    } else {
    console.log(‘データベース接続を閉じました。’);
    }
    });
    });
    }

    // 注意：SQLite3の操作は通常非同期です。
    // 上記の例では、挿入→取得→切断がコールバックの中で順番に実行されるように記述しています。
    // 実際のアプリケーションでは、Promiseやasync/awaitを使って、
    // より管理しやすくエラーハンドリングしやすいコードにするのが一般的です。
    // 例: db.getAsync, db.allAsync などの Promiseラッパーを利用する
    “`

上記の例では、SQLite3への接続、テーブル作成、データ挿入、データ取得、接続切断といった一連のデータベース操作を非同期で行っています。コールバックがネストしていますが、これもPromiseやasync/awaitを使うことで改善できます。

Expressアプリケーションからデータベースを操作する場合、ルートハンドラの中でこれらのデータベース操作関数を呼び出すことになります。

エラーハンドリング

サーバーサイドアプリケーションでは、様々な種類のエラーが発生する可能性があります。ファイルが見つからない、データベース接続に失敗した、予期しないデータが送られてきた、などが考えられます。発生したエラーを適切に処理しないと、アプリケーションがクラッシュしたり、ユーザーに不親切なエラーが表示されたり、セキュリティ上の問題が発生したりする可能性があります。

Node.jsにおける主なエラーハンドリング手法を見てみましょう。

同期処理のエラー (try...catch)

同期的な処理の中で発生したエラーは、JavaScript標準の try...catch ブロックで捕捉できます。

“`javascript
function riskySyncOperation() {
// 例: 存在しない変数を参照して ReferenceError を発生させる
console.log(nonExistentVariable);
}

try {
riskySyncOperation();
console.log(‘同期処理が成功しました’); // ここは実行されない
} catch (error) {
console.error(‘同期処理でエラーが発生しました:’, error.message);
}

console.log(‘try…catchブロックの後続処理’); // ここは実行される
“`

非同期処理のエラー（コールバック、Promise, async/await）

非同期処理で発生したエラーは、try...catch だけでは捕捉できません。非同期処理の方法によってエラーハンドリングの方法が異なります。

  • コールバック:
    非同期関数のコールバック関数の第一引数にエラーオブジェクトが渡されるのが慣習です。

    javascript
    fs.readFile('non_existent_file.txt', 'utf8', (err, data) => {
    if (err) {
    console.error('非同期処理(コールバック)でエラー:', err.message);
    // エラー処理を行う
    return; // 後続の正常系処理を実行しないようにする
    }
    console.log('ファイル内容:', data); // エラーがなければ実行される
    });
    コールバックベースの場合、それぞれのコールバック関数内でエラーチェックを忘れずに行う必要があります。

  • Promise:
    Promiseは .catch() メソッドを使ってエラーを捕捉します。

    javascript
    fsPromises.readFile('another_non_existent_file.txt', 'utf8')
    .then((data) => {
    console.log('ファイル内容:', data);
    })
    .catch((err) => {
    console.error('非同期処理(Promise)でエラー:', err.message);
    // エラー処理を行う
    });
    Promiseチェーンの途中で発生したエラーは、チェーンの最後にある .catch() でまとめて捕捉できます。

  • async/await:
    async 関数の中で await を使った非同期処理は、同期処理のように try...catch でエラーを捕捉できます。

    “`javascript
    async function readNonExistentFile() {
    try {
    const data = await fsPromises.readFile(‘yet_another_non_existent_file.txt’, ‘utf8’);
    console.log(‘ファイル内容:’, data);
    } catch (err) {
    console.error(‘非同期処理(async/await)でエラー:’, err.message);
    // エラー処理を行う
    }
    }

    readNonExistentFile();
    “`
    async/awaitを使うと、非同期処理のエラーハンドリングが直感的で分かりやすくなります。

グローバルなエラーハンドリング（最終手段）

どの try...catch や .catch() でも捕捉されなかったエラー（未捕捉例外）が発生すると、Node.jsプロセスはデフォルトでクラッシュします。本番環境でサーバーが突然停止するのを防ぐため、グローバルなエラーハンドリングを設定することがあります。

  • 未捕捉例外 (uncaughtException):
    同期処理の中で発生し、try...catch で捕捉されなかった例外。

    “`javascript
    process.on(‘uncaughtException’, (err) => {
    console.error(‘キャッチされなかった例外:’, err);
    // プロセスを安全に終了するなど、回復処理を試みる
    // 注意: このイベントハンドラの後も実行が続くため、不安定になる可能性がある
    // 最も安全なのはログを出力してプロセスを終了すること
    // process.exit(1);
    });

    // ここで意図的に未捕捉例外を発生させる (例: 存在しない関数を呼び出す)
    // nonExistentFunction();
    “`

  • 未処理のPromiseのRejection (unhandledRejection):
    Promiseが reject されたにも関わらず、.catch() で捕捉されなかった場合。

    “`javascript
    process.on(‘unhandledRejection’, (reason, promise) => {
    console.error(‘未処理のPromise rejection:’, reason);
    // ログを出力するなどの処理を行う
    // process.exit(1); // 終了させるか検討
    });

    // ここで意図的に未処理のrejectionを発生させる
    // Promise.reject(new Error(‘何か問題が発生しました’));
    “`

これらのグローバルハンドラは、あくまで最後の砦として使用すべきです。可能な限り、各非同期処理や同期処理の発生源に近い場所でエラーを捕捉し、適切に処理する（ログ出力、ユーザーへのエラー応答、リトライなど）ことが重要です。グローバルハンドラは、予期せぬエラーが発生したことを検知し、ログを残してプロセスを再起動するなどのためのものであり、そこで複雑な回復処理を行うべきではありません。

パッケージングとデプロイ（概要）

開発したNode.jsアプリケーションをサーバー上で動かすためには、コードと必要な依存パッケージをまとめてデプロイする必要があります。

  • 依存関係: package.json の dependencies にリストされているパッケージが必要です。npm install を実行して node_modules ディレクトリを作成します。package-lock.json は、インストールされるパッケージのバージョンを正確に固定するために重要です。
  • 本番環境向けインストール: 開発環境で使っていた devDependencies を含めずにインストールするには npm install --production を使います。デプロイ時には通常このコマンドを使います。
  • 起動スクリプト: package.json の scripts フィールドに start スクリプトを定義しておくと、デプロイ先で npm start という共通コマンドでアプリケーションを起動できるようになります（例: "start": "node index.js"）。
  • 環境変数: データベース接続情報、APIキー、ポート番号などの環境に依存する設定値は、コードに直接書き込まず、環境変数としてアプリケーション外部から渡すようにします。Node.jsでは process.env.<変数名> で環境変数の値を取得できます。dotenv パッケージを使うと、開発時に .env ファイルから環境変数を読み込むことができます。
  • デプロイ先: Node.jsアプリケーションをデプロイできるプラットフォームは多数あります。
    • PaaS (Platform as a Service): Heroku, Vercel (主にFrontend/Serverless Functions), Netlify (Serverless Functions), Render など。アプリケーションコードをプッシュするだけで自動的にビルド・デプロイ・スケーリングを行ってくれる手軽さが魅力です。
    • CaaS (Container as a Service): Dockerコンテナとしてパッケージ化し、AWS Fargate, Google Cloud Run, Azure Container Instances などで実行します。コンテナ技術を使うことで環境の再現性が高まります。
    • FaaS (Function as a Service) / Serverless Computing: AWS Lambda, Google Cloud Functions, Azure Functions など。リクエストがあったときだけコードが実行され、イベント駆動の短い処理に向いています。API Gatewayと組み合わせてWeb APIとして公開することも多いです。
    • IaaS (Infrastructure as a Service): AWS EC2, Google Compute Engine, Azure Virtual Machines など。仮想サーバーを自分で構築・管理し、その上でNode.jsアプリケーションを動かします。自由度が高い反面、運用管理の負担が大きくなります。

どのデプロイ先を選ぶかは、アプリケーションの規模、性質、必要な管理レベルなどによって異なります。入門段階ではPaaSが手軽でおすすめです。

セキュリティの考慮（入門レベル）

サーバーサイドアプリケーションを公開する場合、セキュリティは非常に重要です。ここでは入門レベルで知っておくべき最低限の考慮事項を挙げます。

  • 依存関係の脆弱性: 利用しているnpmパッケージにセキュリティ上の脆弱性が見つかることがあります。npm audit コマンドを使うと、プロジェクトの依存関係に既知の脆弱性がないかスキャンし、レポートしてくれます。脆弱性が見つかった場合は npm audit fix で可能な限り自動修正を試みることができます。定期的に npm audit を実行する習慣をつけましょう。
  • 環境変数の利用: APIキー、パスワード、秘密鍵、データベース認証情報といった機密情報は、絶対にコード内に直書きしないでください。必ず環境変数として管理し、アプリケーション起動時に読み込むようにします。開発環境では dotenv パッケージが便利です。
  • 入力値の検証: クライアントから送信されるデータ（フォーム入力、APIパラメータなど）は、常に信頼できないものとして扱います。必ずサーバーサイドで型、形式、サイズ、値の範囲などの検証を行います。不適切な入力値は、アプリケーションのエラーだけでなく、SQLインジェクションやXSS（クロスサイトスクリプティング）などのセキュリティ脆弱性につながる可能性があります。バリデーションライブラリを利用するのが一般的です。
  • エラー情報の暴露: エラーが発生した場合、その詳細な情報（スタックトレース、データベースクエリなど）をそのままクライアントに返さないでください。攻撃者にサーバー内部の情報を与えてしまう可能性があります。本番環境では、汎用的なエラーメッセージのみを返し、詳細なエラー情報はサーバー側のログに記録するようにします。Expressではエラーハンドリングミドルウェアを使ってこれを制御できます。
  • HTTPSの使用: ユーザーの認証情報や機密性の高いデータを扱う場合は、必ずHTTPSを使用し、通信を暗号化してください。

これらは基本的な対策であり、実際のWebアプリケーション開発ではさらに多くのセキュリティ上の考慮が必要です。認証、認可、セッション管理、CSRF対策など、より高度なトピックについては専門の情報を参照してください。

デバッグ

コードを書いていく上で、エラーや意図しない動作はつきものです。効率的に問題を解決するためにはデバッグの手法を知っておくことが重要です。

  • console.log デバッグ:
    最も手軽な方法ですが、問題箇所を特定したり変数の状態を確認したりするのに役立ちます。

    “`javascript
    // … somewhere in your code
    console.log(‘変数userの値:’, user);
    console.log(‘この行に到達しました’);

    // … later
    if (condition) {
    console.warn(‘注意: 条件が満たされました’);
    // …
    }
    ``console.log,console.warn,console.error,console.debug` などを使い分けると便利です。ただし、コードに大量に残しすぎると読みにくくなるため、デバッグが完了したら削除またはコメントアウトしましょう。

  • Node.js組み込みデバッガー:
    Node.jsにはV8エンジンに組み込まれたデバッガーを利用するための機能があります。

    bash
    node --inspect script.js
    または、ブレークポイントを設定したい行に debugger; というキーワードを埋め込んでおき、以下のコマンドで実行します。

    bash
    node --inspect-brk script.js # --inspect-brk はコードの最初の行で一時停止する
    これらのコマンドを実行すると、デバッガーがポートを開いて待機状態になります。Chromeブラウザを開き、アドレスバーに chrome://inspect と入力すると、対象のNode.jsプロセスが表示されるので、「inspect」リンクをクリックするとChrome DevToolsを使ってデバッグできます。DevTools上でソースコードを見ながらブレークポイントの設定、ステップ実行、変数の値確認などが可能です。

  • IDEを使ったデバッグ:
    Visual Studio Code (VS Code) のような統合開発環境（IDE）を使うと、より快適なデバッグができます。VS CodeはNode.jsのデバッグ機能を標準でサポートしており、特別な設定なしにブレークポイントを設定したり、変数ウォッチを使ったりできます。

    通常、VS CodeでNode.jsファイルを開き、左側のデバッグビュー（虫のアイコン）を選択し、「Run and Debug」ボタンをクリックするだけでデバッグを開始できます。.vscode/launch.json ファイルを編集することで、引数を渡したり、特定のファイルを実行したりといった詳細なデバッグ構成を設定することも可能です。ほとんどの場合、IDEを使ったデバッグが最も効率的でおすすめです。

より進んだトピック（簡単な紹介）

Node.jsの世界は非常に広大で、本記事で触れた内容はほんの一歩に過ぎません。今後学習を進めるにあたって知っておくと良い、より進んだトピックをいくつか紹介します。

  • テスト: 開発したアプリケーションが正しく動作することを検証するためにテストは不可欠です。ユニットテスト、結合テスト、E2Eテストなど様々なレベルのテストがあります。Node.jsでよく使われるテストフレームワークには Jest, Mocha, Jasmine などがあります。
  • TypeScript: JavaScriptに静的型付けを追加した言語です。大規模なアプリケーション開発において、コードの保守性や可読性を高めるのに役立ちます。Node.jsでも広く利用されています。
  • 非同期処理のより深い理解: イベントループのフェーズ（タイマー、I/Oコールバック、アイドル・プリペア、ポール、チェック、クローズコールバック）や process.nextTick, setImmediate の違いなど、非同期処理の仕組みを深く理解することは、パフォーマンスの問題解決などに役立ちます。
  • WebSocket: クライアントとサーバー間でリアルタイム双方向通信を実現するための技術です。チャットアプリやオンラインゲームなど、リアルタイム性が求められるアプリケーションで利用されます。Node.jsでは ws や Socket.IO といったライブラリがよく使われます。
  • マイクロサービス: 一つの大きなアプリケーションを、機能ごとに分割された小さな独立したサービスの集まりとして構築するアーキテクチャスタイルです。Node.jsはマイクロサービスの構築に適していると言われています。
  • 他のフレームワーク: Express以外にも、Node.jsのWebフレームワークは多数存在します。
    • NestJS: TypeScriptとOOP/FP/FRPの概念を取り入れた、より構造化されたエンタープライズ向けのフレームワークです。Angularに似たアーキテクチャを持ちます。
    • Koa: Expressの作者たちが開発した、より軽量でミドルウェアに特化したフレームワークです。async/awaitを前提とした設計になっています。
    • Fastify: 高いパフォーマンスと低いオーバーヘッドを特徴とするフレームワークです。

これらのトピックは、Node.js開発者としてさらに成長していく上で、いずれ学習することになるでしょう。

まとめ：次のステップへ

本記事では、Node.jsを使ったサーバーサイド開発の基礎を、インストールから簡単なサーバー構築、フレームワークの利用、非同期処理、エラーハンドリング、データベース連携、セキュリティ、デバッグといった幅広いトピックにわたって解説しました。

Node.jsはJavaScriptでサーバーサイド開発ができる強力なツールであり、その非同期・イベント駆動アーキテクチャによって高いパフォーマンスを実現できます。また、npmエコシステムによって、様々な機能を簡単に開発に取り込むことができます。

本記事の内容を理解できれば、Node.jsを使ったサーバーサイド開発の入り口に立つことができたと言えるでしょう。しかし、これはまだ始まりに過ぎません。実際のアプリケーション開発では、認証、API設計、データベース設計、テスト、パフォーマンス最適化、デプロイ・運用など、さらに多くのことを学ぶ必要があります。

次のステップとして、以下のようなことに挑戦してみることをお勧めします。

  • 簡単なWebアプリケーションをゼロから作ってみる: Todoリストやブログのようなシンプルなアプリケーションを、データベース連携も含めて一通り実装してみましょう。Expressを使ってAPIを作成し、フロントエンド（HTML, CSS, JavaScript）からそのAPIを呼び出すような構成が良い練習になります。
  • Node.jsの公式ドキュメントを読む: Node.jsの組み込みモジュールやAPIについて、公式ドキュメントは最も正確で詳細な情報源です。必要に応じて参照する癖をつけましょう。
  • npmで様々なパッケージを試してみる: 興味のある機能を実装するために、npmで公開されているライブラリを探して使ってみましょう。多くのnpmパッケージはGitHubで公開されており、ソースコードや使い方の例を見ることができます。
  • 非同期処理についてさらに深く学ぶ: Promiseやasync/awaitだけでなく、Node.jsのイベントループの仕組みをより深く理解することは、パフォーマンスの高い、バグの少ないコードを書くために重要です。
  • Express以外のフレームワークも調べてみる: アプリケーションの性質や個人の好みに合わせて、他のフレームワーク（NestJSなど）を学習してみるのも良いでしょう。

Node.jsは活発なコミュニティを持つ人気の技術です。公式ドキュメント、各種チュートリアルサイト、技術ブログ、オンラインコミュニティなどを活用しながら、学習を継続していきましょう。

JavaScriptという馴染みのある言語で、サーバーサイドという新しい世界を切り開くNode.jsでの開発体験を、ぜひ楽しんでください！

コメントする

メールアドレスが公開されることはありません。 ※ が付いている欄は必須項目です

上部へスクロール