Node.js-はじめに

Node.jsとは何ですか？

Node.jsは、Google ChromeのJavaScriptエンジン（V8エンジン）上に構築されたサーバー側プラットフォームです。 Node.jsは2009年にRyan Dahlによって開発され、最新バージョンはv0.10.36です。公式ドキュメントで提供されるNode.jsの定義は次のとおりです-

'_Node.jsはhttps://code.google.com/p/v8/[ChromeのJavaScriptランタイム]上に構築されたプラットフォームであり、高速でスケーラブルなネットワークアプリケーションを簡単に構築できます。 Node.jsは、イベント駆動型のノンブロッキングI/Oモデルを使用するため、軽量で効率的であり、分散デバイス間で実行されるデータ集約型のリアルタイムアプリケーションに最適です。_

Node.jsは、サーバーサイドおよびネットワーキングアプリケーションを開発するためのオープンソースのクロスプラットフォームランタイム環境です。 Node.jsアプリケーションはJavaScriptで記述されており、OS X、Microsoft Windows、およびLinux上のNode.jsランタイム内で実行できます。

Node.jsは、Node.jsを使用したWebアプリケーションの開発を大幅に簡素化するさまざまなJavaScriptモジュールの豊富なライブラリも提供します。

Node.js = Runtime Environment + JavaScript Library

Node.jsの機能

Node.jsをソフトウェアアーキテクトの最初の選択肢にする重要な機能の一部を以下に示します。

非同期およびイベント駆動-Node.jsライブラリのすべてのAPIは非同期、つまり非ブロッキングです。これは本質的に、Node.jsベースのサーバーがAPIがデータを返すのを待たないことを意味します。サーバーは次のAPIを呼び出した後、次のAPIに移動します。Node.jsのイベントの通知メカニズムは、以前のAPI呼び出しからの応答を取得するのに役立ちます。
非常に高速-Google ChromeのV8 JavaScriptエンジン上に構築されているNode.jsライブラリは、コード実行が非常に高速です。
シングルスレッドですが、高度にスケーラブル-Node.jsは、イベントループを備えたシングルスレッドモデルを使用します。イベントメカニズムは、サーバーがノンブロッキング方式で応答するのに役立ち、リクエストを処理するための限定されたスレッドを作成する従来のサーバーとは対照的に、サーバーを非常にスケーラブルにします。 Node.jsはシングルスレッドプログラムを使用し、同じプログラムはApache HTTPサーバーのような従来のサーバーよりもはるかに多くのリクエストにサービスを提供できます。
バッファリングなし-Node.jsアプリケーションはデータをバッファリングしません。これらのアプリケーションは、単にデータをチャンクで出力します。
ライセンス-Node.jsはhttps://raw.githubusercontent.com/joyent/node/v0.12.0/LICENSE[MITライセンス]でリリースされます。

Node.jsを使用するのは誰ですか？

以下は、Node.jsを使用しているプロジェクト、アプリケーション、および企業の包括的なリストを含むgithub wikiのリンクです。このリストには、eBay、General Electric、GoDaddy、Microsoft、PayPal、Uber、Wikipins、Yahoo !、およびYammerが含まれます。

https://github.com/joyent/node/wiki/projects,-applications,-and-companies-using-node [ノードを使用しているプロジェクト、アプリケーション、および企業]

概念

次の図は、後続の章で詳細に説明するNode.jsの重要な部分を示しています。

Node.jsの概念

Node.jsを使用する場所

以下は、Node.jsが完璧なテクノロジーパートナーであることを証明している分野です。

I/Oバウンドアプリケーション
データストリーミングアプリケーション
データ集約型リアルタイムアプリケーション（DIRT）
JSON APIベースのアプリケーション
シングルページアプリケーション

Node.jsを使用しない場所

CPUを集中的に使用するアプリケーションにNode.jsを使用することはお勧めできません。

Node.js-環境設定

オンラインで試す

'__ Node.jsの学習を開始するために、独自の環境を設定する必要はありません。理由は非常に簡単です。すでにNode.js環境をオンラインで設定しているので、利用可能なすべてのサンプルをオンラインで実行し、実践を通して学ぶことができます。サンプルを自由に変更し、さまざまなオプションで結果を確認してください。

以下のサンプルコードボックス（当社のWebサイト）の右上隅にある Live Demo オプションを使用して、次の例を試してください-

/*Hello World! program in Node.js*/
console.log("Hello World!");

このチュートリアルで提供されるほとんどの例では、Try itオプションがありますので、それを利用して学習を楽しんでください。 '__

ローカル環境のセットアップ

Node.jsの環境を引き続き設定する場合は、コンピューターで次の2つのソフトウェアが必要です。（a）テキストエディターと（b）Node.jsバイナリインストール可能ファイル。

テキストエディタ

これは、プログラムの入力に使用されます。いくつかのエディターの例には、Windows Notepad、OS Editコマンド、Brief、Epsilon、EMACS、vimまたはviが含まれます。

テキストエディタの名前とバージョンは、オペレーティングシステムによって異なる場合があります。たとえば、メモ帳はWindowsで使用され、vimまたはviはLinuxまたはUNIXだけでなくWindowsでも使用できます。

エディターで作成するファイルはソースファイルと呼ばれ、プログラムのソースコードが含まれています。 Node.jsプログラムのソースファイルには、通常、拡張子「 .js 」が付いています。

プログラミングを開始する前に、テキストエディタが1つあることを確認し、コンピュータプログラムを作成してファイルに保存し、最後に実行する十分な経験があることを確認してください。

Node.jsランタイム

ソースファイルに記述されたソースコードは、単にJavaScriptです。 Node.jsインタープリターは、javascriptコードの解釈と実行に使用されます。

Node.jsディストリビューションは、32ビット（386）および64ビット（amd64）x86プロセッサアーキテクチャを備えたSunOS、Linux、Mac OS X、およびWindowsオペレーティングシステムにインストール可能なバイナリとして提供されます。

次のセクションでは、Node.jsバイナリ配布をさまざまなOSにインストールする方法について説明します。

Node.jsアーカイブをダウンロードする

Node.jsのインストール可能なアーカイブファイルの最新バージョンをhttp://nodejs.org/download/[Node.js Downloads]からダウンロードします。このチュートリアルを書いている時点で、以下は異なるOSで利用可能なバージョンです。

OS	Archive name
Windows	node-v6.3.1-x64.msi
Linux	node-v6.3.1-linux-x86.tar.gz
Mac	node-v6.3.1-darwin-x86.tar.gz
SunOS	node-v6.3.1-sunos-x86.tar.gz

UNIX/Linux/Mac OS X、およびSunOSへのインストール

OSアーキテクチャに基づいて、アーカイブnode-v6.3.1- osname .tar.gzをダウンロードして/tmpに抽出し、最後に抽出したファイルを/usr/local/nodejsディレクトリに移動します。例えば：

$ cd/tmp
$ wget http://nodejs.org/dist/v6.3.1/node-v6.3.1-linux-x64.tar.gz
$ tar xvfz node-v6.3.1-linux-x64.tar.gz
$ mkdir -p/usr/local/nodejs
$ mv node-v6.3.1-linux-x64/*/usr/local/nodejs

/usr/local/nodejs/binをPATH環境変数に追加します。

OS	Output
Linux	export PATH=$PATH:/usr/local/nodejs/bin
Mac	export PATH=$PATH:/usr/local/nodejs/bin
FreeBSD	export PATH=$PATH:/usr/local/nodejs/bin

Windowsへのインストール

MSIファイルを使用し、プロンプトに従ってNode.jsをインストールします。デフォルトでは、インストーラーはC：\ Program Files \ nodejsのNode.jsディストリビューションを使用します。インストーラーは、ウィンドウのPATH環境変数にC：\ Program Files \ nodejs \ binディレクトリを設定する必要があります。変更を有効にするために、開いているコマンドプロンプトを再起動します。

インストールの検証：ファイルの実行

次のコードを持つマシン（WindowsまたはLinux）に main.js という名前のjsファイルを作成します。

/*Hello, World! program in node.js*/
console.log("Hello, World!")

Node.jsインタープリターを使用してmain.jsファイルを実行し、結果を確認します-

$ node main.js

すべてがインストールに問題がない場合、これは次の結果を生成するはずです-

Hello, World!

Node.js-最初のアプリケーション

実際の「Hello、World！」を作成する前にNode.jsを使用するアプリケーション、Node.jsアプリケーションのコンポーネントを見てみましょう。 Node.jsアプリケーションは、次の3つの重要なコンポーネントで構成されています-

必要なモジュールのインポート-Node.jsモジュールをロードするために require ディレクティブを使用します。
サーバーの作成-Apache HTTPサーバーと同様に、クライアントのリクエストをリッスンするサーバー。
要求を読み取り、応答を返す-前の手順で作成されたサーバーは、ブラウザまたはコンソールである可能性のあるクライアントによって行われたHTTP要求を読み取り、応答を返します。

Node.jsアプリケーションの作成

ステップ1-必要なモジュールのインポート

*require* ディレクティブを使用してhttpモジュールをロードし、返されたHTTPインスタンスを次のようにhttp変数に保存します-

var http = require("http");

ステップ2-サーバーの作成

作成されたhttpインスタンスを使用して* http.createServer（）メソッドを呼び出してサーバーインスタンスを作成し、サーバーインスタンスに関連付けられた *listen メソッドを使用してポート8081でバインドします。パラメータのリクエストとレスポンスを含む関数を渡します。サンプル実装を記述して、常に「Hello World」を返します。

http.createServer(function (request, response) {
  //Send the HTTP header
  //HTTP Status: 200 : OK
  //Content Type: text/plain
   response.writeHead(200, {'Content-Type': 'text/plain'});

  //Send the response body as "Hello World"
   response.end('Hello World\n');
}).listen(8081);

//Console will print the message
console.log('Server running at http://127.0.0.1:8081/');

上記のコードは、リッスンする、つまり、ローカルマシンの8081ポートでリクエストを待機するHTTPサーバーを作成するのに十分です。

ステップ3-要求と応答のテスト

ステップ1と2を main.js というファイルにまとめて、以下に示すようにHTTPサーバーを起動しましょう-

var http = require("http");

http.createServer(function (request, response) {
  //Send the HTTP header
  //HTTP Status: 200 : OK
  //Content Type: text/plain
   response.writeHead(200, {'Content-Type': 'text/plain'});

  //Send the response body as "Hello World"
   response.end('Hello World\n');
}).listen(8081);

//Console will print the message
console.log('Server running at http://127.0.0.1:8081/');

今すぐmain.jsを実行して、次のようにサーバーを起動します-

$ node main.js

出力を確認します。サーバーが起動しました。

Server running at http://127.0.0.1:8081/

Node.jsサーバーにリクエストを行う

任意のブラウザーでhttp://127.0.0.1:8081/を開き、次の結果を確認します。

Node.jsサンプル

おめでとうございます。ポート8081ですべてのHTTP要求に応答している最初のHTTPサーバーが稼働しています。

Node.js-REPLターミナル

REPLはRead Eval Print Loopの略で、コマンドが入力され、システムが対話モードで出力を返すWindowsコンソールやUnix/Linuxシェルなどのコンピューター環境を表します。 Node.jsまたは Node には、REPL環境がバンドルされています。次のタスクを実行します-

読み取り-ユーザーの入力を読み取り、入力をJavaScriptデータ構造に解析し、メモリに保存します。
評価-データ構造を取得して評価します。
印刷-結果を印刷します。
ループ-ユーザーが ctrl-c を2回押すまで、上記のコマンドをループします。

NodeのREPL機能は、Node.jsコードの実験やJavaScriptコードのデバッグに非常に役立ちます。

オンラインREPLターミナル

学習を簡単にするために、使いやすいNode.js REPL環境をオンラインでセットアップしました。ここではNode.js構文を練習できます-link：/nodejs_terminal_online.php [Node.js REPLターミナルの起動__]

REPLの開始

REPLは、次のように引数なしでシェル/コンソールで node を実行するだけで開始できます。

$ node

REPLコマンドプロンプトが表示されます。ここで、Node.jsコマンドを入力できます-

$ node
>

簡単な表現

Node.js REPLコマンドプロンプトで簡単な数学を試してみましょう-

$ node
> 1 &plus; 3
4
> 1 &plus; ( 2 *3 ) - 4
3
>

変数を使用する

変数を使用して値を保存し、後で従来のスクリプトのように印刷できます。* var キーワードを使用しない場合、値は変数に保存されて出力されます。一方、 *var キーワードを使用すると、値は保存されますが、出力されません。 * console.log（）*を使用して変数を印刷できます。

$ node
> x = 10
10
> var y = 10
undefined
> x &plus; y
20
> console.log("Hello World")
Hello World
undefined

複数行の式

Node REPLはJavaScriptに似た複数行の式をサポートします。アクションで次のdo-whileループを確認しましょう-

$ node
> var x = 0
undefined
> do {
   ... x&plus;&plus;;
   ... console.log("x: " &plus; x);
   ... }
while ( x < 5 );
x: 1
x: 2
x: 3
x: 4
x: 5
undefined
>

開始ブラケットの後にEnterキーを押すと、自動的に表示されます。ノードは式の連続性を自動的にチェックします。

アンダースコア変数

あなたは最後の結果を取得するためにアンダースコア*（_）*を使用することができます-

$ node
> var x = 10
undefined
> var y = 20
undefined
> x + y
30
> var sum = _
undefined
> console.log(sum)
30
undefined
>

REPLコマンド

ctrl＆plus; c -現在のコマンドを終了します。
* ctrl＆plus; c 2回*-Node REPLを終了します。
ctrl＆plus; d -Node REPLを終了します。
上/下キー-コマンド履歴を参照し、以前のコマンドを変更します。
tab Keys -現在のコマンドのリスト。
.help -すべてのコマンドのリスト。
.break -複数行の式を終了します。
.clear -複数行の式を終了します。
.save filename -現在のNode REPLセッションをファイルに保存します。
.load filename -現在のノードREPLセッションでファイルコンテンツをロードします。

REPLの停止

上記のように、Node.js REPLから抜け出すには、* ctrl-cを2回使用する必要があります。

$ node
>
(^C again to quit)
>

Node.js-NPM

Node Package Manager（NPM）は2つの主要な機能を提供します-

https://search.nodejs.org [search.nodejs.org]で検索可能なnode.jsパッケージ/モジュールのオンラインリポジトリ
Node.jsパッケージをインストールし、Node.jsパッケージのバージョン管理と依存関係管理を行うコマンドラインユーティリティ。

NPMは、v0.6.3バージョン以降のNode.jsインストール可能ファイルにバンドルされています。同じことを確認するには、コンソールを開き、次のコマンドを入力して結果を確認します-

$ npm --version
2.7.1

NPMの古いバージョンを実行している場合、それを最新バージョンに更新するのは非常に簡単です。ルートから次のコマンドを使用するだけです-

$ sudo npm install npm -g
/usr/bin/npm ->/usr/lib/node_modules/npm/bin/npm-cli.js
npm@2.7.1/usr/lib/node_modules/npm

NPMを使用したモジュールのインストール

Node.jsモジュールをインストールする簡単な構文があります-

$ npm install <Module Name>

たとえば、エクスプレスと呼ばれる有名なNode.js Webフレームワークモジュールをインストールするコマンドは次のとおりです-

$ npm install express

これで、次のようにjsファイルでこのモジュールを使用できます-

var express = require('express');

グローバルインストールとローカルインストール

デフォルトでは、NPMはローカルモードで依存関係をインストールします。ここで、ローカルモードとは、Nodeアプリケーションが存在するフォルダーにあるnode_modulesディレクトリへのパッケージのインストールを指します。ローカルに展開されたパッケージには、require（）メソッドを介してアクセスできます。たとえば、エクスプレスモジュールをインストールすると、エクスプレスモジュールをインストールした現在のディレクトリにnode_modulesディレクトリが作成されます。

$ ls -l
total 0
drwxr-xr-x 3 root root 20 Mar 17 02:23 node_modules

または、 npm ls コマンドを使用して、ローカルにインストールされているすべてのモジュールをリストダウンできます。

グローバルにインストールされたパッケージ/依存関係は、システムディレクトリに保存されます。このような依存関係は、node.jsのCLI（コマンドラインインターフェイス）関数で使用できますが、Nodeアプリケーションでrequire（）を使用して直接インポートすることはできません。次に、グローバルインストールを使用して、エクスプレスモジュールをインストールしてみましょう。

$ npm install express -g

これにより同様の結果が得られますが、モジュールはグローバルにインストールされます。ここで、最初の行はモジュールのバージョンとインストールされる場所を示しています。

express@4.12.2/usr/lib/node_modules/express
├── merge-descriptors@1.0.0
├── utils-merge@1.0.0
├── cookie-signature@1.0.6
├── methods@1.1.1
├── fresh@0.2.4
├── cookie@0.1.2
├── escape-html@1.0.1
├── range-parser@1.0.2
├── content-type@1.0.1
├── finalhandler@0.3.3
├── vary@1.0.0
├── parseurl@1.3.0
├── content-disposition@0.5.0
├── path-to-regexp@0.1.3
├── depd@1.0.0
├── qs@2.3.3
├── on-finished@2.2.0 (ee-first@1.1.0)
├── etag@1.5.1 (crc@3.2.1)
├── debug@2.1.3 (ms@0.7.0)
├── proxy-addr@1.0.7 (forwarded@0.1.0, ipaddr.js@0.1.9)
├── send@0.12.1 (destroy@1.0.3, ms@0.7.0, mime@1.3.4)
├── serve-static@1.9.2 (send@0.12.2)
├── accepts@1.2.5 (negotiator@0.5.1, mime-types@2.0.10)
└── type-is@1.6.1 (media-typer@0.3.0, mime-types@2.0.10)

次のコマンドを使用して、グローバルにインストールされているすべてのモジュールを確認できます-

$ npm ls -g

package.jsonを使用する

package.jsonは、任意のNodeアプリケーション/モジュールのルートディレクトリに存在し、パッケージのプロパティを定義するために使用されます。 node_modules/express/ にあるエクスプレスパッケージのpackage.jsonを開きましょう

{
   "name": "express",
      "description": "Fast, unopinionated, minimalist web framework",
      "version": "4.11.2",
      "author": {

         "name": "TJ Holowaychuk",
         "email": "tj@vision-media.ca"
      },

   "contributors": [{
      "name": "Aaron Heckmann",
      "email": "aaron.heckmann+github@gmail.com"
   },

   {
      "name": "Ciaran Jessup",
      "email": "ciaranj@gmail.com"
   },

   {
      "name": "Douglas Christopher Wilson",
      "email": "doug@somethingdoug.com"
   },

   {
      "name": "Guillermo Rauch",
      "email": "rauchg@gmail.com"
   },

   {
      "name": "Jonathan Ong",
      "email": "me@jongleberry.com"
   },

   {
      "name": "Roman Shtylman",
      "email": "shtylman+expressjs@gmail.com"
   },

   {
      "name": "Young Jae Sim",
      "email": "hanul@hanul.me"
   } ],

   "license": "MIT", "repository": {
      "type": "git",
      "url": "https://github.com/strongloop/express"
   },

   "homepage": "https://expressjs.com/", "keywords": [
      "express",
      "framework",
      "sinatra",
      "web",
      "rest",
      "restful",
      "router",
      "app",
      "api"
   ],

   "dependencies": {
      "accepts": "~1.2.3",
      "content-disposition": "0.5.0",
      "cookie-signature": "1.0.5",
      "debug": "~2.1.1",
      "depd": "~1.0.0",
      "escape-html": "1.0.1",
      "etag": "~1.5.1",
      "finalhandler": "0.3.3",
      "fresh": "0.2.4",
      "media-typer": "0.3.0",
      "methods": "~1.1.1",
      "on-finished": "~2.2.0",
      "parseurl": "~1.3.0",
      "path-to-regexp": "0.1.3",
      "proxy-addr": "~1.0.6",
      "qs": "2.3.3",
      "range-parser": "~1.0.2",
      "send": "0.11.1",
      "serve-static": "~1.8.1",
      "type-is": "~1.5.6",
      "vary": "~1.0.0",
      "cookie": "0.1.2",
      "merge-descriptors": "0.0.2",
      "utils-merge": "1.0.0"
   },

   "devDependencies": {
      "after": "0.8.1",
      "ejs": "2.1.4",
      "istanbul": "0.3.5",
      "marked": "0.3.3",
      "mocha": "~2.1.0",
      "should": "~4.6.2",
      "supertest": "~0.15.0",
      "hjs": "~0.0.6",
      "body-parser": "~1.11.0",
      "connect-redis": "~2.2.0",
      "cookie-parser": "~1.3.3",
      "express-session": "~1.10.2",
      "jade": "~1.9.1",
      "method-override": "~2.3.1",
      "morgan": "~1.5.1",
      "multiparty": "~4.1.1",
      "vhost": "~3.0.0"
   },

   "engines": {
      "node": ">= 0.10.0"
   },

   "files": [
      "LICENSE",
      "History.md",
      "Readme.md",
      "index.js",
      "lib/"
   ],

   "scripts": {
      "test": "mocha --require test/support/env
         --reporter spec --bail --check-leaks test/test/acceptance/",
      "test-cov": "istanbul cover node_modules/mocha/bin/_mocha
         -- --require test/support/env --reporter dot --check-leaks test/test/acceptance/",
      "test-tap": "mocha --require test/support/env
         --reporter tap --check-leaks test/test/acceptance/",
      "test-travis": "istanbul cover node_modules/mocha/bin/_mocha
         --report lcovonly -- --require test/support/env
         --reporter spec --check-leaks test/test/acceptance/"
   },

   "gitHead": "63ab25579bda70b4927a179b580a9c580b6c7ada",
   "bugs": {
      "url": "https://github.com/strongloop/express/issues"
   },

   "_id": "express@4.11.2",
   "_shasum": "8df3d5a9ac848585f00a0777601823faecd3b148",
   "_from": "express@*",
   "_npmVersion": "1.4.28",
   "_npmUser": {
      "name": "dougwilson",
      "email": "doug@somethingdoug.com"
   },

   "maintainers": [{
      "name": "tjholowaychuk",
      "email": "tj@vision-media.ca"
   },

   {
      "name": "jongleberry",
      "email": "jonathanrichardong@gmail.com"
   },

   {
      "name": "shtylman",
      "email": "shtylman@gmail.com"
   },

   {
      "name": "dougwilson",
      "email": "doug@somethingdoug.com"
   },

   {
      "name": "aredridel",
      "email": "aredridel@nbtsc.org"
   },

   {
      "name": "strongloop",
      "email": "callback@strongloop.com"
   },

   {
      "name": "rfeng",
      "email": "enjoyjava@gmail.com"
   }],

   "dist": {
      "shasum": "8df3d5a9ac848585f00a0777601823faecd3b148",
      "tarball": "https://registry.npmjs.org/express/-/express-4.11.2.tgz"
   },

   "directories": {},
      "_resolved": "https://registry.npmjs.org/express/-/express-4.11.2.tgz",
      "readme": "ERROR: No README data found!"
}

Package.jsonの属性

name -パッケージの名前
version -パッケージのバージョン
description -パッケージの説明
homepage -パッケージのホームページ
author -パッケージの作成者
contributors -パッケージへの貢献者の名前
dependencies -依存関係のリスト。 NPMは、ここに記載されているすべての依存関係をパッケージのnode_moduleフォルダーに自動的にインストールします。
repository -パッケージのリポジトリタイプとURL
main -パッケージのエントリポイント
キーワード-キーワード

モジュールのアンインストール

Node.jsモジュールをアンインストールするには、次のコマンドを使用します。

$ npm uninstall express

NPMがパッケージをアンインストールしたら、/node_modules/ディレクトリの内容を見て確認するか、次のコマンドを入力します-

$ npm ls

モジュールの更新

package.jsonを更新し、更新する依存関係のバージョンを変更して、次のコマンドを実行します。

$ npm update express

モジュールを検索する

NPMを使用してパッケージ名を検索します。

$ npm search express

モジュールを作成する

モジュールを作成するには、package.jsonを生成する必要があります。 NPMを使用してpackage.jsonを生成します。これにより、package.jsonの基本的なスケルトンが生成されます。

$ npm init
This utility will walk you through creating a package.json file.
It only covers the most common items, and tries to guess sane defaults.

See 'npm help json' for definitive documentation on these fields
and exactly what they do.

Use 'npm install <pkg> --save' afterwards to install a package and
save it as a dependency in the package.json file.

Press ^C at any time to quit.
name: (webmaster)

モジュールに関するすべての必要な情報を提供する必要があります。上記のpackage.jsonファイルのヘルプを利用して、必要なさまざまな情報の意味を理解できます。 package.jsonが生成されたら、次のコマンドを使用して、有効な電子メールアドレスを使用してNPMリポジトリサイトに自分自身を登録します。

$ npm adduser
Username: mcmohd
Password:
Email: (this IS public) mcmohd@gmail.com

あなたのモジュールを公開する時が来ました-

$ npm publish

モジュールで問題がなければ、リポジトリに公開され、他のNode.jsモジュールと同様にNPMを使用してインストールできるようになります。

Node.js-コールバックの概念

コールバックとは何ですか？

コールバックは、関数の非同期同等物です。コールバック関数は、特定のタスクの完了時に呼び出されます。 Nodeはコールバックを多用します。 NodeのすべてのAPIは、コールバックをサポートするように作成されています。

たとえば、ファイルを読み取る関数は、ファイルの読み取りを開始し、すぐに制御を実行環境に戻し、次の命令を実行できるようにします。ファイルI/Oが完了すると、コールバック関数、ファイルのコンテンツをパラメーターとして渡しながら、コールバック関数を呼び出します。そのため、ファイルI/Oのブロックや待機はありません。 Node.jsは、関数が結果を返すのを待たずに多数のリクエストを処理できるため、非常にスケーラブルになります。

ブロッキングコードの例

次の内容で input.txt という名前のテキストファイルを作成します-

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

次のコードで main.js という名前のjsファイルを作成します-

var fs = require("fs");
var data = fs.readFileSync('input.txt');

console.log(data.toString());
console.log("Program Ended");

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!
Program Ended

ノンブロッキングコードの例

次の内容のinput.txtという名前のテキストファイルを作成します。

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

main.jsを更新して、次のコードを作成します-

var fs = require("fs");

fs.readFile('input.txt', function (err, data) {
   if (err) return console.error(err);
   console.log(data.toString());
});

console.log("Program Ended");

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Program Ended
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

これらの2つの例は、ブロッキング呼び出しとノンブロッキング呼び出しの概念を説明しています。

最初の例は、プログラムがファイルを読み取るまでブロックし、その後、プログラムのみがプログラムを終了することを示しています。
2番目の例は、プログラムがファイルの読み取りを待たずに「プログラム終了」の印刷に進み、同時にブロックされていないプログラムがファイルの読み取りを続行することを示しています。

したがって、ブロッキングプログラムは非常に順番に実行されます。プログラミングの観点からは、ロジックの実装は簡単ですが、ノンブロッキングプログラムは順番に実行されません。プログラムで処理するデータを使用する必要がある場合は、同じブロック内に保持して、順次実行する必要があります。

Node.js-イベントループ

Node.jsはシングルスレッドアプリケーションですが、 event および callbacks の概念を介して並行性をサポートできます。 Node.jsのすべてのAPIは非同期であり、シングルスレッドであるため、* async関数呼び出し*を使用して同時実行性を維持します。ノードはオブザーバーパターンを使用します。ノードスレッドはイベントループを保持し、タスクが完了するたびに、対応するイベントを起動し、イベントリスナー関数に実行を通知します。

イベント駆動型プログラミング

Node.jsはイベントを頻繁に使用するため、Node.jsが他の同様のテクノロジーと比較して非常に高速である理由の1つでもあります。 Nodeはサーバーを起動するとすぐに、変数を開始し、関数を宣言し、イベントが発生するのを待ちます。

イベント駆動型アプリケーションでは、通常、イベントをリッスンし、それらのイベントの1つが検出されるとコールバック関数をトリガーするメインループがあります。

イベントループ

イベントはコールバックに非常に似ていますが、非同期関数が結果を返すときにコールバック関数が呼び出されるという事実に違いがありますが、イベント処理はオブザーバーパターンで機能します。イベントをリッスンする関数は、*オブザーバー*として機能します。イベントが発生すると、そのリスナー関数の実行が開始されます。 Node.jsには、次のようにイベントとイベントリスナーをバインドするために使用されるイベントモジュールとEventEmitterクラスを通じて利用可能な複数の組み込みイベントがあります-

//Import events module
var events = require('events');

//Create an eventEmitter object
var eventEmitter = new events.EventEmitter();

以下は、イベントハンドラをイベントにバインドするための構文です-

//Bind event and event  handler as follows
eventEmitter.on('eventName', eventHandler);

次のようにプログラムでイベントを起動できます-

//Fire an event
eventEmitter.emit('eventName');

例

次のコードでmain.jsという名前のjsファイルを作成します-

//Import events module
var events = require('events');

//Create an eventEmitter object
var eventEmitter = new events.EventEmitter();

//Create an event handler as follows
var connectHandler = function connected() {
   console.log('connection succesful.');

  //Fire the data_received event
   eventEmitter.emit('data_received');
}

//Bind the connection event with the handler
eventEmitter.on('connection', connectHandler);

//Bind the data_received event with the anonymous function
eventEmitter.on('data_received', function() {
   console.log('data received succesfully.');
});

//Fire the connection event
eventEmitter.emit('connection');

console.log("Program Ended.");

今、上記のプログラムを実行し、その出力を確認してみましょう-

$ node main.js

ITは、次の結果を生成する必要があります-

connection successful.
data received successfully.
Program Ended.

ノードアプリケーションの仕組み

Node Applicationでは、非同期関数は最後のパラメーターとしてコールバックを受け入れ、コールバック関数は最初のパラメーターとしてエラーを受け入れます。前の例をもう一度見てみましょう。次の内容のinput.txtという名前のテキストファイルを作成します。

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

次のコードを持つmain.jsという名前のjsファイルを作成します-

var fs = require("fs");

fs.readFile('input.txt', function (err, data) {
   if (err) {
      console.log(err.stack);
      return;
   }
   console.log(data.toString());
});
console.log("Program Ended");

ここで、fs.readFile（）はファイルを読み取ることを目的とする非同期関数です。読み取り操作中にエラーが発生した場合、* errオブジェクト*には対応するエラーが含まれます。それ以外の場合、データにはファイルの内容が含まれます。 readFile は、読み取り操作の完了後にエラーとデータをコールバック関数に渡し、最終的にコンテンツを出力します。

Program Ended
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Node.js-イベントエミッター

Nodeの多くのオブジェクトはイベントを発行します。たとえば、net.Serverはピアが接続するたびにイベントを発行し、fs.readStreamはファイルが開かれたときにイベントを発行します。イベントを発行するすべてのオブジェクトは、events.EventEmitterのインスタンスです。

EventEmitterクラス

前のセクションで見たように、EventEmitterクラスはイベントモジュールにあります。それは次のコードを介してアクセス可能です-

//Import events module
var events = require('events');

//Create an eventEmitter object
var eventEmitter = new events.EventEmitter();

EventEmitterインスタンスがエラーに直面すると、「エラー」イベントを発行します。新しいリスナーが追加されると、「newListener」イベントが発生し、リスナーが削除されると、「removeListener」イベントが発生します。

EventEmitterは、 on や emit などの複数のプロパティを提供します。 on プロパティは関数をイベントにバインドするために使用され、 emit はイベントを起動するために使用されます。

方法

Sr.No.	Method & Description
1	addListener(event, listener) 指定されたイベントのリスナー配列の最後にリスナーを追加します。リスナーがすでに追加されているかどうかを確認するチェックは行われません。イベントとリスナーの同じ組み合わせを渡す複数の呼び出しにより、リスナーが複数回追加されます。エミッタを返すため、呼び出しを連鎖できます。
2	on(event, listener) 指定されたイベントのリスナー配列の最後にリスナーを追加します。リスナーがすでに追加されているかどうかを確認するチェックは行われません。イベントとリスナーの同じ組み合わせを渡す複数の呼び出しにより、リスナーが複数回追加されます。エミッタを返すため、呼び出しを連鎖できます。
3	once(event, listener) ワンタイムリスナーをイベントに追加します。このリスナーは、次にイベントが発生したときにのみ呼び出され、その後削除されます。エミッタを返すため、呼び出しを連鎖できます。
4	removeListener(event, listener) 指定されたイベントのリスナー配列からリスナーを削除します。注意-リスナーの背後にあるリスナー配列の配列インデックスを変更します。 removeListenerは、リスナー配列から最大で1つのリスナーのインスタンスを削除します。単一のリスナーが指定されたイベントのリスナー配列に複数回追加された場合、removeListenerを複数回呼び出して各インスタンスを削除する必要があります。エミッタを返すため、呼び出しを連鎖できます。
5	removeAllListeners([event]) すべてのリスナー、または指定されたイベントのリスナーを削除します。コードの別の場所に追加されたリスナーを削除することはお勧めできません。特に、作成していないエミッター上にある場合（例：ソケットまたはファイルストリーム）。エミッタを返すため、呼び出しを連鎖できます。
6	setMaxListeners(n) デフォルトでは、特定のイベントに10人を超えるリスナーが追加された場合、EventEmittersは警告を出力します。これは、メモリリークの検出に役立つ便利なデフォルトです。明らかに、すべてのエミッタが10に制限されるべきではありません。この機能により、それを増やすことができます。無制限の場合はゼロに設定します。
7	listeners(event) 指定されたイベントのリスナーの配列を返します。
8	emit(event, [arg1], [arg2], […]) 指定された引数を使用して、各リスナーを順番に実行します。イベントにリスナーがある場合はtrue、そうでない場合はfalseを返します。

クラスメソッド

Sr.No.	Method & Description
1	listenerCount(emitter, event) 特定のイベントのリスナーの数を返します。

イベント

Sr.No.

Events & Description

1

newListener

event -文字列：イベント名
listener -関数：イベントハンドラー関数

このイベントは、リスナーが追加されるたびに発生します。このイベントがトリガーされると、リスナーはイベントのリスナーの配列にまだ追加されていない可能性があります。

2

removeListener

event -文字列イベント名
listener -Functionイベントハンドラー関数

このイベントは、誰かがリスナーを削除するたびに発生します。このイベントがトリガーされたとき、リスナーはイベントのリスナーの配列からまだ削除されていない可能性があります。

例

次のNode.jsコードでmain.jsという名前のjsファイルを作成します-

var events = require('events');
var eventEmitter = new events.EventEmitter();

//listener #1
var listner1 = function listner1() {
   console.log('listner1 executed.');
}

//listener #2
var listner2 = function listner2() {
   console.log('listner2 executed.');
}

//Bind the connection event with the listner1 function
eventEmitter.addListener('connection', listner1);

//Bind the connection event with the listner2 function
eventEmitter.on('connection', listner2);

var eventListeners = require('events').EventEmitter.listenerCount
   (eventEmitter,'connection');
console.log(eventListeners + " Listner(s) listening to connection event");

//Fire the connection event
eventEmitter.emit('connection');

//Remove the binding of listner1 function
eventEmitter.removeListener('connection', listner1);
console.log("Listner1 will not listen now.");

//Fire the connection event
eventEmitter.emit('connection');

eventListeners = require('events').EventEmitter.listenerCount(eventEmitter,'connection');
console.log(eventListeners + " Listner(s) listening to connection event");

console.log("Program Ended.");

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

2 Listner(s) listening to connection event
listner1 executed.
listner2 executed.
Listner1 will not listen now.
listner2 executed.
1 Listner(s) listening to connection event
Program Ended.

Node.js-バッファー

純粋なJavaScriptはUnicodeに対応していますが、バイナリデータには適していません。 TCPストリームまたはファイルシステムを処理している間、オクテットストリームを処理する必要があります。 NodeはBufferクラスを提供します。これは、整数の配列に似た生データを格納するインスタンスを提供しますが、V8ヒープ外の生メモリ割り当てに対応します。

バッファクラスは、バッファモジュールをインポートせずにアプリケーションでアクセスできるグローバルクラスです。

バッファを作成する

Node Bufferはさまざまな方法で構築できます。

方法1

以下は、 10 オクテットの未開始バッファを作成する構文です-

var buf = new Buffer(10);

方法2

以下は、指定された配列からバッファを作成するための構文です-

var buf = new Buffer([10, 20, 30, 40, 50]);

方法3

以下は、指定された文字列からバッファを作成し、オプションでエンコードタイプを作成する構文です-

var buf = new Buffer("Simply Easy Learning", "utf-8");

「utf8」がデフォルトのエンコーディングですが、次のエンコーディング「ascii」、「utf8」、「utf16le」、「ucs2」、「base64」または「hex」のいずれかを使用できます。

バッファへの書き込み

構文

以下は、ノードバッファに書き込むメソッドの構文です-

buf.write(string[, offset][, length][, encoding])

パラメーター

ここに使用されるパラメータの説明があります-

string -これは、バッファに書き込まれる文字列データです。
offset -これは書き込みを開始するバッファのインデックスです。デフォルト値は0です。
長さ-これは書き込むバイト数です。デフォルトはbuffer.lengthです。
encoding -使用するエンコーディング。「utf8」はデフォルトのエンコーディングです。

戻り値

このメソッドは、書き込まれたオクテットの数を返します。バッファに文字列全体を収めるのに十分なスペースがない場合、文字列の一部が書き込まれます。

例

buf = new Buffer(256);
len = buf.write("Simply Easy Learning");

console.log("Octets written : "+  len);

上記のプログラムが実行されると、次の結果が生成されます-

Octets written : 20

バッファーからの読み取り

構文

以下は、ノードバッファからデータを読み取るメソッドの構文です-

buf.toString([encoding][, start][, end])

パラメーター

ここに使用されるパラメータの説明があります-

encoding -使用するエンコーディング。「utf8」はデフォルトのエンコーディングです。
start -読み取りを開始する開始インデックス。デフォルトは0です。
end -読み取りを終了するインデックスを終了します。デフォルトは完全なバッファです。

戻り値

このメソッドは、指定された文字セットエンコーディングを使用してエンコードされたバッファデータから文字列をデコードして返します。

例

buf = new Buffer(26);
for (var i = 0 ; i < 26 ; i++) {
  buf[i] = i + 97;
}

console.log( buf.toString('ascii'));      //outputs: abcdefghijklmnopqrstuvwxyz
console.log( buf.toString('ascii',0,5));  //outputs: abcde
console.log( buf.toString('utf8',0,5));   //outputs: abcde
console.log( buf.toString(undefined,0,5));//encoding defaults to 'utf8', outputs abcde

上記のプログラムが実行されると、次の結果が生成されます-

abcdefghijklmnopqrstuvwxyz
abcde
abcde
abcde

バッファをJSONに変換

構文

以下は、ノードバッファをJSONオブジェクトに変換するメソッドの構文です-

buf.toJSON()

戻り値

このメソッドは、BufferインスタンスのJSON表現を返します。

例

var buf = new Buffer('Simply Easy Learning');
var json = buf.toJSON(buf);

console.log(json);

上記のプログラムが実行されると、次の結果が生成されます-

{ type: 'Buffer',
   data:
   [
      83,
      105,
      109,
      112,
      108,
      121,
      32,
      69,
      97,
      115,
      121,
      32,
      76,
      101,
      97,
      114,
      110,
      105,
      110,
      103
   ]
}

連結バッファー

構文

以下は、ノードバッファを単一のノードバッファに連結するメソッドの構文です-

Buffer.concat(list[, totalLength])

パラメーター

ここに使用されるパラメータの説明があります-

list -連結されるBufferオブジェクトの配列リスト。
totalLength -これは、連結時のバッファーの合計長です。

戻り値

このメソッドは、Bufferインスタンスを返します。

例

var buffer1 = new Buffer('finddevguides ');
var buffer2 = new Buffer('Simply Easy Learning');
var buffer3 = Buffer.concat([buffer1,buffer2]);

console.log("buffer3 content: " + buffer3.toString());

上記のプログラムが実行されると、次の結果が生成されます-

buffer3 content: finddevguides Simply Easy Learning

バッファーの比較

構文

以下は、2つのノードバッファを比較するためのメソッドの構文です-

buf.compare(otherBuffer);

パラメーター

ここに使用されるパラメータの説明があります-

otherBuffer -これは buf と比較される他のバッファーです

戻り値

ソート順がotherBufferの前か後か、または同じかどうかを示す数値を返します。

例

var buffer1 = new Buffer('ABC');
var buffer2 = new Buffer('ABCD');
var result = buffer1.compare(buffer2);

if(result < 0) {
   console.log(buffer1 &plus;" comes before " &plus; buffer2);
} else if(result === 0) {
   console.log(buffer1 &plus;" is same as " &plus; buffer2);
} else {
   console.log(buffer1 &plus;" comes after " &plus; buffer2);
}

上記のプログラムが実行されると、次の結果が生成されます-

ABC comes before ABCD

コピーバッファ

構文

以下は、ノードバッファをコピーするメソッドの構文です-

buf.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd])

パラメーター

ここに使用されるパラメータの説明があります-

targetBuffer -バッファがコピーされるバッファオブジェクト。
targetStart -数値、オプション、デフォルト：0
sourceStart -数値、オプション、デフォルト：0
sourceEnd -数値、オプション、デフォルト：buffer.length

戻り値

戻り値なしターゲットメモリ領域がソースと重複していても、このバッファの領域からターゲットバッファの領域にデータをコピーします。未定義の場合、targetStartおよびsourceStartパラメーターはデフォルトで0になり、sourceEndはデフォルトでbuffer.lengthになります。

例

var buffer1 = new Buffer('ABC');

//copy a buffer
var buffer2 = new Buffer(3);
buffer1.copy(buffer2);
console.log("buffer2 content: " + buffer2.toString());

上記のプログラムが実行されると、次の結果が生成されます-

buffer2 content: ABC

スライスバッファー

構文

以下は、ノードバッファのサブバッファを取得するためのメソッドの構文です-

buf.slice([start][, end])

パラメーター

ここに使用されるパラメータの説明があります-

start -数値、オプション、デフォルト：0
end -数値、オプション、デフォルト：buffer.length

戻り値

古いバッファと同じメモリを参照する新しいバッファを返しますが、開始インデックス（デフォルトは0）と終了インデックス（デフォルトはbuffer.length）によってオフセットおよびトリミングされます。負のインデックスはバッファの最後から始まります。

例

var buffer1 = new Buffer('finddevguides');

//slicing a buffer
var buffer2 = buffer1.slice(0,9);
console.log("buffer2 content: " + buffer2.toString());

上記のプログラムが実行されると、次の結果が生成されます-

buffer2 content: Tutorials

バッファ長

構文

以下は、ノードバッファのサイズをバイト単位で取得するメソッドの構文です-

buf.length;

戻り値

バッファのサイズをバイト単位で返します。

例

var buffer = new Buffer('finddevguides');

//length of the buffer
console.log("buffer length: " &plus; buffer.length);

上記のプログラムが実行されると、次の結果が生成されます-

buffer length: 14

メソッドリファレンス

____Followingは、Node.jsで利用可能なBuffersモジュールのリファレンスです。詳細については、公式ドキュメントを参照できます。

Sr.No.	Method & Description
1	new Buffer(size) サイズオクテットの新しいバッファを割り当てます。サイズはkMaxLength以下でなければならないことに注意してください。それ以外の場合、RangeErrorがここにスローされます。
2	new Buffer(buffer) 渡されたバッファデータを新しいBufferインスタンスにコピーします。
3	new Buffer(str[, encoding]) 指定されたstrを含む新しいバッファーを割り当てます。エンコードのデフォルトは「utf8」です。
4	buf.length バッファのサイズをバイト単位で返します。これは必ずしもコンテンツのサイズではないことに注意してください。 lengthは、バッファオブジェクトに割り当てられたメモリの量を指します。バッファの内容が変更されても変更されません。
5	buf.write(string[, offset][, length][, encoding]) 指定されたエンコーディングを使用して、オフセットで文字列をバッファに書き込みます。オフセットのデフォルトは0、エンコードのデフォルトは「utf8」です。 lengthは書き込むバイト数です。書き込まれたオクテットの数を返します。
6	buf.writeUIntLE(value, offset, byteLength[, noAssert]) 指定されたオフセットとbyteLengthでバッファに値を書き込みます。最大48ビットの精度をサポートします。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。デフォルトはfalseです。
7	buf.writeUIntBE(value, offset, byteLength[, noAssert]) 指定されたオフセットとbyteLengthでバッファに値を書き込みます。最大48ビットの精度をサポートします。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。デフォルトはfalseです。
8	buf.writeIntLE(value, offset, byteLength[, noAssert]) 指定されたオフセットとbyteLengthでバッファに値を書き込みます。最大48ビットの精度をサポートします。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。デフォルトはfalseです。
9	buf.writeIntBE(value, offset, byteLength[, noAssert]) 指定されたオフセットとbyteLengthでバッファに値を書き込みます。最大48ビットの精度をサポートします。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。デフォルトはfalseです。
10	buf.readUIntLE(offset, byteLength[, noAssert]) すべての数値読み取りメソッドの汎用バージョン。最大48ビットの精度をサポートします。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
11	buf.readUIntBE(offset, byteLength[, noAssert]) すべての数値読み取りメソッドの汎用バージョン。最大48ビットの精度をサポートします。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
12	buf.readIntLE(offset, byteLength[, noAssert]) すべての数値読み取りメソッドの汎用バージョン。最大48ビットの精度をサポートします。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
13	buf.readIntBE(offset, byteLength[, noAssert]) すべての数値読み取りメソッドの汎用バージョン。最大48ビットの精度をサポートします。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
14	buf.toString([encoding][, start][, end]) 指定された文字セットエンコーディングを使用してエンコードされたバッファデータから文字列をデコードして返します。
15	buf.toJSON() BufferインスタンスのJSON表現を返します。 JSON.stringifyは、Bufferインスタンスを文字列化するときに、この関数を暗黙的に呼び出します。
16	buf[index] インデックスでオクテットを取得および設定します。値は個々のバイトを参照するため、有効な範囲は0x00〜0xFF hexまたは0〜255です。
17	buf.equals(otherBuffer) このバッファーとotherBufferのバイト数が同じ場合、ブール値を返します。
18	buf.compare(otherBuffer) このバッファがソート順でotherBufferと前後するか、otherBufferと同じかを示す数値を返します。
19	buf.copy(targetBuffer[, targetStart][, sourceStart][, sourceEnd]) ターゲットメモリ領域がソースと重複していても、このバッファの領域からターゲットバッファの領域にデータをコピーします。未定義の場合、targetStartおよびsourceStartパラメーターはデフォルトで0になり、sourceEndはデフォルトでbuffer.lengthになります。
20	buf.slice([start][, end]) 古いメモリと同じメモリを参照する新しいバッファを返しますが、開始インデックス（デフォルトは0）と終了インデックス（デフォルトはbuffer.length）によってオフセットおよびトリミングされます。負のインデックスはバッファの最後から始まります。
21	buf.readUInt8(offset[, noAssert]) 指定されたオフセットでバッファから符号なし8ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
22	buf.readUInt16LE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから符号なし16ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
23	buf.readUInt16BE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから符号なし16ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
24	buf.readUInt32LE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから符号なし32ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
25	buf.readUInt32BE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから符号なし32ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
26	buf.readInt8(offset[, noAssert]) 指定されたオフセットでバッファから符号付き8ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
27	buf.readInt16LE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから符号付き16ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
28	buf.readInt16BE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから符号付き16ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
29	buf.readInt32LE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから符号付き32ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
30	buf.readInt32BE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから符号付き32ビット整数を読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
31	buf.readFloatLE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから32ビットfloatを読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
32	buf.readFloatBE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから32ビットfloatを読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
33	buf.readDoubleLE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから64ビットのdoubleを読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
34	buf.readDoubleBE(offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットにあるバッファから64ビットのdoubleを読み取ります。オフセットの検証をスキップするには、noAssertをtrueに設定します。これは、オフセットがバッファーの終わりを超えている可能性があることを意味します。デフォルトはfalseです。
35	buf.writeUInt8(value, offset[, noAssert]) 指定されたオフセットでバッファに値を書き込みます。値は有効な符号なし8ビット整数でなければならないことに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
36	buf.writeUInt16LE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な符号なし16ビット整数でなければならないことに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
37	buf.writeUInt16BE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な符号なし16ビット整数でなければならないことに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
38	buf.writeUInt32LE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な符号なし32ビット整数でなければならないことに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
39	buf.writeUInt32BE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な符号なし32ビット整数でなければならないことに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
40	buf.writeInt8(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な符号付き8ビット整数でなければならないことに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
41	buf.writeInt16LE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な符号付き16ビット整数である必要があることに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
42	buf.writeInt16BE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な符号付き16ビット整数である必要があることに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
43	buf.writeInt32LE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な符号付き32ビット整数でなければならないことに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
44	buf.writeInt32BE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な符号付き32ビット整数でなければならないことに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
45	buf.writeFloatLE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な32ビットのfloatでなければならないことに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、値が特定の関数に対して大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
46	buf.writeFloatBE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な32ビットfloatである必要があります。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
47	buf.writeDoubleLE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な64ビットのdoubleである必要があることに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、値が特定の関数に対して大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
48	buf.writeDoubleBE(value, offset[, noAssert]) 指定されたエンディアン形式で、指定されたオフセットのバッファに値を書き込みます。値は有効な64ビットのdoubleである必要があることに注意してください。値とオフセットの検証をスキップするには、noAssertをtrueに設定します。これは、特定の関数に対して値が大きすぎる可能性があり、オフセットがバッファーの終わりを超えて、値が暗黙的にドロップされる原因になる可能性があることを意味します。正確性が確実でない限り、使用しないでください。デフォルトはfalseです。
49	buf.fill(value[, offset][, end]) 指定された値でバッファを埋めます。オフセット（デフォルトは0）および終了（デフォルトはbuffer.length）が指定されていない場合、バッファー全体が埋められます。

クラスメソッド

Sr.No.	Method & Description
1	Buffer.isEncoding(encoding) エンコードが有効なエンコード引数である場合はtrueを返し、そうでない場合はfalseを返します。
2	Buffer.isBuffer(obj) objがバッファかどうかをテストします。
3	Buffer.byteLength(string[, encoding]) 文字列の実際のバイト長を示します。エンコードのデフォルトは「utf8」です。 String.prototype.lengthは文字列の文字数を返すため、String.prototype.lengthとは異なります。
4	Buffer.concat(list[, totalLength]) リスト内のすべてのバッファーを連結した結果であるバッファーを返します。
5	Buffer.compare(buf1, buf2) buf1.compare（buf2）と同じです。バッファーの配列のソートに役立ちます。

Node.js-ストリーム

ストリームとは何ですか？

ストリームは、ソースからデータを読み取ったり、宛先にデータを連続的に書き込んだりできるオブジェクトです。 Node.jsでは、4種類のストリームがあります-

Readable -読み取り操作に使用されるストリーム。
Writable -書き込み操作に使用されるストリーム。
Duplex -読み取りと書き込みの両方の操作に使用できるストリーム。
Transform -出力が入力に基づいて計算されるデュプレックスストリームのタイプ。

Streamの各タイプは EventEmitter インスタンスであり、異なるインスタンスで複数のイベントをスローします。たとえば、一般的に使用されるイベントのいくつかは-

data -読み取り可能なデータがある場合にこのイベントが発生します。
終了-このイベントは、読み取るデータがなくなると発生します。
エラー-このイベントは、データの受信または書き込みでエラーが発生したときに発生します。
finish -すべてのデータが基になるシステムにフラッシュされると、このイベントが発生します。

このチュートリアルは、Streamsで一般的に使用される操作の基本的な理解を提供します。

ストリームからの読み取り

次の内容を持つinput.txtという名前のテキストファイルを作成します-

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

次のコードでmain.jsという名前のjsファイルを作成します-

var fs = require("fs");
var data = '';

//Create a readable stream
var readerStream = fs.createReadStream('input.txt');

//Set the encoding to be utf8.
readerStream.setEncoding('UTF8');

//Handle stream events --> data, end, and error
readerStream.on('data', function(chunk) {
   data &plus;= chunk;
});

readerStream.on('end',function() {
   console.log(data);
});

readerStream.on('error', function(err) {
   console.log(err.stack);
});

console.log("Program Ended");

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Program Ended
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

ストリームへの書き込み

次のコードでmain.jsという名前のjsファイルを作成します-

var fs = require("fs");
var data = 'Simply Easy Learning';

//Create a writable stream
var writerStream = fs.createWriteStream('output.txt');

//Write the data to stream with encoding to be utf8
writerStream.write(data,'UTF8');

//Mark the end of file
writerStream.end();

//Handle stream events --> finish, and error
writerStream.on('finish', function() {
   console.log("Write completed.");
});

writerStream.on('error', function(err) {
   console.log(err.stack);
});

console.log("Program Ended");

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Program Ended
Write completed.

現在のディレクトリに作成されたoutput.txtを開きます。それは次を含む必要があります-

Simply Easy Learning

ストリームのパイピング

パイピングは、あるストリームの出力を別のストリームへの入力として提供するメカニズムです。通常、あるストリームからデータを取得し、そのストリームの出力を別のストリームに渡すために使用されます。配管操作に制限はありません。次に、あるファイルから読み取り、別のファイルに書き込むためのパイピングの例を示します。

次のコードでmain.jsという名前のjsファイルを作成します-

var fs = require("fs");

//Create a readable stream
var readerStream = fs.createReadStream('input.txt');

//Create a writable stream
var writerStream = fs.createWriteStream('output.txt');

//Pipe the read and write operations
//read input.txt and write data to output.txt
readerStream.pipe(writerStream);

console.log("Program Ended");

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Program Ended

現在のディレクトリに作成されたoutput.txtを開きます。それは次を含む必要があります-

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

ストリームの連鎖

チェーンは、1つのストリームの出力を別のストリームに接続し、複数のストリーム操作のチェーンを作成するメカニズムです。通常、配管操作で使用されます。次に、パイピングとチェーンを使用して、最初にファイルを圧縮し、次に同じファイルを解凍します。

次のコードでmain.jsという名前のjsファイルを作成します-

var fs = require("fs");
var zlib = require('zlib');

//Compress the file input.txt to input.txt.gz
fs.createReadStream('input.txt')
   .pipe(zlib.createGzip())
   .pipe(fs.createWriteStream('input.txt.gz'));

console.log("File Compressed.");

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

File Compressed.

input.txtが圧縮され、現在のディレクトリにinput.txt.gzファイルが作成されていることがわかります。今、次のコードを使用して同じファイルを解凍してみましょう-

var fs = require("fs");
var zlib = require('zlib');

//Decompress the file input.txt.gz to input.txt
fs.createReadStream('input.txt.gz')
   .pipe(zlib.createGunzip())
   .pipe(fs.createWriteStream('input.txt'));

console.log("File Decompressed.");

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

File Decompressed.

Node.js-ファイルシステム

Nodeは、標準POSIX関数の単純なラッパーを使用してファイルI/Oを実装します。ノードファイルシステム（fs）モジュールは、次の構文を使用してインポートすることができます-

var fs = require("fs")

同期vs非同期

fsモジュールのすべてのメソッドには、同期フォームと非同期フォームがあります。非同期メソッドは、最後のパラメーターを完了関数のコールバックとして受け取り、コールバック関数の最初のパラメーターをエラーとして受け取ります。前者は実行中にプログラムをブロックすることはありませんが、2番目のメソッドはブロックするため、同期メソッドの代わりに非同期メソッドを使用することをお勧めします。

例

次の内容で input.txt という名前のテキストファイルを作成します-

Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

次のコードで main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");

//Asynchronous read
fs.readFile('input.txt', function (err, data) {
   if (err) {
      return console.error(err);
   }
   console.log("Asynchronous read: " + data.toString());
});

//Synchronous read
var data = fs.readFileSync('input.txt');
console.log("Synchronous read: " + data.toString());

console.log("Program Ended");

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Synchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

Program Ended
Asynchronous read: Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

この章の次のセクションでは、主要なファイルI/O方法の優れた例を紹介します。

ファイルを開く

構文

以下は、非同期モードでファイルを開くためのメソッドの構文です-

fs.open(path, flags[, mode], callback)

パラメーター

ここに使用されるパラメータの説明があります-

path -これは、パスを含むファイル名を持つ文字列です。
flags -フラグは、開かれるファイルの動作を示します。可能なすべての値については、以下で説明しています。
mode -ファイルモード（許可およびスティッキービット）を設定しますが、ファイルが作成された場合のみです。デフォルトは0666で、読み書き可能です。
callback -これは、2つの引数（err、fd）を取得するコールバック関数です。

フラグ

読み取り/書き込み操作のフラグは-

Sr.No.	Flag & Description
1	r 読み取り用にファイルを開きます。ファイルが存在しない場合、例外が発生します。
2	r+ 読み取りおよび書き込み用にファイルを開きます。ファイルが存在しない場合、例外が発生します。
3	rs 同期モードで読み取るためにファイルを開きます。
4	rs+ ファイルを読み取りおよび書き込み用に開き、OSに同期的に開くように要求します。これを慎重に使用することについては、「rs」の注意事項を参照してください。
5	w 書き込み用にファイルを開きます。ファイルが作成される（存在しない場合）か、切り捨てられます（存在する場合）。
6	wx 'w’に似ていますが、パスが存在する場合は失敗します。
7	w+ 読み取りおよび書き込み用にファイルを開きます。ファイルが作成される（存在しない場合）か、切り捨てられます（存在する場合）。
8	wx+ 「w +」と似ていますが、パスが存在する場合は失敗します。
9	a 追加するファイルを開きます。ファイルが存在しない場合は作成されます。
10	ax 'a’に似ていますが、パスが存在する場合は失敗します。
11	a+ 読み取りおよび追加のためにファイルを開きます。ファイルが存在しない場合は作成されます。
12	ax+ 'a +'に似ていますが、パスが存在する場合は失敗します。

例

次のコードを持つ main.js という名前のjsファイルを作成して、読み取りおよび書き込み用にファイルinput.txtを開きます。

var fs = require("fs");

//Asynchronous - Opening File
console.log("Going to open file!");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File opened successfully!");
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to open file!
File opened successfully!

ファイル情報を取得する

構文

以下は、ファイルに関する情報を取得するためのメソッドの構文です-

fs.stat(path, callback)

パラメーター

ここに使用されるパラメータの説明があります-

path -これは、パスを含むファイル名を持つ文字列です。
callback -これは2つの引数（err、stats）を取得するコールバック関数です。ここで、 stats はfs.Stats型のオブジェクトで、以下の例で出力されます。

以下の例で印刷されている重要な属性とは別に、 fs.Stats クラスで利用可能ないくつかの便利なメソッドがあり、これらを使用してファイルタイプをチェックできます。これらのメソッドを次の表に示します。

Sr.No.	Method & Description
1	stats.isFile() 単純なファイルのファイルタイプの場合、trueを返します。
2	stats.isDirectory() ディレクトリのファイルタイプの場合、trueを返します。
3	stats.isBlockDevice() ブロックデバイスのファイルタイプの場合、trueを返します。
4	stats.isCharacterDevice() キャラクターデバイスのファイルタイプの場合にtrueを返します。
5	stats.isSymbolicLink() シンボリックリンクのファイルタイプの場合、trueを返します。
6	stats.isFIFO() FIFOのファイルタイプの場合、trueを返します。
7	stats.isSocket() ファイルタイプがasocketの場合、trueを返します。

例

次のコードで main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");

console.log("Going to get file info!");
fs.stat('input.txt', function (err, stats) {
   if (err) {
      return console.error(err);
   }
   console.log(stats);
   console.log("Got file info successfully!");

  //Check file type
   console.log("isFile ? " + stats.isFile());
   console.log("isDirectory ? " + stats.isDirectory());
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to get file info!
{
   dev: 1792,
   mode: 33188,
   nlink: 1,
   uid: 48,
   gid: 48,
   rdev: 0,
   blksize: 4096,
   ino: 4318127,
   size: 97,
   blocks: 8,
   atime: Sun Mar 22 2015 13:40:00 GMT-0500 (CDT),
   mtime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT),
   ctime: Sun Mar 22 2015 13:40:57 GMT-0500 (CDT)
}
Got file info successfully!
isFile ? true
isDirectory ? false

ファイルを書く

構文

以下は、ファイルに書き込む方法の1つの構文です-

fs.writeFile(filename, data[, options], callback)

ファイルが既に存在する場合、このメソッドはファイルを上書きします。既存のファイルに書き込みたい場合は、利用可能な別の方法を使用する必要があります。

パラメーター

ここに使用されるパラメータの説明があります-

path -これは、パスを含むファイル名を持つ文字列です。
データ-これは、ファイルに書き込まれる文字列またはバッファです。
オプション-3番目のパラメータは、\ {encoding、mode、flag}を保持するオブジェクトです。デフォルトで。エンコードはutf8、モードは8進数値0666です。フラグは「w」です
callback -これは、書き込みエラーの場合にエラーを返す単一のパラメーターerrを取得するコールバック関数です。

例

私たちは次のコードを持つ main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");

console.log("Going to write into existing file");
fs.writeFile('input.txt', 'Simply Easy Learning!', function(err) {
   if (err) {
      return console.error(err);
   }

   console.log("Data written successfully!");
   console.log("Let's read newly written data");

   fs.readFile('input.txt', function (err, data) {
      if (err) {
         return console.error(err);
      }
      console.log("Asynchronous read: " + data.toString());
   });
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to write into existing file
Data written successfully!
Let's read newly written data
Asynchronous read: Simply Easy Learning!

ファイルを読む

構文

以下は、ファイルから読み取るメソッドの1つの構文です-

fs.read(fd, buffer, offset, length, position, callback)

このメソッドは、ファイル記述子を使用してファイルを読み取ります。ファイル名を使用してファイルを直接読み取る場合は、別の方法を使用する必要があります。

パラメーター

ここに使用されるパラメータの説明があります-

fd -これは、fs.open（）によって返されるファイル記述子です。
バッファ-これは、データが書き込まれるバッファです。
offset -これは書き込みを開始するバッファ内のオフセットです。
長さ-これは読み込むバイト数を指定する整数です。
位置-これは、ファイル内の読み取りを開始する場所を指定する整数です。位置がヌルの場合、データは現在のファイル位置から読み取られます。
callback -これは、3つの引数（err、bytesRead、buffer）を取得するコールバック関数です。

例

次のコードで main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");
var buf = new Buffer(1024);

console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File opened successfully!");
   console.log("Going to read the file");

   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
      if (err){
         console.log(err);
      }
      console.log(bytes + " bytes read");

     //Print only read bytes to avoid junk.
      if(bytes > 0){
         console.log(buf.slice(0, bytes).toString());
      }
   });
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to open an existing file
File opened successfully!
Going to read the file
97 bytes read
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

ファイルを閉じる

構文

以下は、開いているファイルを閉じるための構文です-

fs.close(fd, callback)

パラメーター

ここに使用されるパラメータの説明があります-

fd -これは、ファイルfs.open（）メソッドによって返されるファイル記述子です。
callback -これはコールバック関数です。完了コールバックには、可能な例外以外の引数は与えられません。

例

私たちは次のコードを持つ main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");
var buf = new Buffer(1024);

console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File opened successfully!");
   console.log("Going to read the file");

   fs.read(fd, buf, 0, buf.length, 0, function(err, bytes) {
      if (err) {
         console.log(err);
      }

     //Print only read bytes to avoid junk.
      if(bytes > 0) {
         console.log(buf.slice(0, bytes).toString());
      }

     //Close the opened file.
      fs.close(fd, function(err) {
         if (err) {
            console.log(err);
         }
         console.log("File closed successfully.");
      });
   });
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to open an existing file
File opened successfully!
Going to read the file
Tutorials Point is giving self learning content
to teach the world in simple and easy way!!!!!

File closed successfully.

ファイルを切り捨てる

構文

以下は、開かれたファイルを切り捨てる方法の構文です-

fs.ftruncate(fd, len, callback)

パラメーター

ここに使用されるパラメータの説明があります-

fd -これは、fs.open（）によって返されるファイル記述子です。
len -これは、ファイルが切り捨てられる前のファイルの長さです。
callback -これはコールバック関数です。完了コールバックには、可能な例外以外の引数は与えられません。

例

私たちは次のコードを持つ main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");
var buf = new Buffer(1024);

console.log("Going to open an existing file");
fs.open('input.txt', 'r+', function(err, fd) {
   if (err) {
      return console.error(err);
   }
   console.log("File opened successfully!");
   console.log("Going to truncate the file after 10 bytes");

  //Truncate the opened file.
   fs.ftruncate(fd, 10, function(err) {
      if (err) {
         console.log(err);
      }
      console.log("File truncated successfully.");
      console.log("Going to read the same file");

      fs.read(fd, buf, 0, buf.length, 0, function(err, bytes){
         if (err) {
            console.log(err);
         }

        //Print only read bytes to avoid junk.
         if(bytes > 0) {
            console.log(buf.slice(0, bytes).toString());
         }

        //Close the opened file.
         fs.close(fd, function(err) {
            if (err) {
               console.log(err);
            }
            console.log("File closed successfully.");
         });
      });
   });
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to open an existing file
File opened successfully!
Going to truncate the file after 10 bytes
File truncated successfully.
Going to read the same file
Tutorials
File closed successfully.

ファイルを削除する

構文

以下は、ファイルを削除するメソッドの構文です-

fs.unlink(path, callback)

パラメーター

ここに使用されるパラメータの説明があります-

path -これはパスを含むファイル名です。
callback -これはコールバック関数です。完了コールバックには、可能な例外以外の引数は与えられません。

例

私たちは次のコードを持つ main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");

console.log("Going to delete an existing file");
fs.unlink('input.txt', function(err) {
   if (err) {
      return console.error(err);
   }
   console.log("File deleted successfully!");
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to delete an existing file
File deleted successfully!

ディレクトリを作成する

構文

以下は、ディレクトリを作成するメソッドの構文です-

fs.mkdir(path[, mode], callback)

パラメーター

ここに使用されるパラメータの説明があります-

path -これはパスを含むディレクトリ名です。
mode -これは設定するディレクトリの許可です。デフォルトは0777です。
callback -これはコールバック関数です。完了コールバックには、可能な例外以外の引数は与えられません。

例

私たちは次のコードを持つ main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");

console.log("Going to create directory/tmp/test");
fs.mkdir('/tmp/test',function(err) {
   if (err) {
      return console.error(err);
   }
   console.log("Directory created successfully!");
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to create directory/tmp/test
Directory created successfully!

ディレクトリを読む

構文

以下は、ディレクトリを読み取るためのメソッドの構文です-

fs.readdir(path, callback)

パラメーター

ここに使用されるパラメータの説明があります-

path -これはパスを含むディレクトリ名です。
callback -これは2つの引数（err、files）を取得するコールバック関数です。filesは、 '。'を除くディレクトリ内のファイル名の配列です。および「..」。

例

私たちは次のコードを持つ main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");

console.log("Going to read directory/tmp");
fs.readdir("/tmp/",function(err, files) {
   if (err) {
      return console.error(err);
   }
   files.forEach( function (file) {
      console.log( file );
   });
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to read directory/tmp
ccmzx99o.out
ccyCSbkF.out
employee.ser
hsperfdata_apache
test
test.txt

ディレクトリを削除する

構文

以下は、ディレクトリを削除する方法の構文です-

fs.rmdir(path, callback)

パラメーター

ここに使用されるパラメータの説明があります-

path -これはパスを含むディレクトリ名です。
callback -これはコールバック関数です。完了コールバックには、可能な例外以外の引数は与えられません。

例

私たちは次のコードを持つ main.js という名前のjsファイルを作成しましょう-

var fs = require("fs");

console.log("Going to delete directory/tmp/test");
fs.rmdir("/tmp/test",function(err) {
   if (err) {
      return console.error(err);
   }
   console.log("Going to read directory/tmp");

   fs.readdir("/tmp/",function(err, files) {
      if (err) {
         return console.error(err);
      }
      files.forEach( function (file) {
         console.log( file );
      });
   });
});

次に、main.jsを実行して結果を確認します-

$ node main.js

出力を確認します。

Going to read directory/tmp
ccmzx99o.out
ccyCSbkF.out
employee.ser
hsperfdata_apache
test.txt

メソッドリファレンス

____Followingは、Node.jsで利用可能なファイルシステムモジュールのリファレンスです。詳細については、公式ドキュメントを参照してください。

Sr.No	Method & Description
1	fs.rename(oldPath, newPath, callback) 非同期rename（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
2	fs.ftruncate(fd, len, callback) 非同期のftruncate（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
3	fs.ftruncateSync(fd, len) 同期ftruncate（）。
4	fs.truncate(path, len, callback) 非同期truncate（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
5	fs.truncateSync(path, len) 同期truncate（）。
6	fs.chown(path, uid, gid, callback) 非同期chown（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
7	fs.chownSync(path, uid, gid) 同期chown（）。
8	fs.fchown(fd, uid, gid, callback) 非同期fchown（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
9	fs.fchownSync(fd, uid, gid) 同期fchown（）。
10	fs.lchown(path, uid, gid, callback) 非同期lchown（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
11	fs.lchownSync(path, uid, gid) 同期lchown（）。
12	fs.chmod(path, mode, callback) 非同期chmod（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
13	fs.chmodSync(path, mode) 同期chmod（）。
14	fs.fchmod(fd, mode, callback) 非同期fchmod（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
15	fs.fchmodSync(fd, mode) 同期fchmod（）。
16	fs.lchmod(path, mode, callback) 非同期lchmod（）。可能性のある例外以外の引数は、完了コールバックに渡されません。 Mac OS Xでのみ利用可能です。
17	fs.lchmodSync(path, mode) 同期lchmod（）。
18	fs.stat(path, callback) 非同期stat（）。コールバックは、statsがfs.Statsオブジェクトである2つの引数（err、stats）を取得します。
19	fs.lstat(path, callback) 非同期lstat（）。コールバックは、statsがfs.Statsオブジェクトである2つの引数（err、stats）を取得します。 lstat（）はstat（）と同じですが、pathがシンボリックリンクの場合、参照するファイルではなく、リンク自体がstat-edになります。
20	fs.fstat(fd, callback) 非同期fstat（）。コールバックは、statsがfs.Statsオブジェクトである2つの引数（err、stats）を取得します。 fstat（）は、stat（）と同じですが、stat-ed対象のファイルがファイル記述子fdで指定されている点が異なります。
21	fs.statSync(path) 同期stat（）。 fs.Statsのインスタンスを返します。
22	fs.lstatSync(path) 同期lstat（）。 fs.Statsのインスタンスを返します。
23	fs.fstatSync(fd) 同期fstat（）。 fs.Statsのインスタンスを返します。
24	fs.link(srcpath, dstpath, callback) 非同期link（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
25	fs.linkSync(srcpath, dstpath) 同期link（）。
26	fs.symlink(srcpath, dstpath[, type], callback) 非同期symlink（）。可能性のある例外以外の引数は、完了コールバックに渡されません。 type引数は、 'dir'、 'file'、または 'junction'（デフォルトは 'file'）に設定でき、Windowsでのみ使用可能です（他のプラットフォームでは無視されます）。 Windowsジャンクションポイントでは、宛先パスが絶対パスである必要があることに注意してください。「junction」を使用する場合、宛先引数は自動的に絶対パスに正規化されます。
27	fs.symlinkSync(srcpath, dstpath[, type]) 同期symlink（）。
28	fs.readlink(path, callback) 非同期readlink（）。コールバックは、2つの引数（err、linkString）を取得します。
29	fs.realpath(path[, cache], callback) 非同期realpath（）。コールバックは、2つの引数（err、resolvedPath）を取得します。 process.cwdを使用して、相対パスを解決できます。キャッシュは、特定のパス解決を強制したり、既知の実際のパスに対する追加のfs.stat呼び出しを回避するために使用できる、マッピングされたパスのオブジェクトリテラルです。
30	fs.realpathSync(path[, cache]) 同期realpath（）。解決されたパスを返します。
31	fs.unlink(path, callback) 非同期unlink（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
32	fs.unlinkSync(path) 同期unlink（）。
33	fs.rmdir(path, callback) 非同期rmdir（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
34	fs.rmdirSync(path) 同期rmdir（）。
35	fs.mkdir(path[, mode], callback) 非同期mkdir（2）。可能性のある例外以外の引数は、完了コールバックに渡されません。モードのデフォルトは0777です。
36	fs.mkdirSync(path[, mode]) 同期mkdir（）。
37	fs.readdir(path, callback) 非同期readdir（3）。ディレクトリの内容を読み取ります。コールバックは、2つの引数（err、files）を取得します。filesは、ディレクトリ内の「。」を除くファイル名の配列です。および「..」。
38	fs.readdirSync(path) 同期readdir（）。「。」を除くファイル名の配列を返しますおよび「..」。
39	fs.close(fd, callback) 非同期のclose（）。可能性のある例外以外の引数は、完了コールバックに渡されません。
40	fs.closeSync(fd) 同期close（）。
41	fs.open(path, flags[, mode], callback) 非同期ファイルを開きます。
42	fs.openSync(path, flags[, mode]) fs.open（）の同期バージョン。
43	fs.utimes(path, atime, mtime, callback)
44	fs.utimesSync(path, atime, mtime) 指定されたパスによって参照されるファイルのファイルのタイムスタンプを変更します。
45	fs.futimes(fd, atime, mtime, callback)
46	fs.futimesSync(fd, atime, mtime) 指定されたファイル記述子によって参照されるファイルのファイルのタイムスタンプを変更します。
47	fs.fsync(fd, callback) 非同期fsync。可能性のある例外以外の引数は、完了コールバックに渡されません。
48	fs.fsyncSync(fd) 同期fsync。
49	fs.write(fd, buffer, offset, length[, position], callback) fdで指定されたファイルにバッファを書き込みます。
50	fs.write(fd, data[, position[, encoding]], callback) fdで指定されたファイルにデータを書き込みます。データがBufferインスタンスでない場合、値は文字列に強制されます。
51	fs.writeSync(fd, buffer, offset, length[, position]) fs.write（）の同期バージョン。書き込まれたバイト数を返します。
52	fs.writeSync(fd, data[, position[, encoding]]) fs.write（）の同期バージョン。書き込まれたバイト数を返します。
53	fs.read(fd, buffer, offset, length, position, callback) fdで指定されたファイルからデータを読み取ります。
54	fs.readSync(fd, buffer, offset, length, position) fs.readの同期バージョン。 bytesReadの数を返します。
55	fs.readFile(filename[, options], callback) ファイルのコンテンツ全体を非同期で読み取ります。
56	fs.readFileSync(filename[, options]) fs.readFileの同期バージョン。ファイル名の内容を返します。
57	fs.writeFile(filename, data[, options], callback) データをファイルに非同期的に書き込み、ファイルが既に存在する場合はそれを置き換えます。データは文字列またはバッファです。
58	fs.writeFileSync(filename, data[, options]) fs.writeFileの同期バージョン。
59	fs.appendFile(filename, data[, options], callback) ファイルにデータを非同期的に追加し、ファイルが存在しない場合は作成します。データは文字列またはバッファです。
60	fs.appendFileSync(filename, data[, options]) fs.appendFileの同期バージョン。
61	fs.watchFile(filename[, options], listener) ファイル名の変更に注意してください。コールバックリスナーは、ファイルにアクセスするたびに呼び出されます。
62	fs.unwatchFile(filename[, listener]) ファイル名の変更の監視を停止します。リスナーが指定されている場合、その特定のリスナーのみが削除されます。そうしないと、すべてのリスナーが削除され、ファイル名の監視が事実上停止します。
63	fs.watch(filename[, options][, listener]) ファイル名の変更を監視します。ファイル名はファイルまたはディレクトリです。返されるオブジェクトはfs.FSWatcherです。
64	fs.exists(path, callback) ファイルシステムをチェックして、指定されたパスが存在するかどうかをテストします。次に、trueまたはfalseでコールバック引数を呼び出します。
65	fs.existsSync(path) fs.existsの同期バージョン。
66	fs.access(path[, mode], callback) パスで指定されたファイルに対するユーザーの権限をテストします。 modeは、実行するアクセシビリティチェックを指定するオプションの整数です。
67	fs.accessSync(path[, mode]) fs.accessの同期バージョン。アクセシビリティチェックが失敗した場合はスローし、それ以外は何もしません。
68	fs.createReadStream(path[, options]) 新しいReadStreamオブジェクトを返します。
69	fs.createWriteStream(path[, options]) 新しいWriteStreamオブジェクトを返します。
70	fs.symlink(srcpath, dstpath[, type], callback) 非同期symlink（）。可能性のある例外以外の引数は、完了コールバックに渡されません。 type引数は、 'dir'、 'file'、または 'junction'（デフォルトは 'file'）に設定でき、Windowsでのみ使用可能です（他のプラットフォームでは無視されます）。 Windowsジャンクションポイントでは、宛先パスが絶対パスである必要があることに注意してください。「junction」を使用する場合、宛先引数は自動的に絶対パスに正規化されます。

Node.js-グローバルオブジェクト

Node.jsグローバルオブジェクトは本質的にグローバルであり、すべてのモジュールで使用できます。これらのオブジェクトをアプリケーションに含める必要はなく、直接使用できます。これらのオブジェクトは、以下で説明するように、モジュール、関数、文字列、およびオブジェクト自体です。

__ファイル名

*__ filename* は、実行中のコードのファイル名を表します。 これは、このコードファイルの解決された絶対パスです。 メインプログラムの場合、これは必ずしもコマンドラインで使用されるファイル名と同じではありません。 モジュール内の値は、そのモジュールファイルへのパスです。

例

次のコードでmain.jsという名前のjsファイルを作成します-

//Let's try to print the value of __filename

console.log( __filename );

次に、main.jsを実行して結果を確認します-

$ node main.js

あなたのプログラムの場所に基づいて、それは次のようにメインファイル名を印刷します-

/web/com/1427091028_21099/main.js

__dirname

*__ dirname* は、現在実行中のスクリプトが存在するディレクトリの名前を表します。

例

次のコードでmain.jsという名前のjsファイルを作成します-

//Let's try to print the value of __dirname

console.log( __dirname );

次に、main.jsを実行して結果を確認します-

$ node main.js

プログラムの場所に基づいて、次のように現在のディレクトリ名を出力します-

/web/com/1427091028_21099

setTimeout（cb、ms）

setTimeout（cb、ms）*グローバル関数は、少なくともmsミリ秒後にコールバックcbを実行するために使用されます。実際の遅延は、OSタイマーの粒度やシステム負荷などの外部要因に依存します。タイマーは24.8日を超えることはできません。

この関数は、タイマーをクリアするために使用できるタイマーを表す不透明な値を返します。

例

次のコードでmain.jsという名前のjsファイルを作成します-

function printHello() {
   console.log( "Hello, World!");
}

//Now call above function after 2 seconds
setTimeout(printHello, 2000);

次に、main.jsを実行して結果を確認します-

$ node main.js

少し遅れて出力が印刷されることを確認します。

Hello, World!

clearTimeout（t）

clearTimeout（t）グローバル関数は、setTimeout（）で以前に作成されたタイマーを停止するために使用されます。ここで、 *t はsetTimeout（）関数によって返されるタイマーです。

例

次のコードでmain.jsという名前のjsファイルを作成します-

function printHello() {
   console.log( "Hello, World!");
}

//Now call above function after 2 seconds
var t = setTimeout(printHello, 2000);

//Now clear the timer
clearTimeout(t);

次に、main.jsを実行して結果を確認します-

$ node main.js

何も印刷されない出力を確認します。

setInterval（cb、ms）

setInterval（cb、ms）*グローバル関数は、少なくともmsミリ秒後にコールバックcbを繰り返し実行するために使用されます。実際の遅延は、OSタイマーの粒度やシステム負荷などの外部要因に依存します。タイマーは24.8日を超えることはできません。

この関数は、* clearInterval（t）*関数を使用してタイマーをクリアするために使用できるタイマーを表す不透明な値を返します。

例

次のコードでmain.jsという名前のjsファイルを作成します-

function printHello() {
   console.log( "Hello, World!");
}

//Now call above function after 2 seconds
setInterval(printHello, 2000);

次に、main.jsを実行して結果を確認します-

$ node main.js

上記のプログラムは、2秒ごとにprintHello（）を実行します。システム制限のため。

グローバルオブジェクト

次の表に、アプリケーションで頻繁に使用する他のオブジェクトのリストを示します。詳細については、公式ドキュメントを参照してください。

Sr.No.

Module Name & Description

1

Console

stdoutおよびstderrに関する情報を印刷するために使用されます。

2

Process

現在のプロセスに関する情報を取得するために使用されます。プロセスアクティビティに関連する複数のイベントを提供します。

Node.js-ユーティリティモジュール

Node.jsモジュールライブラリには、いくつかのユーティリティモジュールがあります。これらのモジュールは非常に一般的であり、ノードベースのアプリケーションの開発中に頻繁に使用されます。

Sr.No.	Module Name & Description
1	OS Module 基本的なオペレーティングシステム関連のユーティリティ機能を提供します。
2	Path Module ファイルパスを処理および変換するためのユーティリティを提供します。
3	Net Module サーバーとクライアントの両方をストリームとして提供します。ネットワークラッパーとして機能します。
4	DNS Module 実際のDNSルックアップを行う機能と、基盤となるオペレーティングシステムの名前解決機能を使用する機能を提供します。
5	Domain Module 複数の異なるI/O操作を単一のグループとして処理する方法を提供します。

Node.js-Webモジュール

Webサーバーとは何ですか？

Webサーバーは、Webブラウザなど、HTTPクライアントから送信されたHTTP要求を処理し、クライアントへの応答としてWebページを返すソフトウェアアプリケーションです。 Webサーバーは通常、画像、スタイルシート、およびスクリプトとともにHTMLドキュメントを配信します。

ほとんどのWebサーバーは、スクリプト言語を使用するか、データベースからデータを取得して複雑なロジックを実行し、Webサーバーを介してHTTPクライアントに結果を送信するアプリケーションサーバーにタスクをリダイレクトするサーバー側スクリプトをサポートします。

Apache Webサーバーは、最も一般的に使用されるWebサーバーの1つです。これはオープンソースプロジェクトです。

Webアプリケーションアーキテクチャ

Webアプリケーションは通常4つの層に分割されます-

Webアーキテクチャ

クライアント-この層は、Webサーバー、HTTPリクエストを行うことができるWebブラウザー、モバイルブラウザー、またはアプリケーションで構成されます。
サーバー-このレイヤーには、クライアントによって行われた要求をインターセプトし、それらに応答を渡すことができるWebサーバーがあります。
ビジネス-このレイヤーには、Webサーバーが必要な処理を行うために使用するアプリケーションサーバーが含まれます。この層は、データベースまたはいくつかの外部プログラムを介してデータ層と対話します。
データ-このレイヤーには、データベースまたはその他のデータソースが含まれます。

Nodeを使用したWebサーバーの作成

Node.jsは、サーバーのHTTPクライアントを作成するために使用できる http モジュールを提供します。以下は、8081ポートでリッスンするHTTPサーバーの最低限の構造です。

server.jsという名前のjsファイルを作成します-

ファイル：server.js *

var http = require('http');
var fs = require('fs');
var url = require('url');

//Create a server
http.createServer( function (request, response) {
  //Parse the request containing file name
   var pathname = url.parse(request.url).pathname;

  //Print the name of the file for which request is made.
   console.log("Request for " + pathname + " received.");

  //Read the requested file content from file system
   fs.readFile(pathname.substr(1), function (err, data) {
      if (err) {
         console.log(err);

        //HTTP Status: 404 : NOT FOUND
        //Content Type: text/plain
         response.writeHead(404, {'Content-Type': 'text/html'});
      } else {
        //Page found
        //HTTP Status: 200 : OK
        //Content Type: text/plain
         response.writeHead(200, {'Content-Type': 'text/html'});

        //Write the content of the file to response body
         response.write(data.toString());
      }

     //Send the response body
      response.end();
   });
}).listen(8081);

//Console will print the message
console.log('Server running at http://127.0.0.1:8081/');

次に、server.jsを作成したのと同じディレクトリに、indexという名前の次のhtmlファイルを作成します。

ファイル：インデックス

<html>
   <head>
      <title>Sample Page</title>
   </head>

   <body>
      Hello World!
   </body>
</html>

今、私たちは結果を見るためにserver.jsを実行しましょう-

$ node server.js

出力を確認します。

Server running at http://127.0.0.1:8081/

Node.jsサーバーにリクエストを行う

任意のブラウザーでhttp://127.0.0.1:8081/indexを開いて、次の結果を確認します。

最初のサーバーアプリケーション

サーバー側の出力を確認します。

Server running at http://127.0.0.1:8081/
Request for/index received.

Nodeを使用してWebクライアントを作成する

Webクライアントは、 http モジュールを使用して作成できます。次の例を確認してみましょう。

client.jsという名前のjsファイルを作成します-

ファイル：client.js *

var http = require('http');

//Options to be used by request
var options = {
   host: 'localhost',
   port: '8081',
   path: '/index'
};

//Callback function is used to deal with response
var callback = function(response) {
  //Continuously update stream with data
   var body = '';
   response.on('data', function(data) {
      body += data;
   });

   response.on('end', function() {
     //Data received completely.
      console.log(body);
   });
}
//Make a request to the server
var req = http.request(options, callback);
req.end();

今、結果を見るためにserver.js以外の別のコマンドターミナルからclient.jsを実行します-

$ node client.js

出力を確認します。

<html>
   <head>
      <title>Sample Page</title>
   </head>

   <body>
      Hello World!
   </body>
</html>

サーバー側の出力を確認します。

Server running at http://127.0.0.1:8081/
Request for/index received.

Node.js-Express Framework

エクスプレスの概要

Expressは、Webおよびモバイルアプリケーションを開発するための堅牢な機能セットを提供する、最小限で柔軟なNode.js Webアプリケーションフレームワークです。 NodeベースのWebアプリケーションの迅速な開発を促進します。以下は、Expressフレームワークのコア機能の一部です-

HTTPリクエストに応答するミドルウェアを設定できます。
HTTPメソッドとURLに基づいてさまざまなアクションを実行するために使用されるルーティングテーブルを定義します。
引数をテンプレートに渡すことに基づいて、HTMLページを動的にレンダリングできます。

Expressのインストール

まず、NPMを使用してExpressフレームワークをグローバルにインストールし、ノードターミナルを使用してWebアプリケーションを作成できるようにします。

$ npm install express --save

上記のコマンドは、インストールをローカルに node_modules ディレクトリに保存し、node_modules内にexpressというディレクトリを作成します。あなたはエクスプレスと一緒に次の重要なモジュールをインストールする必要があります-

body-parser -これは、JSON、Raw、Text、およびURLエンコードされたフォームデータを処理するためのnode.jsミドルウェアです。
cookie-parser -Cookieヘッダーを解析し、req.cookiesにCookie名をキーとするオブジェクトを入力します。
multer -これは、multipart/form-dataを処理するためのnode.jsミドルウェアです。

$ npm install body-parser --save
$ npm install cookie-parser --save
$ npm install multer --save

Hello worldの例

以下は、サーバーを起動し、ポート8081で接続を待機する非常に基本的なExpressアプリです。このアプリは、ホームページへのリクエストに対して* Hello World！で応答します。他のすべてのパスについては、 404 Not Found。*で応答します。

var express = require('express');
var app = express();

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

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port

   console.log("Example app listening at http://%s:%s", host, port)
})

上記のコードをserver.jsという名前のファイルに保存し、次のコマンドで実行します。

$ node server.js

次の出力が表示されます-

Example app listening at http://0.0.0.0:8081

任意のブラウザーでhttp://127.0.0.1:8081/を開き、次の結果を確認します。

最初のアプリケーション

リクエストとレスポンス

Expressアプリケーションは、パラメータが request および response オブジェクトであるコールバック関数を使用します。

app.get('/', function (req, res) {
  //--
})

link：/nodejs/nodejs_request_object [リクエストオブジェクト]-リクエストオブジェクトはHTTPリクエストを表し、リクエストクエリ文字列、パラメーター、ボディ、HTTPヘッダーなどのプロパティがあります。
link：/nodejs/nodejs_response_object [Response Object]-レスポンスオブジェクトは、ExpressアプリがHTTPリクエストを受け取ったときに送信するHTTPレスポンスを表します。

Cookie、セッション、URLなどを含むHTTPリクエストおよびレスポンスに関連する多くの情報を提供する req および res オブジェクトを印刷できます。

基本的なルーティング

ホームページのHTTPリクエストを処理する基本的なアプリケーションを見てきました。ルーティングとは、特定のエンドポイントに対するクライアントリクエストに対するアプリケーションの応答方法を決定することです。これは、URI（またはパス）および特定のHTTPリクエストメソッド（GET、POSTなど）です。

Hello Worldプログラムを拡張して、より多くの種類のHTTP要求を処理します。

var express = require('express');
var app = express();

//This responds with "Hello World" on the homepage
app.get('/', function (req, res) {
   console.log("Got a GET request for the homepage");
   res.send('Hello GET');
})

//This responds a POST request for the homepage
app.post('/', function (req, res) {
   console.log("Got a POST request for the homepage");
   res.send('Hello POST');
})

//This responds a DELETE request for the/del_user page.
app.delete('/del_user', function (req, res) {
   console.log("Got a DELETE request for/del_user");
   res.send('Hello DELETE');
})

//This responds a GET request for the/list_user page.
app.get('/list_user', function (req, res) {
   console.log("Got a GET request for/list_user");
   res.send('Page Listing');
})

//This responds a GET request for abcd, abxcd, ab123cd, and so on
app.get('/ab*cd', function(req, res) {
   console.log("Got a GET request for/ab*cd");
   res.send('Page Pattern Match');
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port

   console.log("Example app listening at http://%s:%s", host, port)
})

上記のコードをserver.jsという名前のファイルに保存し、次のコマンドで実行します。

$ node server.js

次の出力が表示されます-

Example app listening at http://0.0.0.0:8081

これで、http：//127.0.0.1：8081でさまざまなリクエストを試して、server.jsによって生成された出力を確認できます。以下は、さまざまなURLに対するさまざまな応答を示すスクリーンショットです。

再び表示される画面http://127.0.0.1:8081/list_user

2番目のアプリケーション

再び表示される画面http://127.0.0.1:8081/abcd

第3アプリケーション

再び表示される画面http://127.0.0.1:8081/abcdefg

第4アプリケーション

静的ファイルの提供

Expressは、画像、CSS、JavaScriptなどの静的ファイルを提供する組み込みミドルウェア express.static を提供します。

静的アセットを保持するディレクトリの名前を express.static ミドルウェアに渡して、ファイルの直接提供を開始するだけです。たとえば、画像、CSS、およびJavaScriptファイルをpublicという名前のディレクトリに保存する場合、これを行うことができます-

app.use(express.static('public'));

次のように、いくつかの画像を public/images サブディレクトリに保存します-

node_modules
server.js
public/
public/images
public/images/logo.png

「Hello Word」アプリを変更して、静的ファイルを処理する機能を追加しましょう。

var express = require('express');
var app = express();

app.use(express.static('public'));

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

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port

   console.log("Example app listening at http://%s:%s", host, port)
})

上記のコードをserver.jsという名前のファイルに保存し、次のコマンドで実行します。

$ node server.js

ブラウザでhttp://127.0.0.1:8081/images/logo.pngを開き、次の結果を確認します。

5番目のアプリケーション

GETメソッド

次に、HTML FORM GETメソッドを使用して2つの値を渡す簡単な例を示します。 server.js内で process_get ルーターを使用して、この入力を処理します。

<html>
   <body>

      <form action = "http://127.0.0.1:8081/process_get" method = "GET">
         First Name: <input type = "text" name = "first_name">  <br>
         Last Name: <input type = "text" name = "last_name">
         <input type = "submit" value = "Submit">
      </form>

   </body>
</html>

上記のコードをインデックスに保存し、server.jsを変更して、ホームページ要求とHTMLフォームによって送信された入力を処理します。

var express = require('express');
var app = express();

app.use(express.static('public'));
app.get('/index', function (req, res) {
   res.sendFile( __dirname + "/" + "index" );
})

app.get('/process_get', function (req, res) {
  //Prepare output in JSON format
   response = {
      first_name:req.query.first_name,
      last_name:req.query.last_name
   };
   console.log(response);
   res.end(JSON.stringify(response));
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port

   console.log("Example app listening at http://%s:%s", host, port)
})

_http：//127.0.0.1：8081/index_を使用してHTMLドキュメントにアクセスすると、次のフォームが生成されます-

ファーストネーム：

苗字：

今、あなたは名と姓を入力し、結果を見るために送信ボタンをクリックすることができ、それは次の結果を返すはずです-

{"first_name":"John","last_name":"Paul"}

POSTメソッド

以下は、HTML FORM POSTメソッドを使用して2つの値を渡す簡単な例です。 server.js内で process_get ルーターを使用して、この入力を処理します。

<html>
   <body>

      <form action = "http://127.0.0.1:8081/process_post" method = "POST">
         First Name: <input type = "text" name = "first_name"> <br>
         Last Name: <input type = "text" name = "last_name">
         <input type = "submit" value = "Submit">
      </form>

   </body>
</html>

上記のコードをインデックスに保存し、server.jsを変更して、ホームページ要求とHTMLフォームから送信された入力を処理します。

var express = require('express');
var app = express();
var bodyParser = require('body-parser');

//Create application/x-www-form-urlencoded parser
var urlencodedParser = bodyParser.urlencoded({ extended: false })

app.use(express.static('public'));
app.get('/index', function (req, res) {
   res.sendFile( __dirname + "/" + "index" );
})

app.post('/process_post', urlencodedParser, function (req, res) {
  //Prepare output in JSON format
   response = {
      first_name:req.body.first_name,
      last_name:req.body.last_name
   };
   console.log(response);
   res.end(JSON.stringify(response));
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port

   console.log("Example app listening at http://%s:%s", host, port)
})

_http：//127.0.0.1：8081/index_を使用してHTMLドキュメントにアクセスすると、次のフォームが生成されます-

ファーストネーム：

苗字：

今、あなたは名と姓を入力し、次の結果を見るために送信ボタンをクリックすることができます-

{"first_name":"John","last_name":"Paul"}

ファイルアップロード

次のHTMLコードは、ファイルアップローダーフォームを作成します。このフォームのメソッド属性は POST に設定され、enctype属性は multipart/form-data に設定されます

<html>
   <head>
      <title>File Uploading Form</title>
   </head>

   <body>
      <h3>File Upload:</h3>
      Select a file to upload: <br/>

      <form action = "http://127.0.0.1:8081/file_upload" method = "POST"
         enctype = "multipart/form-data">
         <input type="file" name="file" size="50"/>
         <br/>
         <input type = "submit" value = "Upload File"/>
      </form>

   </body>
</html>

上記のコードをインデックスに保存し、server.jsを変更して、ホームページのリクエストとファイルのアップロードを処理します。

var express = require('express');
var app = express();
var fs = require("fs");

var bodyParser = require('body-parser');
var multer  = require('multer');

app.use(express.static('public'));
app.use(bodyParser.urlencoded({ extended: false }));
app.use(multer({ dest: '/tmp/'}));

app.get('/index', function (req, res) {
   res.sendFile( __dirname + "/" + "index" );
})

app.post('/file_upload', function (req, res) {
   console.log(req.files.file.name);
   console.log(req.files.file.path);
   console.log(req.files.file.type);
   var file = __dirname + "/" + req.files.file.name;

   fs.readFile( req.files.file.path, function (err, data) {
      fs.writeFile(file, data, function (err) {
         if( err ) {
            console.log( err );
            } else {
               response = {
                  message:'File uploaded successfully',
                  filename:req.files.file.name
               };
            }

         console.log( response );
         res.end( JSON.stringify( response ) );
      });
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port

   console.log("Example app listening at http://%s:%s", host, port)
})

_http：//127.0.0.1：8081/index_を使用してHTMLドキュメントにアクセスすると、次のフォームが生成されます-

File Upload:
Select a file to upload:



NOTE: This is just dummy form and would not work, but it must work at your server.

クッキー管理

次のミドルウェアオプションを使用して、同じものを処理できるNode.jsサーバーにCookieを送信できます。以下は、クライアントから送信されたすべてのCookieを印刷する簡単な例です。

var express      = require('express')
var cookieParser = require('cookie-parser')

var app = express()
app.use(cookieParser())

app.get('/', function(req, res) {
   console.log("Cookies: ", req.cookies)
})
app.listen(8081)

Node.js-RESTful API

RESTアーキテクチャとは何ですか？

RESTは、REpresentational State Transferの略です。 RESTはWeb標準ベースのアーキテクチャであり、HTTPプロトコルを使用します。すべてのコンポーネントがリソースであり、リソースがHTTP標準メソッドを使用して共通のインターフェースによってアクセスされるリソースを中心に展開します。 RESTは、2000年にRoy Fieldingによって初めて導入されました。

RESTサーバーは、リソースへのアクセスとRESTクライアントへのアクセスを提供し、HTTPプロトコルを使用してリソースを変更します。ここで、各リソースはURI/グローバルIDによって識別されます。 RESTはさまざまな表現を使用して、テキスト、JSON、XMLなどのリソースを表しますが、JSONが最も人気があります。

HTTPメソッド

RESTベースのアーキテクチャでは、次の4つのHTTPメソッドが一般的に使用されます。

GET -これは、リソースへの読み取り専用アクセスを提供するために使用されます。
PUT -これは、新しいリソースを作成するために使用されます。
DELETE -これはリソースを削除するために使用されます。
POST -これは、既存のリソースの更新または新しいリソースの作成に使用されます。

RESTful Webサービス

Webサービスは、アプリケーション間またはシステム間でデータを交換するために使用されるオープンプロトコルおよび標準の集まりです。様々なプログラミング言語で書かれ、様々なプラットフォーム上で実行されるソフトウェアアプリケーションは、単一のコンピュータ上のプロセス間通信と同様に、インターネットのようなコンピュータネットワークを介してデータを交換するためにウェブサービスを使用することができる。この相互運用性（JavaとPython、またはWindowsとLinuxアプリケーション間の通信など）は、オープンスタンダードの使用によるものです。

RESTアーキテクチャに基づくWebサービスは、RESTful Webサービスとして知られています。これらのWebサービスは、HTTPメソッドを使用してRESTアーキテクチャの概念を実装します。通常、RESTful WebサービスはURI、Uniform Resource Identifierサービスを定義し、JSONやHTTPメソッドのセットなどのリソース表現を提供します。

ライブラリー用のRESTfulの作成

ファイル users.json に次のユーザーを持つユーザーのJSONベースのデータベースがあるとします。

{
   "user1" : {
      "name" : "mahesh",
      "password" : "password1",
      "profession" : "teacher",
      "id": 1
   },

   "user2" : {
      "name" : "suresh",
      "password" : "password2",
      "profession" : "librarian",
      "id": 2
   },

   "user3" : {
      "name" : "ramesh",
      "password" : "password3",
      "profession" : "clerk",
      "id": 3
   }
}

この情報に基づいて、次のRESTful APIを提供します。

Sr.No.	URI	HTTP Method	POST body	Result
1	listUsers	GET	empty	Show list of all the users.
2	addUser	POST	JSON String	Add details of new user.
3	deleteUser	DELETE	JSON String	Delete an existing user.
4	:id	GET	empty	Show details of a user.

Ajaxまたは単純なフォームデータを使用してフロントエンドから値を渡す方法と、Express Request オブジェクトを使用して値を処理する方法を既に知っていることを前提として、すべての例の大部分をハードコーディングの形式で保持しています。

ユーザーの一覧表示

server.jsファイルで次のコードを使用して、最初のRESTful API listUsers を実装しましょう-

server.js

var express = require('express');
var app = express();
var fs = require("fs");

app.get('/listUsers', function (req, res) {
   fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
      console.log( data );
      res.end( data );
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   console.log("Example app listening at http://%s:%s", host, port)
})

ここで、_URL：http://127.0.0.1:8081/listUsers_および_HTTPメソッドを使用して、定義済みのAPIにアクセスしてみてください。RESTクライアントを使用して、ローカルマシンでGET_を実行します。これは、次の結果を生成する必要があります-

ソリューションを実稼働環境に配置するときに、指定したIPアドレスを変更できます。

{
   "user1" : {
      "name" : "mahesh",
      "password" : "password1",
      "profession" : "teacher",
      "id": 1
   },

   "user2" : {
      "name" : "suresh",
      "password" : "password2",
      "profession" : "librarian",
      "id": 2
   },

   "user3" : {
      "name" : "ramesh",
      "password" : "password3",
      "profession" : "clerk",
      "id": 3
   }
}

ユーザーを追加する

次のAPIは、リストに新しいユーザーを追加する方法を示します。以下は、新しいユーザーの詳細です-

user = {
   "user4" : {
      "name" : "mohit",
      "password" : "password4",
      "profession" : "teacher",
      "id": 4
   }
}

Ajax呼び出しを使用してJSONの形式で同じ入力を受け入れることができますが、視点を教えるために、ここでハードコーディングしています。以下は、データベース内の新しいユーザーへの addUser APIです-

server.js

var express = require('express');
var app = express();
var fs = require("fs");

var user = {
   "user4" : {
      "name" : "mohit",
      "password" : "password4",
      "profession" : "teacher",
      "id": 4
   }
}

app.post('/addUser', function (req, res) {
  //First read existing users.
   fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
      data = JSON.parse( data );
      data["user4"] = user["user4"];
      console.log( data );
      res.end( JSON.stringify(data));
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   console.log("Example app listening at http://%s:%s", host, port)
})

ここで、_URL：http://127.0.0.1:8081/addUser_および_HTTPメソッドを使用して、定義済みのAPIにアクセスしてみてください。RESTクライアントを使用して、ローカルマシンでPOST_を実行します。これは、次の結果を生成する必要があります-

{
   "user1":{"name":"mahesh","password":"password1","profession":"teacher","id":1},
   "user2":{"name":"suresh","password":"password2","profession":"librarian","id":2},
   "user3":{"name":"ramesh","password":"password3","profession":"clerk","id":3},
   "user4":{"name":"mohit","password":"password4","profession":"teacher","id":4}
}

詳細を表示

次に、ユーザーIDを使用して呼び出されるAPIを実装し、対応するユーザーの詳細を表示します。

server.js

var express = require('express');
var app = express();
var fs = require("fs");

app.get('/:id', function (req, res) {
  //First read existing users.
   fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
      var users = JSON.parse( data );
      var user = users["user" + req.params.id]
      console.log( user );
      res.end( JSON.stringify(user));
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   console.log("Example app listening at http://%s:%s", host, port)
})

ここで、_URL：http://127.0.0.1:8081/2_および_HTTPメソッドを使用して、定義済みのAPIにアクセスしてみてください。RESTクライアントを使用して、ローカルマシンでGET_を実行します。これは、次の結果を生成する必要があります-

{"name":"suresh","password":"password2","profession":"librarian","id":2}

ユーザーを削除

このAPIは、req.bodyを介して入力データを受け取り、ユーザーIDに基づいてそのユーザーをデータベースから削除するaddUser APIと非常に似ています。プログラムをシンプルに保つために、ID 2のユーザーを削除することを想定しています。

*server.js*

var express = require('express');
var app = express();
var fs = require("fs");

var id = 2;

app.delete('/deleteUser', function (req, res) {
  //First read existing users.
   fs.readFile( __dirname + "/" + "users.json", 'utf8', function (err, data) {
      data = JSON.parse( data );
      delete data["user" + 2];

      console.log( data );
      res.end( JSON.stringify(data));
   });
})

var server = app.listen(8081, function () {
   var host = server.address().address
   var port = server.address().port
   console.log("Example app listening at http://%s:%s", host, port)
})

ここで、_URL：http://127.0.0.1:8081/deleteUser_および_HTTP Method：DELETE_を使用して、任意のRESTクライアントを使用してローカルマシンで定義済みのAPIにアクセスしてみてください。これは、次の結果を生成する必要があります-

{"user1":{"name":"mahesh","password":"password1","profession":"teacher","id":1},
"user3":{"name":"ramesh","password":"password3","profession":"clerk","id":3}}

Node.js-スケーリングアプリケーション

Node.jsはシングルスレッドモードで実行されますが、同時実行を処理するためにイベント駆動型のパラダイムを使用します。また、子プロセスの作成を容易にし、マルチコアCPUベースのシステムでの並列処理を活用します。

子プロセスには、常に3つのストリーム child.stdin 、 child.stdout 、および child.stderr があり、親プロセスのstdioストリームと共有できます。

Nodeは、子プロセスを作成する次の3つの主要な方法を持つ child_process モジュールを提供します。

exec -child_process.execメソッドは、シェル/コンソールでコマンドを実行し、出力をバッファリングします。
spawn -child_process.spawnは、指定されたコマンドで新しいプロセスを起動します。
fork -child_process.forkメソッドは、子プロセスを作成するspawn（）の特殊なケースです。

exec（）メソッド

child_process.execメソッドは、シェルでコマンドを実行し、出力をバッファリングします。次の署名があります-

child_process.exec(command[, options], callback)

パラメーター

ここに使用されるパラメータの説明があります-

command （文字列）スペースで区切られた引数を使用して実行するコマンド
オプション（オブジェクト）は、次のオプションの1つ以上を含むことがあります-
cwd （文字列）子プロセスの現在の作業ディレクトリ
env （オブジェクト）環境のキーと値のペア
encoding （String）（デフォルト： 'utf8'）
shell （文字列）コマンドを実行するシェル（デフォルト：UNIXでは「/bin/sh」、Windowsでは「cmd.exe」、シェルはUNIXの-cスイッチまたはWindowsの/s/cを理解する必要があります。 Windowsでは、コマンドライン解析はcmd.exeと互換性があります。
timeout （数値）（デフォルト：0）
maxBuffer （数値）（デフォルト：200 * 1024）
killSignal （文字列）（デフォルト： 'SIGTERM'）
uid （数値）プロセスのユーザーIDを設定します。
gid （数値）プロセスのグループIDを設定します。
callback この関数は、プロセスの終了時に出力とともに呼び出される3つの引数 error 、* stdout、、および *stderr を取得します。

exec（）メソッドは、最大サイズのバッファを返し、プロセスが終了するまで待機し、バッファされたすべてのデータを一度に返そうとします。

例

support.jsとmaster.jsという2つのjsファイルを作成しましょう-

ファイル：support.js *

console.log("Child Process " + process.argv[2] + " executed." );

ファイル：master.js *

const fs = require('fs');
const child_process = require('child_process');

for(var i=0; i<3; i++) {
   var workerProcess = child_process.exec('node support.js '+i,function
      (error, stdout, stderr) {

      if (error) {
         console.log(error.stack);
         console.log('Error code: '+error.code);
         console.log('Signal received: '+error.signal);
      }
      console.log('stdout: ' + stdout);
      console.log('stderr: ' + stderr);
   });

   workerProcess.on('exit', function (code) {
      console.log('Child process exited with exit code '+code);
   });
}

今、master.jsを実行して結果を確認します-

$ node master.js

出力を確認します。サーバーが起動しました。

Child process exited with exit code 0
stdout: Child Process 1 executed.

stderr:
Child process exited with exit code 0
stdout: Child Process 0 executed.

stderr:
Child process exited with exit code 0
stdout: Child Process 2 executed.

spawn（）メソッド

child_process.spawnメソッドは、指定されたコマンドで新しいプロセスを起動します。次の署名があります-

child_process.spawn(command[, args][, options])

パラメーター

ここに使用されるパラメータの説明があります-

command （文字列）実行するコマンド
args （配列）文字列引数のリスト
オプション（オブジェクト）は、次のオプションの1つ以上を含むことがあります-
cwd （文字列）子プロセスの現在の作業ディレクトリ。
env （オブジェクト）環境のキーと値のペア。
stdio （配列）文字列子のstdio設定。
customFds （配列）stdioで使用する子の非推奨ファイル記述子。
detached （ブール値）子はプロセスグループリーダーになります。
uid （数値）プロセスのユーザーIDを設定します。
gid （数値）プロセスのグループIDを設定します。

spawn（）メソッドはストリーム（stdout＆stderr）を返します。プロセスが大量のデータを返す場合に使用する必要があります。 spawn（）は、プロセスの実行が開始されるとすぐに応答の受信を開始します。

例

support.jsおよびmaster.jsという名前の2つのjsファイルを作成します-

ファイル：support.js *

console.log("Child Process " + process.argv[2] + " executed." );

ファイル：master.js *

const fs = require('fs');
const child_process = require('child_process');

for(var i = 0; i<3; i++) {
   var workerProcess = child_process.spawn('node', ['support.js', i]);

   workerProcess.stdout.on('data', function (data) {
      console.log('stdout: ' + data);
   });

   workerProcess.stderr.on('data', function (data) {
      console.log('stderr: ' + data);
   });

   workerProcess.on('close', function (code) {
      console.log('child process exited with code ' + code);
   });
}

今、master.jsを実行して結果を確認します-

$ node master.js

出力を確認します。サーバーが起動しました

stdout: Child Process 0 executed.

child process exited with code 0
stdout: Child Process 1 executed.

stdout: Child Process 2 executed.

child process exited with code 0
child process exited with code 0

fork（）メソッド

child_process.forkメソッドは、Nodeプロセスを作成するspawn（）の特殊なケースです。次の署名があります-

child_process.fork(modulePath[, args][, options])

パラメーター

ここに使用されるパラメータの説明があります-

modulePath （文字列）子で実行するモジュール。
args （配列）文字列引数のリスト
オプション（オブジェクト）は、次のオプションの1つ以上を含むことがあります-
cwd （文字列）子プロセスの現在の作業ディレクトリ。
env （オブジェクト）環境のキーと値のペア。
execPath （文字列）子プロセスの作成に使用される実行可能ファイル。
execArgv （配列）実行可能ファイルに渡される文字列引数のリスト（デフォルト：process.execArgv）。
silent （ブール値）trueの場合、子のstdin、stdout、およびstderrは親にパイプされます。そうでない場合は、親から継承されます。spawn（）の「パイプ」および「継承」オプションを参照してください。詳細についてはstdio（デフォルトはfalse）。
uid （数値）プロセスのユーザーIDを設定します。
gid （数値）プロセスのグループIDを設定します。

forkメソッドは、通常のChildProcessインスタンスにすべてのメソッドを含めることに加えて、組み込みの通信チャネルを持つオブジェクトを返します。

例

support.jsおよびmaster.jsという名前の2つのjsファイルを作成します-

ファイル：support.js *

console.log("Child Process " + process.argv[2] + " executed." );

ファイル：master.js *

const fs = require('fs');
const child_process = require('child_process');

for(var i=0; i<3; i++) {
   var worker_process = child_process.fork("support.js", [i]);

   worker_process.on('close', function (code) {
      console.log('child process exited with code ' + code);
   });
}

今、master.jsを実行して結果を確認します-

$ node master.js

出力を確認します。サーバーが起動しました。

Child Process 0 executed.
Child Process 1 executed.
Child Process 2 executed.
child process exited with code 0
child process exited with code 0
child process exited with code 0

Node.js-パッケージング

*JXcore* はオープンソースプロジェクトであり、ソースファイルおよびその他のアセットをJXパッケージにパッケージ化および暗号化するための独自の機能を導入しています。

多くのファイルで構成される大きなプロジェクトがあるとします。 JXcoreはそれらをすべて単一ファイルにパックして、配布を簡素化できます。この章では、JXcoreのインストールから始まるプロセス全体の概要を簡単に説明します。

JXcoreのインストール

JXcoreのインストールは非常に簡単です。ここでは、システムにJXcoreをインストールする方法について順を追って説明しました。以下の手順に従ってください-

ステップ1

オペレーティングシステムとマシンアーキテクチャに従って、https://github.com/jxcore/jxcoreからJXcoreパッケージをダウンロードします。 64ビットマシンで実行されているCenotsのパッケージをダウンロードしました。

$ wget https://s3.amazonaws.com/nodejx/jx_rh64.zip

ステップ2

ダウンロードしたファイル* jx_rh64.zip *を解凍し、jxバイナリを/usr/binにコピーするか、システムのセットアップに基づいて他のディレクトリに置くことができます。

$ unzip jx_rh64.zip
$ cp jx_rh64/jx/usr/bin

ステップ3

PATH変数を適切に設定して、好きな場所からjxを実行します。

$ export PATH=$PATH:/usr/bin

ステップ4

以下に示すような簡単なコマンドを発行することにより、インストールを確認できます。次のように動作し、バージョン番号を出力するはずです-

$ jx --version
v0.10.32

コードのパッケージ化

Node.js、メインファイル、index.js、およびローカルにインストールされたすべてのモジュールを含むすべてのファイルを保持する次のディレクトリを持つプロジェクトがあると考えてください。

drwxr-xr-x  2 root root  4096 Nov 13 12:42 images
-rwxr-xr-x  1 root root 30457 Mar  6 12:19 index
-rwxr-xr-x  1 root root 30452 Mar  1 12:54 index.js
drwxr-xr-x 23 root root  4096 Jan 15 03:48 node_modules
drwxr-xr-x  2 root root  4096 Mar 21 06:10 scripts
drwxr-xr-x  2 root root  4096 Feb 15 11:56 style

上記のプロジェクトをパッケージ化するには、このディレクトリ内に移動して、次のjxコマンドを発行するだけです。 index.jsがNode.jsプロジェクトのエントリファイルであると仮定します-

$ jx package index.js index

ここでは、* index。の代わりに他のパッケージ名を使用できます。メインファイル名をindex.jxのままにしておくため、 *index を使用しました。ただし、上記のコマンドはすべてをパックし、次の2つのファイルを作成します-

index.jxp これは、プロジェクトのコンパイルに必要な完全なプロジェクト詳細を含む中間ファイルです。
index.jx これは、クライアントまたは実稼働環境に出荷する準備ができている完全なパッケージを含むバイナリファイルです。

JXファイルの起動

元のNode.jsプロジェクトが次のように実行されていたと考えてください-

$ node index.js command_line_arguments

JXcoreを使用してパッケージをコンパイルした後、次のように開始することができます-

$ jx index.jx command_line_arguments

JXcoreの詳細については、公式Webサイトをご覧ください。

Nodejs-quick-guide

Node.js-はじめに

Node.jsとは何ですか？

Node.jsの機能

Node.jsを使用するのは誰ですか？

概念

Node.jsを使用する場所

Node.jsを使用しない場所

Node.js-環境設定

オンラインで試す

ローカル環境のセットアップ

テキストエディタ

Node.jsランタイム

Node.jsアーカイブをダウンロードする

UNIX/Linux/Mac OS X、およびSunOSへのインストール

Windowsへのインストール

インストールの検証：ファイルの実行

Node.js-最初のアプリケーション

Node.jsアプリケーションの作成

ステップ1-必要なモジュールのインポート

ステップ2-サーバーの作成

ステップ3-要求と応答のテスト

Node.jsサーバーにリクエストを行う

Node.js-REPLターミナル

オンラインREPLターミナル

REPLの開始

簡単な表現

変数を使用する

複数行の式

アンダースコア変数

REPLコマンド

REPLの停止

Node.js-NPM

NPMを使用したモジュールのインストール

グローバルインストールとローカルインストール

package.jsonを使用する

Package.jsonの属性

モジュールのアンインストール

モジュールの更新

モジュールを検索する

モジュールを作成する

Node.js-コールバックの概念

コールバックとは何ですか？

ブロッキングコードの例

ノンブロッキングコードの例

Node.js-イベントループ

イベント駆動型プログラミング

例

ノードアプリケーションの仕組み

Node.js-イベントエミッター

EventEmitterクラス

方法

クラスメソッド

イベント

例

Node.js-バッファー

バッファを作成する

方法1

方法2

方法3

バッファへの書き込み

構文

パラメーター

戻り値

例

バッファーからの読み取り

構文

パラメーター

戻り値

例

バッファをJSONに変換

構文

戻り値

例

連結バッファー

構文

パラメーター

戻り値

例

バッファーの比較