Node.jsとは？何ができる？初心者でもわかる入門ガイド

By /

Node.js（ノード・ジェイエス）とは？何ができる？初心者でもわかる入門ガイド

はじめに：Web開発の風景を変えたNode.js

テクノロジーの世界は常に進化しており、新しいツールやフレームワークが次々と登場します。その中でも、近年特に大きな注目を集め、多くの開発現場で採用されている技術の一つに Node.js（ノード・ジェイエス） があります。

「JavaScriptって、ウェブサイトの画面を動かすためのものだよね？」そう思っている方も多いかもしれません。確かに、JavaScriptはもともとブラウザ上で動くために開発された言語です。しかし、Node.jsの登場によって、JavaScriptはブラウザという枠を超え、サーバーサイドやデスクトップアプリケーション、さらにはIoTデバイスまで、あらゆる場所で活躍できる強力なツールへと進化しました。

Node.jsを学ぶことは、現代のソフトウェア開発において非常に大きなアドバンテージとなります。特にウェブ開発においては、フロントエンドからバックエンドまで一貫してJavaScriptで開発できる「フルスタックJavaScript」という考え方が広まり、開発効率の向上や学習コストの削減に繋がっています。

「でも、プログラミング経験があまりないんだけど、Node.jsって難しい？」
ご安心ください。この記事は、あなたがNode.jsの基礎を理解し、実際に簡単なプログラムを動かせるようになることを目指した、初心者向けの入門ガイドです。約5000語にわたり、Node.jsがなぜ生まれ、何ができて、どうやって使うのかを、丁寧に解説していきます。

この記事を読むことで、あなたは以下のことを習得できます。

  • Node.jsの基本的な概念と特徴を理解する。
  • Node.jsをインストールし、開発環境を整える。
  • JavaScriptコードをNode.js上で実行する。
  • Node.jsのモジュールシステムと非同期処理の基本を学ぶ。
  • npm（Node Package Manager）を使って便利なライブラリを利用する。
  • 簡単なWebサーバーを構築する。
  • Node.jsで何ができるのか、具体的な用途や事例を知る。

少し長い旅になりますが、Node.jsの扉を開けることで、あなたのプログラミングの世界はきっと大きく広がるでしょう。さあ、一緒にNode.jsの世界へ踏み出しましょう！

Node.jsとは何か？ 基本概念を理解しよう

まずは、「Node.jsとは一体何なのか？」という核心に迫ります。一言でいうと、Node.jsは 「JavaScriptの実行環境」 です。

JavaScriptの実行環境とは？

プログラミング言語は、書かれたコードをコンピューターが理解できる形に変換・実行するための「実行環境」が必要です。例えば、私たちが普段Webブラウザで見ているウェブサイトの動き（ボタンをクリックしたら何か表示される、アニメーションするなど）は、ブラウザに組み込まれたJavaScriptエンジンがJavaScriptコードを実行することで実現しています。主要なブラウザには、それぞれ独自のJavaScriptエンジンが搭載されています（例：ChromeのV8、FirefoxのSpiderMonkey、SafariのJavaScriptCore）。

Node.jsが登場するまで、JavaScriptはこのように主に「ブラウザ上」で動くための言語でした。しかし、Node.jsは、ブラウザの外でJavaScriptを実行できるようにした 画期的な技術です。具体的には、Google Chromeが使用している高性能なJavaScriptエンジンである V8エンジン を核として、サーバーサイドやデスクトップなど、ブラウザ以外の環境でJavaScriptコードを実行できるように構築されています。

ブラウザJavaScriptとの違い

Node.jsはJavaScriptの実行環境ですが、ブラウザで実行されるJavaScriptとはいくつか重要な違いがあります。

  1. 実行環境:

    • ブラウザJavaScript: Webブラウザ上で実行される。
    • Node.js: ブラウザを介さず、オペレーティングシステム上で直接実行される。サーバーサイドやコマンドラインツールなどで利用される。

  2. アクセス可能な機能:

    • ブラウザJavaScript: セキュリティ上の理由から、ユーザーのコンピューター上のファイルシステムへの直接アクセスや、OSレベルの操作は基本的に制限されている。主にDOM（Document Object Model）を操作してWebページの表示や振る舞いを変更することに特化している。
    • Node.js: ファイルシステムへのアクセス（ファイルの読み書き）、ネットワーク通信（HTTPサーバーの構築、他のサービスとの通信）、データベース連携など、OSが提供する多くの機能にアクセスできる。これは、サーバーサイドアプリケーションに必要な機能です。

  3. モジュールシステム:

    • ブラウザJavaScript: かつてはグローバルスコープで変数を共有するか、簡単なパターンでモジュールを実現していた。現在はES Modulesが標準化されつつある。
    • Node.js: CommonJSという独自のモジュールシステムを古くから採用しており、require()を使ってモジュールを読み込み、module.exportsでモジュールを公開するのが一般的だった。現在はES Modulesもサポートされている。

Node.jsの核：V8エンジンと非同期I/O、イベントループ

Node.jsがなぜ高性能で人気があるのかを理解するためには、その内部の仕組み、特にV8エンジンと非同期I/O、イベントループの概念を知ることが重要です。

  • V8エンジン:
    V8は、Google Chromeのために開発された、オープンソースの高性能なJavaScriptエンジンです。JavaScriptコードを直接機械語にコンパイルすることで、非常に高速な実行を実現しています。Node.jsはこのV8エンジンを採用しているため、JavaScriptコードの実行速度が速いという特徴があります。

  • 非同期I/Oとイベントループ:
    これがNode.jsの最も重要な特徴であり、そのパフォーマンスの秘密です。
    I/O とは、Input/Output、つまり入力/出力のことです。具体的には、ファイルの読み書き、ネットワーク通信（Webサーバーがクライアントからのリクエストを受け付けたり、データベースからデータを取得したり）、データベースへのアクセスなどがI/O処理にあたります。
    一般的なサーバーサイド言語（PHP, Ruby, Python, Javaなど）の多くは、デフォルトではI/O処理を ブロッキング 方式で行います。これは、あるI/O処理（例えば大きなファイルの読み込み）を開始したら、その処理が完了するまでプログラムの実行が一時停止（ブロック）される方式です。その間、他のリクエストや処理は待たされることになります。多くのユーザーからのリクエストが同時に発生した場合、処理待ちが起こりやすく、サーバー全体の応答速度が低下する可能性があります。

    一方、Node.jsはデフォルトで 非同期（ノンブロッキング）I/O を採用しています。これは、I/O処理を開始したら、その完了を待たずにすぐに次の処理に移る方式です。I/O処理が完了した際には、「この処理が終わりましたよ」という通知（イベント）が送られます。Node.jsは、このイベントを監視し、イベントが発生したら、あらかじめ指定しておいた処理（コールバック関数など）を実行します。このイベントの監視と、発生したイベントに応じた処理の実行を繰り返す仕組みを イベントループ と呼びます。

    イベントループの簡単なイメージ:
    1. リクエストAが来る（例: ファイルを読み込む）。
    2. Node.jsはファイル読み込み処理をOSに依頼する。
    3. 依頼したら、完了を待たずに すぐに 次のリクエストBの処理に移る。
    4. リクエストBが来る（例: データベースに書き込む）。
    5. Node.jsはデータベース書き込み処理を依頼する。
    6. 依頼したら、完了を待たずに すぐに また次の処理に移る。
    7. …（他の処理を実行し続ける）…
    8. しばらくして、ファイル読み込み処理が完了したというイベントが発生する。
    9. イベントループがこれT検知し、リクエストAの続き（ファイル内容を使った処理）を実行する。
    10. さらにしばらくして、データベース書き込み処理が完了したというイベントが発生する。
    11. イベントループがこれを検知し、リクエストBの続き（処理完了のレスポンスを返すなど）を実行する。

    このように、Node.jsはI/O処理中に他の処理を並行して（厳密にはシングルスレッド内で効率的に切り替えながら）行うことができます。これにより、特に多数の同時接続を扱うWebサーバーや、I/O負荷の高いアプリケーションにおいて、非常に高いパフォーマンスとスケーラビリティを発揮します。

    ただし、Node.jsのJavaScriptコード実行自体は基本的に シングルスレッド です。つまり、一度に一つのJavaScriptコードしか実行できません。計算量の多い処理（CPUを長時間占有する処理）があると、その間イベントループがブロックされ、他の処理が滞ってしまう可能性がある点には注意が必要です。しかし、Webアプリケーションの多くのボトルネックはCPU処理ではなくI/O処理にあるため、非同期I/Oによる恩恵の方が大きい場合が多いです。

まとめると、Node.jsはV8エンジンの高速な実行能力と、非同期I/O・イベントループによる効率的なI/O処理によって、特にリアルタイムアプリケーションや多数の同時接続を扱うサーバーサイド開発において、非常に強力な実行環境となっています。

Node.jsで何ができる？ 用途と事例

Node.jsが単なる「ブラウザの外でJavaScriptが動く」環境以上のものだと理解できたところで、具体的にNode.jsを使って何ができるのか、その幅広い用途を見ていきましょう。

  1. サーバーサイドアプリケーションの開発 (Webサーバー、APIサーバー)
    これはNode.jsの最も代表的な用途です。HTTPリクエストを受け付けて、処理を行い、クライアントにレスポンスを返す、いわゆるバックエンドのシステムを構築できます。

    • Webサーバー: 静的なファイル（HTML, CSS, JavaScriptファイルなど）を配信したり、動的なコンテンツを生成して返すサーバーを構築できます。
    • APIサーバー: モバイルアプリケーションやフロントエンドフレームワーク（React, Vue, Angularなど）からのリクエストに対して、データを提供するAPI（RESTful APIやGraphQL APIなど）を構築できます。多くの企業が、バックエンドAPIの開発にNode.jsを採用しています。

    Node.jsの標準ライブラリにはhttpモジュールが含まれており、これを使って基本的なWebサーバーを構築できますが、より複雑なアプリケーション開発には、以下のようなフレームワークが広く使われています。
    * Express.js: Node.jsで最も人気があり、シンプルで柔軟性の高い軽量なWebアプリケーションフレームワーク。多くのプロジェクトで使用されています。
    * NestJS: TypeScriptとOOP（オブジェクト指向プログラミング）の原則に基づいた、より構造化されたエンタープライズレベルのアプリケーション開発に適したフレームワーク。Angularの設計思想に影響を受けています。
    * Koa.js: Expressの開発チームによって作られた、より軽量で柔軟性の高いフレームワーク。ミドルウェアの概念が特徴的です。

  2. リアルタイムアプリケーション
    Node.jsの非同期・イベント駆動の特性は、リアルタイム性が求められるアプリケーションと非常に相性が良いです。

    • チャットアプリケーション: 複数のユーザーが同時にメッセージをやり取りするようなアプリケーションは、サーバーとクライアント間の双方向通信が必要です。Node.jsは WebSocket というプロトコルを扱うためのライブラリ（例: Socket.IO）が豊富にあり、効率的にリアルタイム通信を実装できます。
    • オンラインゲーム: プレイヤーの状態をリアルタイムに同期するなど。
    • コラボレーションツール: ドキュメントの共同編集など。
    • IoT（Internet of Things）: デバイスの状態をリアルタイムに監視したり、コマンドを送信したりするバックエンド。

  3. コマンドラインツール (CLIツール)
    Node.jsを使えば、ターミナル上で実行できるオリジナルのコマンドラインツールを作成できます。

    • ファイルの操作、データの変換、特定のタスクの自動化など、日々の開発作業を効率化するツールを作れます。
    • npm自体もNode.jsで書かれたCLIツールです。その他にも、多くの開発ツール（後述のフロントエンドビルドツールなど）がNode.jsで開発されています。

  4. フロントエンドのビルドツールと開発ワークフロー
    一見意外に思えるかもしれませんが、Node.jsは現代のフロントエンド開発においてなくてはならない存在です。

    • モジュールバンドラー: 複数のJavaScript/CSS/その他のアセットファイルをまとめて一つ（あるいはいくつか）のファイルにバンドルするツール（例: webpack, Rollup, Parcel）。Node.js上で実行されます。
    • タスクランナー: ファイルのコンパイル（SassからCSSへ、TypeScriptからJavaScriptへ）、コードの圧縮（Minification）、テストの実行などの定型作業を自動化するツール（例: Gulp, Grunt）。Node.js上で実行されます。
    • パッケージマネージャー: npmやyarn, pnpmといったJavaScript/Node.jsのライブラリを管理するツール自体が、Node.jsで書かれています。
    • 開発サーバー: 静的なファイルを配信したり、コードの変更を検知して自動的にブラウザをリロードしたりする開発用のローカルサーバー（例: webpack-dev-server, Vite）。Node.js上で動きます。

    このように、Node.jsは直接ユーザーに見える部分（フロントエンド）を開発するためにも、裏側で様々な自動化や効率化を支える重要な役割を果たしています。

  5. デスクトップアプリケーション
    Node.jsとChromium（Chromeのオープンソース版）を組み合わせた Electron というフレームワークを使えば、Web技術（HTML, CSS, JavaScript）を使ってデスクトップアプリケーションを作成できます。

    • 有名なElectron製のアプリケーションには、VS Code、Slack、Discordなどがあります。

  6. マイクロサービス
    大規模なシステムを小さな独立したサービスの集まりとして構築するマイクロサービスアーキテクチャにおいて、Node.jsは軽量かつ高速なランタイムとして非常に適しています。サービスごとに最適な言語やフレームワークを選択できるのがマイクロサービスの利点であり、リアルタイム処理や高負荷なAPIサービスにはNode.jsが選ばれることが多いです。

  7. サーバーレス環境
    AWS Lambda, Google Cloud Functions, Azure Functionsなどのサーバーレスプラットフォームの多くは、Node.jsをサポートしています。Node.jsで記述した関数をイベント（HTTPリクエスト、データベースの変更、ファイルのアップロードなど）をトリガーとして実行させることができ、サーバー管理の負荷を軽減できます。

これらの用途からもわかるように、Node.jsは単なるWebサーバー技術にとどまらず、開発ワークフローの自動化からデスクトップアプリケーション、リアルタイムシステムまで、非常に幅広い分野で活用されています。そして、これらすべての開発をJavaScriptという単一言語で行える可能性がある点が、Node.jsの大きな魅力の一つです。

Node.jsを始めるための準備

Node.jsの世界へようこそ！実際にコードを書き始める前に、開発環境を整えましょう。必要なものはそれほど多くありません。

  1. Node.jsのインストール
  2. コードエディタ/IDE
  3. ターミナル/コマンドプロンプト

1. Node.jsのインストール

Node.jsを使い始めるには、まずお使いのコンピューターにNode.jsの実行環境をインストールする必要があります。

公式サイトからのダウンロード:
最も簡単な方法は、Node.jsの公式サイト（https://nodejs.org/）からインストーラーをダウンロードすることです。
公式サイトにアクセスすると、通常2つのダウンロードオプションが表示されます。

  • LTS (Long Term Support) 版: 長期サポート版です。安定しており、多くの開発現場で推奨されています。特に理由がなければ、こちらを選びましょう。
  • Current 版: 最新の機能が含まれていますが、まだ変更される可能性があり、LTS版より安定性に欠けることがあります。新しい機能を試したい場合や、特定の機能が必要な場合に選びます。

お使いのOS（Windows, macOS, Linux）に応じたインストーラーをダウンロードし、指示に従ってインストールを進めてください。ほとんどの場合、特別な設定は不要で、「次へ」「同意する」「インストール」といったボタンをクリックしていけば完了します。インストール時に、npm（Node Package Manager）も一緒にインストールされるのが一般的です。

パッケージマネージャーを使ったインストール (macOS/Linux 推奨):
macOSであればHomebrew、Linuxであればaptやyumといった各ディストリビューションのパッケージマネージャーを使ってインストールすることも可能です。

  • macOS (Homebrew):
    bash
    brew install node
  • Linux (Debian/Ubuntu):
    bash
    sudo apt update
    sudo apt install nodejs npm
    （バージョンが古い場合があるので、NodeSourceなどを利用する方が望ましい場合もあります）

バージョン管理ツール nvm の利用を推奨:
Node.jsは比較的新しいバージョンが頻繁にリリースされます。プロジェクトによっては古いバージョンのNode.jsが必要だったり、複数のプロジェクトで異なるバージョンを使いたかったりする場合があります。このような場合に便利なのが Node Version Manager (nvm) です。

nvmを使うと、複数のNode.jsバージョンを簡単にインストール、切り替え、管理できます。特に開発者にとっては非常に便利なツールなので、導入を検討することを強く推奨します。

  • nvmのインストール (macOS/Linux):
    以下のコマンドを実行します（最新のインストールスクリプトはnvmのリポジトリで確認してください）。
    bash
    curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
    インストール後、ターミナルを再起動するか、.bashrcや.zshrcなどの設定ファイルを再読み込みしてください。

  • nvmを使ったNode.jsのインストール:
    LTS版の最新バージョンをインストールする場合:
    bash
    nvm install --lts
    特定のバージョンをインストールする場合 (例: v18.17.1):
    bash
    nvm install 18.17.1

  • 使用するNode.jsバージョンの切り替え:
    bash
    nvm use --lts # LTS版を使う
    nvm use 18.17.1 # 特定のバージョンを使う

  • インストール済みのバージョンを確認:
    bash
    nvm ls

インストールの確認:
インストールが完了したら、ターミナル（またはコマンドプロンプト）を開き、以下のコマンドを実行してNode.jsとnpmが正しくインストールされ、バージョンが表示されるか確認してください。

bash
node -v
npm -v

それぞれのバージョン番号が表示されれば成功です。

2. コードエディタ/IDEの準備

JavaScript/Node.jsのコードを書くためのエディタが必要です。高機能なものからシンプルなものまで様々ありますが、初心者には以下のようなものがおすすめです。

  • Visual Studio Code (VS Code): Microsoftが提供する、無料かつ高機能なコードエディタです。JavaScript/Node.jsの開発に必要な機能（シンタックスハイライト、コード補完、デバッグ機能、ターミナル統合など）が豊富に揃っており、拡張機能も非常に充実しています。現在、最も多くの開発者に利用されています。
  • Sublime Text: シンプルで高速なコードエディタ。有料ですが、評価版を期間無制限で利用できます。
  • Atom: GitHubが開発していた無料のエディタ（開発は終了していますが、使用は可能です）。カスタマイズ性が高いです。

お好きなエディタをインストールして準備しておきましょう。VS Codeが最も人気があり、情報も豊富なので特におすすめです。

3. ターミナル/コマンドプロンプトの使い方

Node.jsは基本的にターミナル（macOS/Linux）やコマンドプロンプト/PowerShell（Windows）を使って操作します。
* Node.jsプログラムの実行 (node your_script.js)
* npmコマンドの実行 (npm install, npm start など)
* ファイルやディレクトリの作成/移動

基本的なコマンド操作に慣れておくと、Node.js開発がスムーズに進みます。

  • ディレクトリの移動: cd <ディレクトリ名>
  • 一つ上のディレクトリへ移動: cd ..
  • 現在のディレクトリを表示: pwd (macOS/Linux), cd (Windows)
  • ファイルやディレクトリの一覧を表示: ls (macOS/Linux), dir (Windows)
  • 新しいディレクトリを作成: mkdir <ディレクトリ名>
  • 新しいファイルを作成: touch <ファイル名> (macOS/Linux), type nul > <ファイル名> (Windows)
  • コマンドの実行: node <ファイル名>, npm install など

これらの基本的な操作をいくつか覚えておくと、以降の学習で困ることが減るでしょう。

これで、Node.jsを始めるための準備は完了です！

Node.jsの基本を学ぶ

開発環境が整ったところで、Node.jsの基本的な使い方を見ていきましょう。

1. REPLを使ってみる

Node.jsをインストールすると、対話型の実行環境である REPL (Read-Eval-Print Loop) も一緒にインストールされます。これは、コードを一行ずつ入力してすぐに結果を確認できる便利なツールです。簡単なコードの試行錯誤や、JavaScriptの文法の確認に役立ちます。

ターミナルを開き、node コマンドを実行してみてください。

bash
node

すると、プロンプト > が表示され、入力を待ち受ける状態になります。ここでJavaScriptコードを入力してEnterキーを押すと、すぐにそのコードが実行され、結果が表示されます。

“`

console.log(‘Hello, Node.js!’);
Hello, Node.js!
undefined
1 + 1
2
var message = ‘Node.jsは楽しい！’;
undefined
message
‘Node.jsは楽しい！’
function greet(name) { return ‘こんにちは、’ + name + ‘さん！’; }
undefined
greet(‘太郎’)
‘こんにちは、太郎さん！’
“`

REPLを終了するには、Ctrl + C を2回押すか、.exit と入力します。

REPLは手軽にコードを試すのに便利ですが、実際の開発ではコードをファイルに書いて実行するのが一般的です。

2. 簡単なJavaScriptファイルの実行

Node.jsでは、通常のJavaScriptファイルをそのまま実行できます。ファイルにコードを記述し、ターミナルから node ファイル名 というコマンドで実行します。

テキストエディタを開き、hello.js という名前で以下の内容のファイルを作成してください。

“`javascript
// hello.js
console.log(‘Node.jsからこんにちは！’);

var number = 10;
console.log(‘変数の値:’, number);

function add(a, b) {
return a + b;
}
console.log(‘1 + 2 =’, add(1, 2));
“`

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

bash
node hello.js

ファイルに書かれたコードが順番に実行され、console.log の出力がターミナルに表示されます。

Node.jsからこんにちは！
変数の値: 10
1 + 2 = 3

これで、あなたはNode.jsでJavaScriptコードを実行できるようになりました！

3. モジュールシステム (CommonJS)

実際のNode.jsアプリケーションは、単一のファイルで構成されることはほとんどありません。機能ごとにファイルを分割し、それらを組み合わせて開発します。この分割された機能単位を モジュール と呼びます。Node.jsは、モジュールを管理するための組み込みのシステムを持っています（歴史的にはCommonJS、現在はES Modulesも利用可能）。ここでは、広く使われているCommonJSについて解説します。

CommonJSでは、以下の2つのキーワードを使ってモジュールのインポートとエクスポートを行います。

  • require(): 他のファイル（モジュール）を読み込むために使用します。
  • module.exports: 現在のファイル（モジュール）が外部から利用できるように、機能（変数、関数、オブジェクトなど）を公開するために使用します。

例を見てみましょう。utils.js という名前で、簡単な足し算と引き算の関数を持つモジュールを作成します。

“`javascript
// utils.js
function add(a, b) {
return a + b;
}

function subtract(a, b) {
return a – b;
}

// add関数とsubtract関数を外部に公開する
module.exports = {
add: add,
subtract: subtract
};
// あるいはショートハンドで書くことも多い
// module.exports = { add, subtract };

// または、特定の関数だけを直接エクスポートすることも可能
// exports.add = add;
// exports.subtract = subtract;
“`

次に、この utils.js モジュールを利用する app.js ファイルを作成します。

“`javascript
// app.js
// utils.js モジュールを読み込む
// 同じディレクトリにある場合は ‘./ファイル名’ または ‘./ディレクトリ名/ファイル名’
const utils = require(‘./utils’);

const num1 = 10;
const num2 = 5;

// 読み込んだモジュールの関数を利用する
const sum = utils.add(num1, num2);
const difference = utils.subtract(num1, num2);

console.log(${num1} + ${num2} = ${sum}); // 10 + 5 = 15
console.log(${num1} - ${num2} = ${difference}); // 10 – 5 = 5
“`

app.js を実行してみましょう。

bash
node app.js

出力:
10 + 5 = 15
10 - 5 = 5

このように、utils.js で module.exports を使って公開した add と subtract 関数を、app.js で require() を使って読み込み、utils オブジェクト経由で利用できています。

Node.jsには、ファイルシステムを操作するfsや、HTTPサーバーを構築するhttpなど、あらかじめ組み込まれている便利なモジュール（ビルトインモジュール）が多数あります。これらはパスを指定せずに名前だけでrequire()を使って読み込めます。

“`javascript
// app.js でビルトインモジュールを使う例
const fs = require(‘fs’); // ファイルシステムモジュールを読み込み
const http = require(‘http’); // HTTPモジュールを読み込み

// fsモジュールの関数を使ってファイルを読み込む（非同期版）
fs.readFile(‘hello.js’, ‘utf8’, (err, data) => {
if (err) {
console.error(‘ファイルの読み込みに失敗しました:’, err);
return;
}
console.log(‘hello.js の内容:\n’, data);
});

console.log(‘ファイル読み込みを要求しました（これは非同期なので先に出力されることがあります）’);
“`

この例では、Node.jsに標準で組み込まれている fs モジュールを読み込んで、readFile という関数を使っています。require('fs') のように、パス指定なしでモジュール名だけで読み込めるものがビルトインモジュールです。

4. 非同期処理の基礎

先ほどNode.jsの重要な特徴として「非同期I/O」と「イベントループ」を挙げました。Node.jsで効率的なプログラミングを行う上で、非同期処理の扱いは避けて通れません。

非同期処理とは、処理の完了を待たずに次の処理に進み、完了した時に指定した処理（コールバックなど）を実行する方式です。これは特に時間のかかるI/O処理（ファイル読み書き、ネットワーク通信、データベースアクセスなど）で重要になります。Node.jsのビルトインモジュールの多くは、非同期APIを提供しています。

非同期処理を扱うための主な方法には、以下のものがあります。

  • コールバック関数 (Callback Functions):
    最も基本的な非同期処理のパターンです。非同期処理を行う関数に、処理完了後に実行してほしい関数（コールバック関数）を引数として渡します。

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

    // ファイルを非同期で読み込む（エラーファーストコールバック）
    fs.readFile(‘some_file.txt’, ‘utf8’, (err, data) => {
    if (err) {
    console.error(‘ファイルの読み込みに失敗しました:’, err);
    return;
    }
    console.log(‘ファイルの読み込みが完了しました。内容:\n’, data);
    });

    console.log(‘readFileを呼び出しました。結果は後でコールバックで通知されます。’);
    ``
    このコードを実行すると、「readFileを呼び出しました...」というメッセージが先に表示され、しばらくしてからファイルの読み込み完了メッセージと内容が表示されるのが一般的です。これは、    readFileが非同期だからです。fs.readFileはファイルの読み込みを開始するとすぐに制御を返し、JavaScriptコードの実行は継続されます。読み込みが完了した時点で、Node.jsのイベントループがそれを検知し、指定されたコールバック関数(err, data) => { … }` を実行します。

    コールバック関数は非同期処理の基本ですが、複数の非同期処理を連続して行う場合、コールバックの中にさらにコールバックを書く、というネストが深くなりやすく、「コールバック地獄（Callback Hell）」と呼ばれる、可読性や保守性の低いコードになりがちです。

  • Promise:
    コールバック地獄を解消するために登場したのがPromiseです。Promiseは、非同期処理の「最終的な完了（または失敗）」を表すオブジェクトです。非同期処理の結果を、その処理が完了するまで一時的に保持するようなイメージです。

    Promiseを使うと、非同期処理をチェーン（.then()で繋げる）して記述できるため、コールバックよりもコードが読みやすくなります。エラーハンドリングも.catch()でまとめて行えます。

    “`javascript
    const fs = require(‘fs’).promises; // fsモジュールのPromise版を読み込む

    // Promiseを使ったファイルの非同期読み込み
    fs.readFile(‘some_file.txt’, ‘utf8’)
    .then((data) => {
    console.log(‘ファイルの読み込みが完了しました (Promise)。内容:\n’, data);
    // 読み込んだデータを使って次の非同期処理を行う場合は、ここで別のPromiseを返す
    // return anotherAsyncOperation(data);
    })
    .catch((err) => {
    console.error(‘ファイルの読み込みに失敗しました (Promise):’, err);
    });

    console.log(‘readFile (Promise版) を呼び出しました。’);
    ``
    多くのNode.jsの非同期APIは、Promiseベースのインターフェースも提供しています（または、    util.promisify` を使ってコールバックベースのAPIをPromise化できます）。

  • async/await:
    Promiseをさらに簡潔かつ、同期的なコードを書いているかのように記述できるのが async/await です。ES2017で導入され、現在では非同期処理の記述方法として最も推奨されています。

    async キーワードを関数の前につけると、その関数は非同期関数となり、その中で await キーワードを使用できるようになります。await は、Promiseが解決される（完了または失敗する）まで非同期関数の実行を一時停止し、Promiseが解決されたらその結果を返します。

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

    async function readAndProcessFile() {
    console.log(‘async/await 関数を開始します。’);
    try {
    // Promiseが解決されるまでここで一時停止
    const data = await fs.readFile(‘some_file.txt’, ‘utf8’);
    console.log(‘ファイルの読み込みが完了しました (async/await)。内容:\n’, data);
    // 読み込んだデータを使った次の処理…
    // const processedData = await processDataAsync(data);
    // console.log(‘処理済みデータ:’, processedData);

    } catch (err) {
    // awaitで待機中のPromiseが失敗した場合、ここでキャッチされる
    console.error(‘エラーが発生しました (async/await):’, err);
    }
    console.log(‘async/await 関数を終了します。’);
    }

    readAndProcessFile(); // async関数を実行
    console.log(‘async/await 関数を呼び出しました（関数内の処理完了を待たずにすぐ次へ）’);
    “`

    この例でも、「async/await 関数を呼び出しました…」が先に表示され、ファイル読み込み完了メッセージが後から表示されるはずです。await はあくまで非同期関数内での一時停止であり、関数を呼び出した側のコードは待たずにすぐに次の行に移ります。

    async/await は非同期コードの可読性を大幅に向上させます。Promiseが理解できれば、async/await はさらに強力な武器となるでしょう。

非同期処理はNode.jsの根幹をなす部分です。最初は少し難しく感じるかもしれませんが、実際にコードを書きながら慣れていくことが重要です。

npm (Node Package Manager) とは？

Node.jsが爆発的に普及した理由の一つに、強力なパッケージ管理システム npm (Node Package Manager) の存在があります。npmは、Node.jsで利用できるライブラリやツール（これらを パッケージ または モジュール と呼びます）を管理するための標準的なツールです。

npmの役割

npmの主な役割は以下の通りです。

  1. パッケージのリポジトリ: 世界中の開発者が公開しているNode.jsパッケージが集まる巨大なオンラインレジストリ（倉庫）です。現在100万以上のパッケージが登録されています。
  2. パッケージのインストール: 必要なパッケージをオンラインレジストリからダウンロードし、プロジェクトにインストールするコマンドを提供します。
  3. 依存関係の管理: 自分のプロジェクトが依存しているパッケージや、そのパッケージがさらに依存しているパッケージ（依存関係の依存関係）を自動的に解決し、適切に管理します。
  4. プロジェクト情報の管理: package.json ファイルを使って、プロジェクトの名前、バージョン、説明、依存パッケージ、実行スクリプトなどの情報を一元管理します。
  5. スクリプトの実行: package.json に定義した開発タスク（テスト実行、ビルド、サーバー起動など）を簡単なコマンドで実行できます。

パッケージのインストール

npmを使ったパッケージのインストールは非常に簡単です。ターミナルでプロジェクトのディレクトリに移動し、npm install <パッケージ名> コマンドを実行します。

例えば、Webサーバー構築でよく使われるExpressフレームワークをインストールするには、以下のようにします。

bash
npm install express

このコマンドを実行すると、以下のことが起こります。

  1. npmがオンラインのnpmレジストリで express パッケージを探します。
  2. express パッケージが見つかったら、それをダウンロードします。
  3. express が依存している他のパッケージも自動的にダウンロードします。
  4. ダウンロードしたパッケージを、プロジェクトディレクトリ内の node_modules というフォルダに保存します。
  5. プロジェクトのルートディレクトリにある package.json ファイルに、express を依存関係として記録します（初めてインストールする場合や、すでにpackage.jsonがある場合）。また、package-lock.json というファイルが生成/更新され、インストールされたパッケージの正確なバージョンや依存関係のツリーが記録されます。

ローカルインストール vs グローバルインストール:

  • ローカルインストール (推奨): npm install <パッケージ名>
    パッケージは現在のプロジェクトディレクトリ内の node_modules フォルダにインストールされます。インストールされたパッケージは、そのプロジェクト内でのみ利用可能です。これは、プロジェクトごとに異なるバージョンのライブラリを使いたい場合に便利です。フレームワークやライブラリなど、プロジェクトのコードから require で読み込んで使うものは通常ローカルインストールします。

  • グローバルインストール: npm install -g <パッケージ名>
    パッケージはシステム全体のNode.js環境にインストールされます。どのディレクトリからでもそのパッケージのコマンドを実行できるようになります。コマンドラインツールとして利用するパッケージ（例: Create React App, Vue CLIなど、プロジェクトを作成するツール）はグローバルインストールすることがあります。ただし、最近ではnpx (npmの機能) を使ってグローバルインストールせずにコマンドを実行する方が推奨されています。

package.json ファイル

package.json ファイルは、Node.jsプロジェクトの「設定ファイル」「マニフェストファイル」のようなものです。プロジェクトのメタ情報や、npmを使った開発に必要な情報がJSON形式で記述されます。

新しいプロジェクトを開始する際に、プロジェクトディレクトリで npm init コマンドを実行すると、対話形式で package.json ファイルを簡単に作成できます。

bash
npm init

いくつかの質問（プロジェクト名、バージョン、説明、エントリーポイントなど）に答えていくと、package.json ファイルが生成されます。

json
// 生成される package.json の例
{
"name": "my-node-project",
"version": "1.0.0",
"description": "これは私の最初のNode.jsプロジェクトです。",
"main": "index.js", // このプロジェクトのエントリーポイントとなるファイル
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
},
"keywords": [],
"author": "",
"license": "ISC",
"dependencies": {
// ここに本番環境で必要なパッケージが記録される
},
"devDependencies": {
// ここに開発環境でのみ必要なパッケージ（テストツール、ビルドツールなど）が記録される
}
}

主要なフィールド:

  • name: プロジェクト名。npmレジストリで公開する場合、ユニークである必要があります。
  • version: プロジェクトのバージョン。
  • description: プロジェクトの説明。
  • main: このプロジェクトをモジュールとして require したときに、最初に読み込まれるファイル（エントリーポイント）。通常 index.js など。
  • scripts: よく使うコマンドに名前をつけて登録する場所（後述）。
  • dependencies: プロジェクトが実行される上で必要なパッケージ（本番環境でも必要）。npm install <パッケージ名> でインストールするとここに追加されます。
  • devDependencies: プロジェクトの開発中にのみ必要なパッケージ（テストツール、ビルドツール、リンターなど）。npm install <パッケージ名> --save-dev または npm install <パッケージ名> -D でインストールするとここに追加されます。

他の人が開発したNode.jsプロジェクトを始める際には、そのプロジェクトのディレクトリに移動し、npm install コマンドを実行するだけで、package.json に記述されたすべての依存パッケージが自動的にインストールされます。

“`bash

package.json があるディレクトリで実行

npm install
“`

npm scripts

package.json の scripts フィールドには、よく使うコマンドを登録しておくことができます。これにより、長く複雑なコマンドを毎回入力する手間が省け、チーム内でのコマンドの共通化にも役立ちます。

json
"scripts": {
"start": "node index.js", // プロジェクトを開始するコマンド
"dev": "nodemon index.js", // 開発中にファイル変更を監視して自動再起動するコマンド (nodemonは別途インストールが必要)
"test": "mocha", // テストを実行するコマンド (mochaは別途インストールが必要)
"build": "webpack --config webpack.config.js" // フロントエンドをビルドするコマンド (webpackは別途インストールが必要)
}

scripts に登録したコマンドは、npm run <スクリプト名> で実行できます。

bash
npm run start # -> node index.js が実行される
npm run dev # -> nodemon index.js が実行される
npm run test # -> mocha が実行される
npm run build # -> webpack --config webpack.config.js が実行される

start, test, install, stop などのいくつかのスクリプト名には特別な意味があり、run なしで実行できます（例: npm start, npm test）。

npm scriptsは、Node.js開発における開発ワークフローを定義する上で非常に重要な機能です。

npmの代替 (yarn, pnpm)

npm以外にも、JavaScript/Node.jsのパッケージマネージャーとして yarn (Facebook発) や pnpm が存在します。これらはnpmと同様の機能を提供しますが、インストール速度やディスク使用量、セキュリティ、依存関係の管理方法などに違いがあり、それぞれメリット・デメリットがあります。
特にpnpmは、パッケージを効率的に管理することでディスク容量を節約し、インストール速度も速いと注目されています。

初心者としてはまずnpmの使い方をしっかり理解すれば十分ですが、情報収集する中でこれらの名前が出てきたら、「npmの仲間なんだな」と認識しておくと良いでしょう。

簡単なWebサーバーを構築してみよう

Node.jsの最も代表的な用途の一つであるWebサーバーの構築を体験してみましょう。まずはNode.js標準の http モジュールを使ってみます。

新しいディレクトリを作成し、その中で作業を開始しましょう。

“`bash
mkdir my-web-server
cd my-web-server

必要であれば npm init -y で package.json を作成しておく

“`

server.js という名前でファイルを作成し、以下のコードを記述してください。

“`javascript
// server.js
const http = require(‘http’); // Node.js標準のhttpモジュールを読み込み

const hostname = ‘127.0.0.1’; // サーバーがリッスンするIPアドレス (localhost)
const port = 3000; // サーバーがリッスンするポート番号

// HTTPサーバーを作成する
const server = http.createServer((req, res) => {
// クライアントからリクエストがあるたびにこの関数が実行される

// レスポンスヘッダーを設定する (ステータスコード200 OK, コンテンツタイプをtext/plainに)
res.statusCode = 200;
res.setHeader(‘Content-Type’, ‘text/plain’);

// レスポンスボディを送信し、レスポンスを終了する
res.end(‘Hello, Node.js Server!\n’);
});

// 指定したIPアドレスとポート番号でサーバーを起動し、リクエストを待ち受ける
server.listen(port, hostname, () => {
// サーバー起動後に実行されるコールバック関数
console.log(サーバーが http://${hostname}:${port}/ で起動しました);
});
“`

このコードは、以下の処理を行っています。

  1. http モジュールを読み込みます。
  2. サーバーが待ち受けるIPアドレス (hostname) とポート番号 (port) を設定します。127.0.0.1 は localhost と同じで、自分のコンピューターを指します。ポート番号 3000 は一般的な開発用ポートです。
  3. http.createServer() メソッドを使ってHTTPサーバーインスタンスを作成します。このメソッドには、クライアントからのリクエストがあるたびに実行される リクエストリスナー関数 を渡します。この関数は、req (Request) と res (Response) という2つの引数を受け取ります。
    • req: クライアントからのリクエストに関する情報（URL、メソッド、ヘッダーなど）を持つオブジェクト。
    • res: クライアントに送り返すレスポンスを構築するためのオブジェクト。
  4. リクエストリスナー関数の中で、res.statusCode でHTTPステータスコード（200は成功）、res.setHeader でレスポンスヘッダー（コンテンツタイプ）を設定します。
  5. res.end() メソッドでレスポンスボディ（ここでは文字列 'Hello, Node.js Server!\n'）をクライアントに送信し、レスポンスを完了させます。
  6. server.listen() メソッドでサーバーを起動し、指定したポートでリクエストを待ち受ける状態にします。サーバーが正常に起動したら、第3引数のコールバック関数が実行されます。

サーバーを起動するには、ターミナルで my-web-server ディレクトリに移動し、以下のコマンドを実行します。

bash
node server.js

ターミナルに「サーバーが http://127.0.0.1:3000/ で起動しました」というメッセージが表示されたら成功です。

次に、Webブラウザを開き、アドレスバーに http://localhost:3000/ と入力してアクセスしてみてください。ブラウザに「Hello, Node.js Server!」という文字列が表示されるはずです。

ターミナルに戻り、サーバーを停止するには Ctrl + C を押します。

この例は最もシンプルなWebサーバーですが、Node.jsでWebサービスを提供するための基本構造を理解できたはずです。実際には、リクエストのURLに応じて異なる処理をしたり（ルーティング）、POSTデータを受け取ったり、データベースと連携したりといった複雑な処理が必要になります。これらの処理を効率的に行うために、ExpressのようなWebフレームワークが利用されます。

Expressフレームワーク入門

先ほどの http モジュールを使ったサーバーは非常に基本的なものでした。実際のWebアプリケーション開発では、ルーティング（どのURLへのリクエストをどの処理に振り分けるか）、ミドルウェア（リクエスト処理の前後に共通の処理を挟む仕組み）、テンプレートエンジンの統合など、様々な機能が必要になります。これらの機能をまとめて提供し、開発を効率化してくれるのが Webフレームワーク です。

Node.jsで最も人気があり、広く使われているWebフレームワークが Express.js です。シンプルで軽量ながら、WebアプリケーションやAPIサーバー開発に必要な機能が揃っています。

Expressを使ってみましょう。先ほどの my-web-server ディレクトリ内に、Expressをインストールします。

bash
cd my-web-server
npm install express

インストールが完了すると、node_modules ディレクトリと package-lock.json が作成/更新され、package.json の dependencies に express が追加されます。

次に、express-server.js という名前でファイルを作成し、以下のコードを記述してください。

“`javascript
// express-server.js
const express = require(‘express’); // Expressモジュールを読み込み
const app = express(); // Expressアプリケーションインスタンスを作成
const port = 3000; // ポート番号

// ルーティングの設定
// GETリクエストで ‘/’ パスにアクセスがあった場合の処理
app.get(‘/’, (req, res) => {
res.send(‘Hello from Express!’); // レスポンスとして文字列を送信
});

// GETリクエストで ‘/about’ パスにアクセスがあった場合の処理
app.get(‘/about’, (req, res) => {
res.send(‘このページはExpressで作られています。’);
});

// GETリクエストで ‘/users/:userId’ パスにアクセスがあった場合の処理
// ‘:userId’ の部分は可変（パスパラメータ）
app.get(‘/users/:userId’, (req, res) => {
const userId = req.params.userId; // パスパラメータの値を取得
res.send(ユーザーID: ${userId} の情報を表示します。);
});

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

このコードは、以下の処理を行っています。

  1. express モジュールを読み込み、express() を呼び出してアプリケーションインスタンス app を作成します。
  2. app.get() メソッドを使ってルーティングを設定します。これは、特定のHTTPメソッド（ここではGET）とパスに対するリクエストが来たときに実行される処理を定義します。
    • app.get('/', ...): ルートパス (/) へのGETリクエストに対する処理。
    • app.get('/about', ...): /about パスへのGETリクエストに対する処理。
    • app.get('/users/:userId', ...): /users/ の後に任意の文字列が続くパスへのGETリクエストに対する処理。:userId の部分はパスパラメータと呼ばれ、req.params.userId でその値を取得できます。
      リクエストハンドラー関数は、req (Request) と res (Response) オブジェクトを受け取る点は http モジュールと同じですが、Expressはこれらのオブジェクトに便利なメソッド（res.send(), req.params など）を追加しています。
  3. app.listen() メソッドでサーバーを指定したポートで起動します。

Expressサーバーを起動するには、ターミナルで my-web-server ディレクトリに移動し、以下のコマンドを実行します。

bash
node express-server.js

ターミナルにメッセージが表示されたら、ブラウザで以下のURLにアクセスしてみてください。

  • http://localhost:3000/ -> “Hello from Express!”
  • http://localhost:3000/about -> “このページはExpressで作られています。”
  • http://localhost:3000/users/123 -> “ユーザーID: 123 の情報を表示します。”
  • http://localhost:3000/users/abc -> “ユーザーID: abc の情報を表示します。”
  • 上記以外のURL -> Expressのデフォルトの404 Not Foundページが表示される

このように、Expressを使うと、URLごとに処理を振り分けるルーティングが非常に簡単に設定できます。

ミドルウェア (Middleware) の概念:

Expressにおける重要な概念に ミドルウェア があります。ミドルウェアとは、リクエストが最終的なルートハンドラーに到達するまでの間に、順番に実行される関数群のことです。ミドルウェアは以下のことができます。

  • リクエストオブジェクト (req) やレスポンスオブジェクト (res) を変更する。
  • データベースへの接続を確立するなど、必要な準備を行う。
  • ログ出力や認証処理を行う。
  • レスポンスを終了させ、後続のミドルウェアやルートハンドラーへの処理を渡さない。
  • 次のミドルウェアまたはルートハンドラーに処理を渡すために、next() 関数を呼び出す。

例えば、すべてのリクエストに対してログを出力するシンプルなミドルウェアは以下のようになります。

``javascript
// ミドルウェア関数
const requestLogger = (req, res, next) => {
console.log(${req.method} ${req.url} – ${new Date().toISOString()}`);
next(); // 次の処理（次のミドルウェアまたはルートハンドラー）へ進む
};

// アプリケーション全体でミドルウェアを使用する
app.use(requestLogger);

// … ルーティング設定など …
“`

app.use(middlewareFunction) のように記述することで、そのミドルウェアが指定したパス（パス指定なしの場合はすべてのパス）へのリクエストに対して適用されます。ミドルウェアは app.use() を記述した順番に実行されます。

Expressには、静的ファイルの配信 (express.static) や、POSTデータの解析 (express.json, express.urlencoded) など、便利な組み込みミドルウェアや、サードパーティ製のミドルウェア（例: セッション管理、認証、CORS設定など）が多数存在します。これらを組み合わせることで、様々な機能を簡単にアプリケーションに追加できます。

このExpressの例はまだ基本的なものですが、Node.jsで実際のWebアプリケーションを構築する上での重要なステップとなります。

非同期処理をもっと深く理解する (実践)

Node.js開発において、非同期処理は避けて通れないテーマです。ここでは、より実践的な例を通して非同期処理への理解を深めます。

ファイル読み書き (fs モジュール)

Node.jsのビルトインモジュールである fs (File System) モジュールは、ファイルの読み書きやディレクトリ操作など、ファイルシステムに関する機能を提供します。多くの関数が非同期版と同期版の両方を提供していますが、Node.jsでは非同期版を使うことが強く推奨されます。

非同期版 (fs.readFile, fs.writeFile):

“`javascript
const fs = require(‘fs’); // 標準のコールバックベースのfsモジュール

// 非同期でファイルを読み込む
fs.readFile(‘example.txt’, ‘utf8’, (err, data) => {
if (err) {
console.error(‘ファイルの読み込みに失敗:’, err);
return;
}
console.log(‘非同期読み込み完了:\n’, data);

// 読み込んだ内容の一部を非同期で別のファイルに書き込む
const partialData = data.substring(0, 20);
fs.writeFile(‘output.txt’, 最初の20文字: ${partialData}, (err) => {
if (err) {
console.error(‘ファイルの書き込みに失敗:’, err);
return;
}
console.log(‘非同期書き込み完了: output.txt’);
});
});

console.log(‘ファイル処理を非同期で行っています…’);
“`

このコードを実行すると、「ファイル処理を非同期で行っています…」というメッセージが先に表示され、その後に読み書き完了のメッセージが表示される可能性があります。これは、readFile と writeFile が非同期関数であり、処理の完了を待たずに次のコードが実行されるためです。

同期版 (fs.readFileSync, fs.writeFileSync):

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

console.log(‘同期処理を開始します。’);

try {
// 同期でファイルを読み込む – 読み込み完了までここでブロックされる
const data = fs.readFileSync(‘example.txt’, ‘utf8’);
console.log(‘同期読み込み完了:\n’, data);

// 同期で別のファイルに書き込む – 書き込み完了までここでブロックされる
const partialData = data.substring(0, 20);
fs.writeFileSync(‘output_sync.txt’, 最初の20文字: ${partialData});
console.log(‘同期書き込み完了: output_sync.txt’);

} catch (err) {
console.error(‘同期処理中にエラーが発生:’, err);
}

console.log(‘同期処理を終了しました。’);
“`

この同期版のコードを実行すると、「同期処理を開始します。」→「同期読み込み完了…」→「同期書き込み完了…」→「同期処理を終了しました。」の順に、書かれた順番通りにメッセージが表示されます。同期版は処理が完了するまで次の行に進まないため、コードの流れは分かりやすいですが、Node.jsのイベントループをブロックしてしまうため、特にWebサーバーのような同時接続を多数扱うアプリケーションでは避けるべきです。同期I/Oは、起動時の設定ファイルの読み込みなど、アプリケーションの初期化処理など限られた場面でのみ使用します。

Promise と async/await を使う

先述の通り、Promiseやasync/awaitを使うことで、非同期処理のコードをより読みやすく、管理しやすくできます。Node.js v10以降、多くの非同期ビルトインモジュールがPromiseベースのAPI (require('fs').promises) を提供するようになりました。

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

async function processFiles() {
console.log(‘async/await によるファイル処理を開始します。’);
try {
// ファイルを非同期で読み込む (awaitで待つ)
const data = await fs.readFile(‘example.txt’, ‘utf8’);
console.log(‘async/await 読み込み完了:\n’, data);

// 読み込んだ内容を使って別のファイルを非同期で書き込む (awaitで待つ)
const partialData = data.substring(0, 20);
await fs.writeFile('output_async.txt', `最初の20文字: ${partialData}`);
console.log('async/await 書き込み完了: output_async.txt');

// 別のファイルも非同期で読み込む (連続して非同期処理を実行)
const outputData = await fs.readFile('output_async.txt', 'utf8');
console.log('async/await output_async.txt 読み込み完了:\n', outputData);

} catch (err) {
console.error(‘async/await 処理中にエラーが発生:’, err);
}
console.log(‘async/await によるファイル処理を終了します。’);
}

// 仮の example.txt ファイルを作成 (初回実行時などに必要)
fs.writeFile(‘example.txt’, ‘これはNode.jsの非同期ファイル読み書きの例です。もう少し長いテキストにしてみましょう。’)
.then(() => {
// example.txt 作成後、非同期処理関数を実行
processFiles();
console.log(‘processFiles関数を呼び出しました。’); // これはreadAndProcessFile内のconsoleより先に表示されうる
})
.catch(err => console.error(‘example.txt の作成に失敗:’, err));

“`

このコードは、example.txt の作成も非同期で行い、それが完了してから processFiles 関数（これも非同期）を実行しています。processFiles 関数の中では、await を使うことで非同期処理の完了を待ちながらも、コードの見た目は同期的な処理の流れに近くなり、非常に読みやすくなります。

エラーハンドリングも try...catch ブロックを使うことで、同期的なコードと同じように記述できます。await で待機中のPromiseがrejectされた場合、catchブロックにジャンプします。

非同期処理はNode.jsのパフォーマンスの鍵となるため、コールバック、Promise、async/awaitそれぞれの記述方法と、なぜ非同期処理が必要なのかをしっかりと理解することが、Node.jsマスターへの道です。

データベース連携 (簡単な例)

ほとんどのWebアプリケーションやAPIサーバーは、データを永続的に保存するためにデータベースと連携します。Node.jsから様々なデータベース（リレーショナルデータベースやNoSQLデータベース）に接続し、操作することができます。

主要なデータベースとそのNode.jsからのアクセス方法の概要です。

  • リレーショナルデータベース (RDBMS): PostgreSQL, MySQL, SQLite, SQL Serverなど。

    • 各データベースに対応したnpmパッケージ（例: pg for PostgreSQL, mysql2 for MySQL, sqlite3 for SQLite）を使います。
    • 複雑なクエリやスキーマ管理には、ORM (Object-Relational Mapper) と呼ばれるツールを使うことが多いです。代表的なORMに Sequelize, TypeORM, Prisma などがあります。これらはJavaScript/TypeScriptのオブジェクトとデータベースのテーブルをマッピングし、より抽象的で安全な方法でデータベースを操作できます。

  • NoSQLデータベース: MongoDB, Redis, Cassandraなど。

    • 各データベースに対応したnpmパッケージ（例: mongodb for MongoDB, ioredis for Redis）。
    • MongoDBなどドキュメント指向データベースの場合、ODM (Object-Document Mapper) と呼ばれるツールを使うことが多いです。代表的なODMに Mongoose (for MongoDB) があります。

ここでは、手軽に試せるファイルベースのRDBMSである SQLite を使った簡単な例を紹介します。SQLiteを使うには、sqlite3 というnpmパッケージをインストールします。

bash
npm install sqlite3

次に、database.js という名前でファイルを作成し、以下のコードを記述してください。

“`javascript
// database.js
const sqlite3 = require(‘sqlite3’).verbose(); // sqlite3モジュールを読み込み、冗長モードを有効に

// データベースファイルを開く（ファイルが存在しない場合は作成される）
// ‘:memory:’ を指定すると、メモリ上に一時的なデータベースを作成する
const db = new sqlite3.Database(‘my_database.sqlite’, (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テーブルが存在することを確認しました。’);
}
});
}
});

// データを挿入する関数
function insertUser(name, age, callback) {
const sql = ‘INSERT INTO users (name, age) VALUES (?, ?)’;
db.run(sql, [name, age], function(err) { // function(err) {} を使うことでthis.lastIDにアクセスできる
if (err) {
console.error(‘データ挿入エラー:’, err.message);
callback(err);
} else {
console.log(データ挿入成功: ID = ${this.lastID});
callback(null, this.lastID);
}
});
}

// データを取得する関数
function getAllUsers(callback) {
const sql = ‘SELECT id, name, age FROM users’;
db.all(sql, [], (err, rows) => {
if (err) {
console.error(‘データ取得エラー:’, err.message);
callback(err);
} else {
console.log(‘データ取得成功:’);
callback(null, rows);
}
});
}

// サンプルとしてデータ操作を実行
insertUser(‘山田 太郎’, 30, (err, userId) => {
if (err) {
console.error(‘ユーザー挿入に失敗’);
return;
}

insertUser(‘佐藤 花子’, 25, (err, userId) => {
if (err) {
console.error(‘ユーザー挿入に失敗’);
return;
}

getAllUsers((err, users) => {
  if (err) {
    console.error('ユーザー一覧取得に失敗');
    return;
  }
  console.log('登録されているユーザー一覧:');
  users.forEach(user => {
    console.log(`ID: ${user.id}, 名前: ${user.name}, 年齢: ${user.age}`);
  });

  // アプリケーション終了時にデータベース接続を閉じる (実際のサーバーでは適切に管理が必要)
  db.close((err) => {
    if (err) {
      console.error('データベース切断エラー:', err.message);
    } else {
      console.log('データベース接続を閉じました。');
    }
  });
});

});
});
“`

このコードを実行すると、my_database.sqlite というファイルが作成され、その中に users テーブルが作られ、データが挿入・取得されます。

bash
node database.js

出力例:
データベースに接続しました。
usersテーブルが存在することを確認しました。
データ挿入成功: ID = 1
データ挿入成功: ID = 2
データ取得成功:
登録されているユーザー一覧:
ID: 1, 名前: 山田 太郎, 年齢: 30
ID: 2, 名前: 佐藤 花子, 年齢: 25
データベース接続を閉じました。

この例では、sqlite3 モジュールが非同期処理にコールバック関数を使用していることがわかります。実際の開発では、これらの非同期APIをPromise化したり、ORM/ODMを使ったりして、コードの可読性や保守性を高めるのが一般的です。

データベース連携は、Node.jsで動的なアプリケーションを開発する上で不可欠な要素です。まずはシンプルな操作から始め、必要に応じてORM/ODMやより複雑なクエリ、非同期処理の管理方法を学んでいくと良いでしょう。

テストについて

ソフトウェア開発において、書いたコードが意図通りに動くことを確認するためのテストは非常に重要です。Node.jsでも、様々なテストツールやフレームワークを使ってコードをテストできます。

なぜテストが必要か？

  • 品質の向上: バグを早期に発見し、修正することで、ソフトウェアの品質を高めます。
  • 変更への耐性: コードを変更したり、機能を追加したりする際に、既存の機能が壊れていないかを確認できます。これにより、安心してリファクタリングや機能拡張を行えます。
  • コードの理解: テストコードは、そのコードがどのように使われ、何を期待しているのかを示すドキュメントとしても機能します。
  • 開発速度の向上: 長期的には、バグ修正にかかる時間を減らし、開発サイクルを速めることに繋がります。

Node.jsでよく使われるテストフレームワーク

Node.jsエコシステムには、様々なテストフレームワークやライブラリがあります。

  • Jest: Facebook（現Meta）が開発した、JavaScriptのテストフレームワークです。特にReactアプリケーションでよく使われますが、Node.jsのバックエンドコードのテストにも非常に適しています。設定が簡単で、アサーションライブラリ（テストの検証部分）、モック機能、カバレッジレポートなどが統合されています。人気があり、情報も豊富です。
  • Mocha: 柔軟性が高く、様々なアサーションライブラリ（Chai, Should.jsなど）やモックライブラリ（Sinon）と組み合わせて使用できます。Jestよりも設定の自由度が高い一方、個別のライブラリを選択・設定する必要があります。
  • Chai: JavaScriptのためのアサーションライブラリです。Mochaなど他のテストフレームワークと組み合わせて、テストの検証部分（例: expect(result).to.equal(expected)）を記述するのに使われます。

Jestを使った簡単なテストコード例

最も人気の高いJestを使って、簡単なNode.js関数のテストコードを書いてみましょう。

まず、Jestをプロジェクトにインストールします。開発時のみ必要なツールなので、devDependencies としてインストールします。

bash
npm install jest --save-dev

次に、テスト対象となるコードとして、math.js というファイルを作成します。

“`javascript
// math.js
function add(a, b) {
return a + b;
}

function subtract(a, b) {
return a – b;
}

module.exports = { add, subtract };
“`

この math.js をテストするためのファイルを作成します。Jestは、通常 __tests__ ディレクトリ内にテストファイルを配置するか、テスト対象ファイルと同じディレクトリに .test.js または .spec.js というサフィックスを付けたファイル名で配置することを推奨しています。ここでは、math.test.js というファイル名で作成します。

“`javascript
// math.test.js
const { add, subtract } = require(‘./math’); // テスト対象のモジュールを読み込み

// describe ブロックでテストスイート（関連するテストの集まり）を定義
describe(‘Math Functions’, () => {

// it または test ブロックで個別のテストケースを定義
test(‘add function should correctly add two numbers’, () => {
// アサーション（検証）：add(2, 3) の結果が 5 であることを期待する
expect(add(2, 3)).toBe(5);
expect(add(-1, 5)).toBe(4);
expect(add(0, 0)).toBe(0);
});

test(‘subtract function should correctly subtract two numbers’, () => {
// アサーション（検証）：subtract(5, 3) の結果が 2 であることを期待する
expect(subtract(5, 3)).toBe(2);
expect(subtract(10, 20)).toBe(-10);
expect(subtract(0, 0)).toBe(0);
});

// エッジケースやエラーケースのテストも重要
test(‘add function should handle floating point numbers’, () => {
expect(add(0.1, 0.2)).toBeCloseTo(0.3); // 浮動小数点数の比較にはtoBeCloseToを使う
});
});
“`

describe でテスト対象のグループを、test (または it) で個別のテスト項目を記述します。expect( actual ).matcher( expected ) という形式で、実際の結果 (actual) が期待する結果 (expected) と一致するかどうかを検証します。toBe, toEqual, toBeCloseTo など、様々なマッチャーが用意されています。

テストを実行するには、package.json の scripts にテストコマンドを追加するのが一般的です。npm init で作成したデフォルトの test スクリプトを修正しましょう。

json
// package.json の scripts 部分を修正
"scripts": {
"test": "jest" // テストコマンドを jest に変更
},

これで、ターミナルで以下のコマンドを実行すると、Jestがテストファイルを見つけてテストを実行してくれます。

bash
npm test

テストが成功すると、以下のような結果が表示されます。

“`

[email protected] test /path/to/my-node-project
jest

PASS ./math.test.js
Math Functions
✓ add function should correctly add two numbers (3 ms)
✓ subtract function should correctly subtract two numbers (1 ms)
✓ add function should handle floating point numbers (1 ms)

Test Suites: 1 passed, 1 total
Tests: 3 passed, 3 total
Snapshots: 0 total
Time: 1.234 s
Ran all test suites.
“`

もしテストが失敗すると、どのテストで、どのような理由で失敗したのかが詳しく表示されます。

テストは最初の手間がかかるように思えますが、コードの信頼性を高め、長期的な開発効率を向上させるために不可欠なプラクティスです。Node.js開発においても、積極的にテストを取り入れていくことを強く推奨します。

デバッグ方法

プログラムにバグはつきものです。バグが発生したときに、原因を特定し修正する作業を デバッグ と呼びます。Node.jsアプリケーションのデバッグ方法をいくつか紹介します。

1. console.log() を使う

最も手軽で、初心者から上級者まで広く使われるデバッグ方法です。変数の値やコードの実行パスを確認したい場所に console.log() 文を挿入し、プログラムを実行してターミナルに出力されるログを確認します。

“`javascript
function processData(data) {
console.log(‘processData関数開始’); // 実行されたか確認
console.log(‘入力データ:’, data); // 変数の値を確認

if (!data) {
console.log(‘データがありません。処理をスキップします。’); // 特定の条件になったか確認
return null;
}

const result = data.toUpperCase();
console.log(‘処理結果:’, result); // 処理結果を確認
console.log(‘processData関数終了’); // 実行フローを確認
return result;
}

processData(‘hello’);
processData(”); // データがない場合
“`

シンプルですが、多くの場面で有効なデバッグ手法です。ただし、ログが増えすぎるとかえって見づらくなるため、適切な場所に絞って使用することが大切です。

2. Node.jsの組み込みデバッガー

Node.jsには、コマンドラインから使える組み込みのデバッガーがあります。プログラムの実行を一時停止させたり、ステップ実行したり、変数の値を検査したりといった、より高度なデバッグが可能です。

デバッグモードでNode.jsプログラムを起動するには、inspect フラグを付けて node コマンドを実行します。

bash
node inspect your_script.js

すると、デバッガーが起動し、ブレークポイント（実行を一時停止したい場所）を設定したり、コマンドを入力したりできるようになります。

  • c または cont: 実行を再開する。
  • n または next: 次の行にステップ実行する。
  • s または step: 関数呼び出しの中に入る。
  • o または out: 現在の関数から抜け出す。
  • repl: 現在のスコープで変数を調べたり、JavaScriptコードを実行したりできるREPLモードに入る。終了するには Ctrl + C を押す。
  • list(): 現在実行中のコード周辺を表示する。
  • setBreakpoint('ファイル名', 行番号) または sb('ファイル名', 行番号): ブレークポイントを設定する。

組み込みデバッガーは強力ですが、コマンドライン操作に慣れていないと少し使いにくいかもしれません。

3. VS Codeなどのエディタを使ったデバッグ

VS Codeのような高機能なコードエディタは、GUIベースの統合デバッグ機能を提供しています。これが最も効率的で使いやすいデバッグ方法と言えるでしょう。

VS CodeでNode.jsプロジェクトを開き、デバッグしたい行番号の左側をクリックすると、ブレークポイントを設定できます（赤い丸が表示されます）。

次に、VS Codeの左側にあるデバッグアイコンをクリックし、「実行とデバッグ」ボタンを押します。通常、Node.js環境として自動的に認識され、デバッグが開始されます。

プログラムの実行は設定したブレークポイントで一時停止します。デバッグサイドバーでは、ローカル変数やグローバル変数の値を調べたり、コールスタック（どの関数からどの関数が呼び出されたかの履歴）を確認したりできます。また、デバッグコントロール（再生、ステップオーバー、ステップイン、ステップアウト、停止など）を使って、コードの実行を制御できます。

VS Codeの統合デバッガーは非常に強力で直感的です。本格的にNode.js開発を行うなら、エディタのデバッグ機能を活用することをおすすめします。

バグは開発プロセスの一部です。効率的なデバッグ方法を身につけることは、開発効率とストレスを軽減する上で非常に重要です。

よくある質問とつまづきやすいポイント

Node.jsを学び始めた初心者がよく疑問に思ったり、つまづいたりしやすいポイントをいくつか紹介します。

1. 非同期処理の理解とコールバック地獄

Node.jsの非同期処理は強力ですが、最初は同期処理との違いや、非同期処理の流れを追うのに混乱することがあります。特に、非同期処理が複数ネストする場合のコールバック地獄は、コードを追いにくくし、エラーハンドリングも複雑にします。

  • 解決策: Promiseやasync/awaitといった、よりモダンな非同期処理の記述方法を積極的に使いましょう。これにより、コードの可読性が向上し、エラーハンドリングもtry...catchで統一的に行いやすくなります。最初は少し難しく感じるかもしれませんが、慣れることが重要です。

2. this の扱い

JavaScriptの this キーワードは、呼び出され方によって参照するオブジェクトが変わるという特性があります。特にコールバック関数内で this を使う場合に、意図しないオブジェクトを参照してしまうことがあります。

  • 解決策: Node.js開発では、アロー関数 (() => {}) を積極的に使うことが推奨されます。アロー関数は自身では this を持たず、外側のスコープの this を継承します。これにより、this の参照が予測しやすくなります。または、bind() メソッドを使って関数の this の値を固定する方法もあります。

3. モジュール解決の仕組み

require() や import を使ってモジュールを読み込む際、Node.jsがどのようにしてそのモジュールファイルを見つけるのか（モジュール解決の仕組み）が最初は分かりにくいかもしれません。

  • 解決策:
    • パスが ./ または ../ で始まる場合、指定された相対パスにあるファイルを読み込もうとします。
    • パスが / で始まる場合、ルートディレクトリからの絶対パスにあるファイルを読み込もうとします。
    • パスが ./, ../, / で始まらない場合（例: require('express'), require('fs')）、Node.jsはそれをコアモジュール（ビルトインモジュール）か、または node_modules ディレクトリにインストールされたサードパーティモジュールであると解釈します。node_modules の探索は、現在のディレクトリから開始し、親ディレクトリを遡って行われます。
      この仕組みを理解しておくと、モジュールが見つからないといったエラー（Cannot find module '...'）が発生した際に原因を特定しやすくなります。

4. ブロッキング処理とイベントループ

Node.jsは非同期I/Oによって高いパフォーマンスを発揮しますが、シングルスレッドのJavaScript実行環境内でCPU負荷の高い同期処理を行うと、イベントループがブロックされてしまい、他の処理が滞ってしまう可能性があります。

  • 解決策: 時間のかかる計算処理や同期I/O処理は、可能な限り避けましょう。もし避けられない場合は、子プロセスを生成して処理をオフロードする (child_process モジュール) か、Worker Threads (Node.js v10.5.0以降) を利用して別スレッドで実行することを検討します。ほとんどのWebアプリケーションのボトルネックはI/O処理にあるため、非同期I/Oを適切に使うことがパフォーマンス最適化の基本です。

5. エラーハンドリングの重要性

非同期処理が多いNode.jsでは、エラーハンドリングが複雑になりがちです。エラーを適切に処理しないと、アプリケーションがクラッシュしたり、予期しない動作をしたりする可能性があります。

  • 解決策: コールバックベースの非同期処理では「エラーファーストコールバック」（コールバック関数の最初の引数にエラーオブジェクト、2番目以降に結果を渡す）という規約に従い、必ずエラーチェックを行いましょう。Promiseでは .catch() を使い、async/awaitでは try...catch を使うことで、エラーを一箇所でまとめて処理できます。また、Node.jsには予期しないエラーをキャッチするための process.on('uncaughtException', ...) や process.on('unhandledRejection', ...) といった仕組みもありますが、これらは最後の砦であり、可能な限りそれぞれの非同期処理内でエラーをハンドリングすることが重要です。

これらのポイントを意識しながら学習を進めることで、Node.js開発のスキルを効果的に向上させることができるでしょう。

次のステップ

この記事でNode.jsの基本的な概念、開発環境の構築、基本的なコードの実行、npmの使い方、簡単なWebサーバー構築、非同期処理、データベース連携、テスト、デバッグについて学びました。これはNode.jsの世界の入り口に過ぎません。ここからさらにスキルアップしていくための次のステップをいくつか紹介します。

  • より進んだWebフレームワークの学習: Expressはシンプルですが、より大規模で構造化されたアプリケーションを開発するには、NestJSやKoa.jsといった他のフレームワークも検討する価値があります。NestJSはTypeScriptとの相性が良く、大規模なAPI開発に適しています。
  • データベース知識の深化: 特定のデータベース（PostgreSQL, MongoDBなど）を選び、そのデータベースの特性や、Node.jsからのより高度な操作（トランザクション、インデックス、スキーマ設計など）について深く学びましょう。また、SequelizeやMongooseのようなORM/ODMの使い方を習得すると、データベース操作が格段に効率化されます。
  • 認証・認可: ユーザー認証（ログイン機能など）や認可（どのユーザーがどの操作を許可されるか）は、多くのWebアプリケーションで必須の機能です。OAuth, JWT (JSON Web Tokens), セッション管理などの技術を学び、Node.jsで実装する方法を習得しましょう。Passport.jsのような認証ミドルウェアがよく使われます。
  • セキュリティ: Webアプリケーションは様々なセキュリティリスクにさらされます。XSS (クロスサイトスクリプティング), CSRF (クロスサイトリクエストフォージェリ), SQLインジェクションなどの一般的な脆弱性とその対策について学びましょう。HTTPS化、入力値の検証、パスワードの安全な保存方法なども重要です。
  • API開発の実践: RESTful APIの設計原則や、GraphQLといった新しいAPI技術について学び、Node.jsで本格的なAPIサーバーを構築する練習をしましょう。
  • リアルタイムアプリケーション: WebSocketを使ったチャットアプリケーションなど、リアルタイム性の高いアプリケーション開発に挑戦してみましょう。Socket.IOは非常に便利なライブラリです。
  • パフォーマンス最適化: 大規模なアプリケーションでは、パフォーマンスが重要になります。Node.jsの非同期処理をより深く理解し、プロファイリングツールを使ってパフォーマンスのボトルネックを見つけ、改善する方法を学びましょう。
  • デプロイ: 開発したNode.jsアプリケーションをインターネット上に公開する方法を学びましょう。Heroku, AWS (EC2, Lambda, Elastic Beanstalk), Google Cloud Platform (App Engine, Cloud Functions), Vercel, Netlifyなどのクラウドプラットフォームへのデプロイ方法を実践します。PM2のようなプロセスマネージャーを使って、Node.jsアプリケーションを安定して実行・監視する方法も知っておくと良いでしょう。
  • TypeScript: JavaScriptに静的型付けを追加したTypeScriptは、大規模なプロジェクトや複数人での開発において、コードの品質と保守性を大きく向上させます。Node.js開発でもTypeScriptの採用が進んでいます。
  • コミュニティへの参加: Stack Overflowで質問したり、Node.jsや利用しているライブラリの公式ドキュメントを読んだり、GitHubで他の開発者のコードを見たり、勉強会に参加したりするなど、コミュニティと関わることも学習を深める上で非常に有効です。

学習の道は続きますが、焦る必要はありません。一つずつ着実に、興味のある分野から深めていくのが良いでしょう。

まとめ：Node.jsの可能性は無限大

この記事では、Node.jsがどのようにして生まれたのか、ブラウザJavaScriptとの違い、非同期I/Oとイベントループといった核心的な概念、そしてNode.jsで何ができるのか（Webサーバー、API、CLIツール、リアルタイム、ビルドツールなど）を幅広く解説しました。さらに、Node.jsのインストール方法から、REPL、モジュール、非同期処理、npm、簡単なWebサーバー、データベース連携、テスト、デバッグといった基本的な使い方についても、コード例を交えながら具体的に見てきました。

Node.jsは、JavaScriptという多くの開発者にとって馴染みのある言語を使って、サーバーサイドを含む多様なアプリケーションを開発できる強力なプラットフォームです。非同期・イベント駆動のモデルによる高いパフォーマンスと、npmという巨大なエコシステムが生み出す豊富なライブラリによって、開発者は多くの機能をゼロから作る必要なく、効率的にアプリケーションを構築できます。

もちろん、Node.jsにも向き不向きがあります。CPU負荷の高い処理が中心のアプリケーションには、PythonやGoなど、並列処理が得意な言語の方が適している場合もあります。しかし、I/Oバウンドな処理が中心となるWebサービスやAPI、リアルタイムアプリケーションにおいては、Node.jsはその強みを最大限に発揮します。

あなたがもし、フロントエンド開発の経験があってバックエンドにも挑戦したい、あるいはJavaScriptという言語が好きで様々な領域で活用したいと考えているなら、Node.jsはまさにうってつけの選択肢です。

この記事が、あなたがNode.jsの世界に一歩踏み出し、その可能性を感じるきっかけとなれば幸いです。Node.jsのエコシステムは常に進化しています。新しいライブラリやフレームワークが登場し、Node.js自体もアップデートを続けています。変化を楽しめる人にとって、Node.jsは刺激的で学びがいのある分野であり続けるでしょう。

さあ、まずは小さなプロジェクトから始めてみましょう。簡単なCLIツールを作ってみる、Expressを使ってブログのAPIを作ってみるなど、手を動かしながら学ぶのが一番の近道です。

Node.jsの学習の旅は始まったばかりです。この強力なツールを使いこなし、あなたのアイデアを形にしていきましょう！応援しています！

コメントする

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

上部へスクロール