この翻訳は不完全です。英語から この記事を翻訳 してください。

Expressの最初の記事では、”Nodeって何だろう?”、”Expressって何だろう?”という疑問に答え、なぜExpress webが特別なのかについて概要を説明します。主な特徴、Expressアプリケーションの主なビルディングブロック(テスト開発環境についてはここではまだ触れません)を大まかに説明します。

前提条件 基本的なコンピュータリテラシー。サーバーサイドのウェブサイトプログラミングの一般的な理解、特にウェブサイトにおけるクライアントとサーバーのやりとりの仕組み。
目標 Express の特徴、Node との適合性、提供する機能、Express アプリケーションの主要なビルディングブロックに慣れてください。

Node の紹介

Node(正式にはNode.js)はオープンソースのクロスプラットフォーム、実行環境で、開発者はあらゆるサーバーサイドのツールやアプリケーションを JavaScript で作成することができます。この実行環境は、ラウザコンテキスト外での使用 (すなわち、コンピューターまたはサーバー OS 上での直接実行) を目的としています。そのため、クライアントサイドではブラウザー固有の JavaScript API が省略され、HTTP やファイルシステムライブラリを含む従来の OS API がサポートされます

Webサーバー開発の観点から Node には多くの利点があります。

  • 素晴らしいパフォーマンス! Node は Web アプリケーションのスループットとスケーラビリティを最適化するように設計されており、多くの一般的な Web 開発の問題 (リアルタイムWebアプリケーションなど) に非常に適しています。
  • コードは "plain old JavaScript" で書かれています。つまり、ブラウザと Web サーバーの両方のコードを記述しているときに、言語間の "コンテキストシフト" に費やす時間が短くなります。
  • JavaScript は比較的新しいプログラミング言語であり、他の従来のWebサーバ言語 (Python、PHPなど) と比較して言語設計の改善のメリットがあります。CoffeeScript、ClosureScript、Scala、LiveScript などを使用できるように、新しく普及している多くの言語が JavaScript にコンパイル/変換されます。
  • ノードパッケージマネージャー (NPM) は、何十万もの再利用可能なパッケージへのアクセスを提供します。クラス最高の依存関係解決機能もあり、ほとんどのビルドツールチェーンの自動化にも使用できます。
  • Node.js は移植可能です。Microsoft Windows、macOS、Linux、Solaris、FreeBSD、OpenBSD、WebOS、およびNonStop OS で利用できます。さらに、多くの Web ホスティングプロバイダは、Node サイトをホスティングするための特定のインフラストラクチャとドキュメントを提供することがよくあります。
  • 非常に活発な第三者のエコシステムと開発者コミュニティがあり、多くの方々が喜んで協力しています。

Node HTTP パッケージを使用することで、Node.js で簡単な Web サーバーを作成できます。

Hello Node.js

次の例では、URL http://127.0.0.1:8000/ にあるあらゆる種類の HTTP リクエストを待ち受ける Web サーバーを作成します。リクエストが受信されると、スクリプトは "Hello World" という文字列でレスポンスします。すでに Node をインストールしている場合は、次の手順に従ってこの例を試すことができます。

  1. ターミナルを開きます (Windows ではコマンドラインユーティリティを開きます)
  2. プログラムを保存するフォルダ (たとえば "test-node") を作成し、端末に次のコマンドを入力して移動します
cd test-node
  1. 好きなテキストエディタを使って "hello.js" というファイルを作成し、次のコードを貼り付けます
// HTTPモジュールの読み込み
var http = require("http");

//  HTTPサーバーを作成し、ポート8000で要求を行う
http.createServer(function(request, response) {

   // Set the response HTTP header with HTTP status and Content type
   response.writeHead(200, {'Content-Type': 'text/plain'});
   
   // レスポンスボディー"Hello World"を送信
   response.end('Hello World\n');
}).listen(8000);

//  サーバーにアクセスするためのURLを出力 
console.log('Server running at http://127.0.0.1:8000/');
  1. 上記で作成したフォルダにファイルを保存します
  2. ターミナルに戻り、次のコマンドを入力します
node "hello.js"

最後に、Web ブラウザで "http://localhost:8000" に移動します。空の Web ページでなければ、左上に "Hello World" というテキストが表示されます。

Web フレームワーク

その他の一般的な Web 開発タスクは、Node 自体では直接サポートされていません。異なる HTTP 動詞 (GET, POST, DELETE など) に特定の処理を追加したい場合、別々の URL パス ("routes") でリクエストを個別に処理したり、静的ファイルを提供したり、テンプレートを使用してレスポンスを動的に作成したり、あなた自身でコードを書く必要があります。そうしない場合は Web フレームワークを使用して、タイヤの再構築を避けることができます。

Express のイントロダクション

Express は最も一般的な Node Web フレームワークであり、他の多くの一般的な Node Web フレームワークの基礎となるライブラリです。それは以下のメカニズムを提供します:

  • 異なる URL のパス (ルート) で異なる HTTP 動詞を使用してリクエストのハンドラを作成します。
  • テンプレートにデータを挿入してレスポンスを生成するために、「ビュー」レンダリングエンジンと統合します。
  • 接続に使用するポートやレスポンスのレンダリングに使用されるテンプレートの場所などの一般的な Web アプリケーション設定値を設定します。
  • リクエスト処理パイプライン内の任意の時点で、追加のリクエスト処理「ミドルウェア」を追加します。

Express 自体はかなりシンプルですが、開発者はほぼすべての Web 開発問題に対応する互換性のあるミドルウェアパッケージを作成しています。Cookie、セッション、ユーザーログイン、URL パラメータ、POST データ、セキュリティヘッダーなどを扱うライブラリがあります。Express チームが管理するミドルウェア・パッケージのリストは、Express Middleware (一般的なサード・パーティ・パッケージのリストとともに) にあります。

注: この柔軟性は両刃の剣です。ほぼすべての問題や要件に対応するミドルウェアパッケージがありますが、適切なパッケージを使用して作業することは時には挑戦になることがあります。アプリケーションを構造化する「正しい方法」もなく、インターネット上で見つかる多くの例は最適ではないし、ウェブアプリケーションを開発するために必要なことのほんの一部を示しているだけです。

Node と Express はどこから来たのですか?

Node は2009年に Linux 用に最初にリリースされました。NPMパッケージマネージャは2010年にリリースされ、ネイティブ Windows サポートは2012年に追加されました。現在の LTS リリースは Node v8.11.3 で、最新のリリースは Node 10.7.0 です。これは、豊かな歴史の小さなスナップショットです。もっと知りたいのであれば、Wikipedia を掘り下げてみてください。

Express は2010年11月に最初にリリースされ、現在 API のバージョンが 4.16.3 になっています。現在のリリースの変更点についてはチェンジログを、詳細な履歴リリースノートについては GitHub を参照してください。

Node と Express はどれくらい普及していますか?

Web フレームワークの普及は、それが維持されるかどうかの指標であり、ドキュメンテーション、アドオンライブラリ、テクニカルサポートの面でどのようなリソースが利用される可能性が高いかという点で重要です。

サーバー側のフレームワークの普及率 (Hot Frameworks のようなサイトでは、GitHub プロジェクトの数や各プラットフォームの StackOverflow の質問数などの仕組みを使って人気を評価しようとしています) は、すぐに利用可能で決定的なものではありません。より良い質問は、人気のないプラットフォームの問題を避けるために Node と Express が「人気がある」かどうかです。それらは進化し続けていますか?あなたがそれを必要としたら助けを得ることができますか?あなたが Express を学ぶならば、あなたは職を得る機会がありますか?

Based on the number of high profile companies that use Express, the number of people contributing to the codebase, and the number of people providing both free and paid for support, then yes, Express is a popular framework!

Express は論評されていますか?

Webフレームワークは、しばしば、自分自身を「敬意を表した」または「未評価」と呼んでいます。

意見の分かれたフレームワークは、特定のタスクを処理するための「正しい方法」についての意見を持ったフレームワークです。彼らは、何かを行う正しい方法は、通常よく理解され、よく文書化されているため、特定のドメインでの迅速な開発をサポートします(特定のタイプの問題を解決する)。しかし、主ドメイン以外の問題の解決に柔軟性を欠き、使用できるコンポーネントやアプローチの選択肢が少なくなる傾向があります。

対照的に、ユニファイド化されていないフレームワークは、目標を達成するためにコンポーネントを一緒に接着する最善の方法、または使用するコンポーネントを制限することが非常に少なくなっています。開発者は、特定のタスクを完了するために最も適したツールを簡単に使用できます。ただし、それらのコンポーネントを自分で見つける必要があります。

Expressは未評価です。ほとんどの互換性のあるミドルウェアは、リクエスト処理チェーンに、好きな順序で挿入することができます。アプリケーションを1つのファイルまたは複数のファイルで構成し、任意のディレクトリ構造を使用することができます。あなたは時にはあまりにも多くの選択肢があると感じることがあります!

Expressコードはどのように見えますか?

従来のデータ駆動型Webサイトでは、WebアプリケーションはWebブラウザ(または他のクライアント)からのHTTP要求を待機します。要求が受信されると、アプリケーションは、URLパターンと、POSTデータまたはGETデータに含まれる可能性のある関連情報に基づいて、必要なアクションを実行します。必要に応じて、データベースから情報を読み書きしたり、要求を満たすために必要な他のタスクを実行することができます。アプリケーションはウェブブラウザに応答を返し、検索されたデータをHTMLテンプレートのプレースホルダに挿入することによってブラウザが表示するHTMLページを動的に作成することがよくあります。

Express は特定の HTTP 動詞(GET, POST, SET など) と URL パターン ("Route") に対してどの関数が呼び出されるかを指定するメソッドと、どのテンプレート ("view") エンジンが使用されるかを指定するメソッドファイルが配置され、レスポンスをレンダリングするために使用するテンプレート。Express ミドルウェアを使用して、Cookie、セッション、およびユーザー、POST/GET パラメーターなどのサポートを追加することができます。Node がサポートするデータベース・メカニズムを使用できます (Express はデータベース関連の動作を定義しません)。

次のセクションでは、Expressおよびノー​​ド・コードを使用して作業するときに表示される一般的な事項について説明します。

Helloworld Express

First lets consider the standard Express Hello World example (we discuss each part of this below, and in the following sections).

Tip: If you have Node and Express already installed (or if you install them as shown in the next article), you can save this code in a text file called app.js and run it in a bash command prompt by calling:   

node ./app.js

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

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

app.listen(3000, function() {
  console.log('Example app listening on port 3000!');
});

The first two lines require() (import) the express module and create an Express application. This object, which is traditionally named app, has methods for routing HTTP requests, configuring middleware, rendering HTML views, registering a template engine, and modifying application settings that control how the application behaves (e.g. the environment mode, whether route definitions are case sensitive, etc.)

The middle part of the code (the three lines starting with app.get) shows a route definition. The app.get() method specifies a callback function that will be invoked whenever there is an HTTP GET request with a path ('/') relative to the site root. The callback function takes a request and a response object as arguments, and simply calls send() on the response to return the string "Hello World!"

The final block starts up the server on port '3000' and prints a log comment to the console. With the server running, you could go to localhost:3000 in your browser to see the example response returned.

モジュールのインポートと作成

A module is a JavaScript library/file that you can import into other code using Node's require() function. Express itself is a module, as are the middleware and database libraries that we use in our Express applications.

The code below shows how we import a module by name, using the Express framework as an example. First we invoke the require() function, specifying the name of the module as a string ('express'), and calling the returned object to create an Express application. We can then access the properties and functions of the application object.

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

独自のモジュールを作成して、同じ方法でインポートすることもできます。

Tip: モノリシックな単一ファイルアプリケーションは理解して維持するのが難しいため、コードを管理可能な部分に編成することができるため、独自のモジュールを作成することをお勧めします。 モジュールを使用すると明示的にエクスポートする変数だけがインポートされるため、モジュールを使用すると名前空間を管理することもできます。

To make objects available outside of a module you just need to expose them as additional properties on the exports object. For example, the square.js module below is a file that exports area() and perimeter() methods:

exports.area = function(width) { return width * width; };
exports.perimeter = function(width) { return 4 * width; };

We can import this module using require(), and then call the exported method(s) as shown:

var square = require('./square'); // Here we require() the name of the file without the (optional) .js file extension
console.log('The area of a square with a width of 4 is ' + square.area(4));

Note: You can also specify an absolute path to the module (or a name, as we did initially).

If you want to export a complete object in one assignment instead of building it one property at a time, assign it to module.exports as shown below (you can also do this to make the root of the exports object a constructor or other function):

module.exports = {
  area: function(width) {
    return width * width;
  },
       
  perimeter: function(width) {
    return 4 * width;
  }
};

Note: You can think of exports as a shortcut to module.exports within a given module. In fact, exports is just a variable that gets initialized to the value of module.exports before the module is evaluated. That value is a reference to an object (empty object in this case). This means that exports holds a reference to the same object referenced by module.exports. It also means that by assigning another value to exports it's no longer bound to module.exports.

For a lot more information about modules see Modules (Node API docs).

非同期 API の使用

JavaScriptコードでは、操作に同期APIよりも非同期APIが頻繁に使用されるため、処理に時間がかかることがあります。 同期APIは、各操作を完了してから次の操作を開始できるAPIです。 たとえば、次のログ関数は同期的で、テキストをコンソールに順番に印刷します(First、Second)。

console.log('First');
console.log('Second');

By contrast, an asynchronous API is one in which the API will start an operation and immediately return (before the operation is complete). Once the operation finishes, the API will use some mechanism to perform additional operations. For example, the code below will print out "Second, First" because even though setTimeout() method is called first, and returns immediately, the operation doesn't complete for several seconds.

setTimeout(function() {
   console.log('First');
   }, 3000);
console.log('Second');

ノンブロッキング非同期APIを使用することは、Nodeがシングルスレッドのイベント駆動型実行環境であるため、ブラウザよりもNodeではさらに重要です。 「単一スレッド」とは、サーバーへのすべての要求が(別のプロセスに生成されるのではなく)同じスレッドで実行されることを意味します。 このモデルは、速度とサーバーリソースの点で非常に効率的ですが、いずれかの関数が完了するまでに時間がかかる同期メソッドを呼び出すと、現在の要求だけでなく、 あなたのWebアプリケーション

非同期APIが完了したことをアプリケーションに通知するには、いくつかの方法があります。 最も一般的な方法は、非同期APIを呼び出すときにコールバック関数を登録することです。これは、操作が完了したときにコールバックされます。 これが上記のアプローチです。

Tip: Using callbacks can be quite "messy" if you have a sequence of dependent asynchronous operations that must be performed in order because this results in multiple levels of nested callbacks. This problem is commonly known as "callback hell". This problem can be reduced by good coding practices (see http://callbackhell.com/), using a module like async, or even moving to ES6 features like Promises.

Note: A common convention for Node and Express is to use error-first callbacks. In this convention, the first value in your callback functions is an error value, while subsequent arguments contain success data. There is a good explanation of why this approach is useful in this blog: The Node.js Way - Understanding Error-First Callbacks (fredkschott.com).

ルートハンドラの作成

In our Hello World Express example (see above), we defined a (callback) route handler function for HTTP GET requests to the site root ('/').

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

The callback function takes a request and a response object as arguments. In this case, the method simply calls send() on the response to return the string "Hello World!" There are a number of other response methods for ending the request/response cycle, for example, you could call res.json() to send a JSON response or res.sendFile() to send a file.

JavaScript tip: コールバック関数で好きな引数名を使うことができます。 コールバックが呼び出されると、最初の引数は常に要求になり、2番目の引数は常に応答になります。 コールバックの本体で作業しているオブジェクトを識別できるようにそれらの名前を付けることは意味があります。

Expressアプリケーションオブジェクトには、他のすべてのHTTP動詞のルートハンドラを定義するメソッドも用意されています。ほとんどの場合、まったく同じ方法で使用されます。

checkout()copy()delete()get()head()lock()merge()mkactivity(), mkcol(), move(), m-search(), notify(), options(), patch(), post(), purge(), put(), report(), search(), subscribe(), trace(), unlock(), unsubscribe().

There is a special routing method, app.all(), which will be called in response to any HTTP method. This is used for loading middleware functions at a particular path for all request methods. The following example (from the Express documentation) shows a handler that will be executed for requests to /secret irrespective of the HTTP verb used (provided it is supported by the http module).

app.all('/secret', function(req, res, next) {
  console.log('Accessing the secret section ...');
  next(); // pass control to the next handler
});

ルートを使用すると、URL内の特定のパターンの文字を照合し、URLからいくつかの値を抽出し、それらをパラメータとしてルートハンドラに渡すことができます(パラメータとして渡されるリクエストオブジェクトの属性として)。

Often it is useful to group route handlers for a particular part of a site together and access them using a common route-prefix (e.g. a site with a Wiki might have all wiki-related routes in one file and have them accessed with a route prefix of /wiki/). In Express this is achieved by using the express.Router object. For example, we can create our wiki route in a module named wiki.js, and then export the Router object, as shown below:

// wiki.js - Wiki route module

var express = require('express');
var router = express.Router();

// Home page route
router.get('/', function(req, res) {
  res.send('Wiki home page');
});

// About page route
router.get('/about', function(req, res) {
  res.send('About this wiki');
});

module.exports = router;

Note: Adding routes to the Router object is just like adding routes to the app object (as shown previously).

To use the router in our main app file we would then require() the route module (wiki.js), then call use() on the Express application to add the Router to the middleware handling path. The two routes will then be accessible from /wiki/ and /wiki/about/.

var wiki = require('./wiki.js');
// ...
app.use('/wiki', wiki);

We'll show you a lot more about working with routes, and in particular about using the Router, later on in the linked section Routes and controllers .

ミドルウェアの使用

ミドルウェアは、静的ファイルの処理からエラー処理まで、HTTP応答の圧縮まで、Expressアプリケーションで幅広く使用されています。 ルート関数はHTTPクライアントに何らかの応答を返すことによってHTTP要求 - 応答サイクルを終了させるのに対して、ミドルウェア関数は通常、要求または応答に対して何らかの操作を実行し、次に「ミドルウェア」や「ルート」 ハンドラ。 ミドルウェアが呼び出される順序は、アプリケーション開発者の責任です。

Note: The middleware can perform any operation, execute any code, make changes to the request and response object, and it can also end the request-response cycle. If it does not end the cycle then it must call next() to pass control to the next middleware function (or the request will be left hanging).

Most apps will use third-party middleware in order to simplify common web development tasks like working with cookies, sessions, user authentication, accessing request POST and JSON data, logging, etc. You can find a list of middleware packages maintained by the Express team (which also includes other popular 3rd party packages). Other Express packages are available on the NPM package manager.

To use third party middleware you first need to install it into your app using NPM. For example, to install the morgan HTTP request logger middleware, you'd do this:

$ npm install morgan

You could then call use() on the Express application object to add the middleware to the stack:

var express = require('express');
var logger = require('morgan');
var app = express();
app.use(logger('dev'));
...

Note: Middleware and routing functions are called in the order that they are declared. For some middleware the order is important (for example if session middleware depends on cookie middleware, then the cookie handler must be added first). It is almost always the case that middleware is called before setting routes, or your route handlers will not have access to functionality added by your middleware.

You can write your own middleware functions, and you are likely to have to do so (if only to create error handling code). The only difference between a middleware function and a route handler callback is that middleware functions have a third argument next, which middleware functions are expected to call if they are not that which completes the request cycle (when the middleware function is called, this contains the next function that must be called).

You can add a middleware function to the processing chain with either app.use() or app.add(), depending on whether you want to apply the middleware to all responses or to responses with a particular HTTP verb (GET, POST, etc). You specify routes the same in both cases, though the route is optional when calling app.use().

The example below shows how you can add the middleware function using both methods, and with/without a route.

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

// An example middleware function
var a_middleware_function = function(req, res, next) {
  // ... perform some operations
  next(); // Call next() so Express will call the next middleware function in the chain.
}

// Function added with use() for all routes and verbs
app.use(a_middleware_function);

// Function added with use() for a specific route
app.use('/someroute', a_middleware_function);

// A middleware function added for a specific HTTP verb and route
app.get('/', a_middleware_function);

app.listen(3000);

JavaScript Tip: Above we declare the middleware function separately and then set it as the callback. In our previous route handler function we declared the callback function when it was used. In JavaScript, either approach is valid.

The Express documentation has a lot more excellent documentation about using and writing Express middleware.

静的ファイルの提供

You can use the express.static middleware to serve static files, including your images, CSS and JavaScript (static() is the only middleware function that is actually part of Express). For example, you would use the line below to serve images, CSS files, and JavaScript files from a directory named 'public' at the same level as where you call node:

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

Any files in the public directory are served by adding their filename (relative to the base "public" directory) to the base URL. So for example:

http://localhost:3000/images/dog.jpg
http://localhost:3000/css/style.css
http://localhost:3000/js/app.js
http://localhost:3000/about.html

You can call static() multiple times to serve multiple directories. If a file cannot be found by one middleware function then it will simply be passed on to the subsequent middleware (the order that middleware is called is based on your declaration order).

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

You can also create a virtual prefix for your static URLs, rather than having the files added to the base URL. For example, here we specify a mount path so that the files are loaded with the prefix "/media":

app.use('/media', express.static('public'));

Now, you can load the files that are in the public directory from the /media path prefix.

http://localhost:3000/media/images/dog.jpg
http://localhost:3000/media/video/cat.mp4
http://localhost:3000/media/cry.mp3

For more information, see Serving static files in Express.

エラーの処理

Errors are handled by one or more special middleware functions that have four arguments, instead of the usual three: (err, req, res, next). For example:

app.use(function(err, req, res, next) {
  console.error(err.stack);
  res.status(500).send('Something broke!');
});

These can return any content required, but must be called after all other app.use() and routes calls so that they are the last middleware in the request handling process!

Express comes with a built-in error handler, which takes care of any remaining errors that might be encountered in the app. This default error-handling middleware function is added at the end of the middleware function stack. If you pass an error to next() and you do not handle it in an error handler, it will be handled by the built-in error handler; the error will be written to the client with the stack trace.

Note: The stack trace is not included in the production environment. To run it in production mode you need to set the environment variable NODE_ENV to 'production'.

Note: HTTP404 and other "error" status codes are not treated as errors. If you want to handle these, you can add a middleware function to do so. For more information see the FAQ.

For more information see Error handling (Express docs).

データベースの使用

Expressアプリケーションは、Nodeがサポートする任意のデータベース・メカニズムを使用できます(Express自体は、データベース管理のための特定の追加の動作/要件を定義しません)。 PostgreSQL、MySQL、Redis、SQLite、MongoDBなど多くのオプションがあります。

これらを使用するには、まずNPMを使用してデータベース・ドライバーをインストールする必要があります。 たとえば、一般的なNoSQL MongoDB用のドライバをインストールするには、次のコマンドを使用します。

$ npm install mongodb

The database itself can be installed locally or on a cloud server. In your Express code you require the driver, connect to the database, and then perform create, read, update, and delete (CRUD) operations. The example below (from the Express documentation) shows how you can find "mammal" records using MongoDB.

//this works with older versions of  mongodb version ~ 2.2.33
var MongoClient = require('mongodb').MongoClient;

MongoClient.connect('mongodb://localhost:27017/animals', function(err, db) {
  if (err) throw err;

  db.collection('mammals').find().toArray(function (err, result) {
    if (err) throw err;

    console.log(result);
  });
});


//for mongodb version 3.0 and up
let MongoClient = require('mongodb').MongoClient;
MongoClient.connect('mongodb://localhost:27017/animals', function(err, client){
   if(err) throw err;
   
   let db = client.db('animals');
   db.collection('mammals').find().toArray(function(err, result){
     if(err) throw err;
     console.log(result);
     client.close();
   });
});

Another popular approach is to access your database indirectly, via an Object Relational Mapper ("ORM"). In this approach you define your data as "objects" or "models" and the ORM maps these through to the underlying database format. This approach has the benefit that as a developer you can continue to think in terms of JavaScript objects rather than database semantics, and that there is an obvious place to perform validation and checking of incoming data. We'll talk more about databases in a later article.

For more information see Database integration (Express docs).

データのレンダリング (ビュー)

Template engines (referred to as "view engines" by Express) allow you to specify the structure of an output document in a template, using placeholders for data that will be filled in when a page is generated. Templates are often used to create HTML, but can also create other types of documents. Express has support for a number of template engines, and there is a useful comparison of the more popular engines here: Comparing JavaScript Templating Engines: Jade, Mustache, Dust and More.

In your application settings code you set the template engine to use and the location where Express should look for templates using the 'views' and 'view engines' settings, as shown below (you will also have to install the package containing your template library too!)

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

// Set directory to contain the templates ('views')
app.set('views', path.join(__dirname, 'views'));

// Set view engine to use, in this case 'some_template_engine_name'
app.set('view engine', 'some_template_engine_name');

The appearance of the template will depend on what engine you use. Assuming that you have a template file named "index.<template_extension>" that contains placeholders for data variables named 'title' and "message", you would call Response.render() in a route handler function to create and send the HTML response:

app.get('/', function(req, res) {
  res.render('index', { title: 'About dogs', message: 'Dogs rock!' });
});

For more information see Using template engines with Express (Express docs).

ファイル構造

Express makes no assumptions in terms of structure or what components you use. Routes, views, static files, and other application-specific logic can live in any number of files with any directory structure. While it is perfectly possible to have the whole Express application in one file, typically it makes sense to split your application into files based on function (e.g. account management, blogs, discussion boards) and architectural problem domain (e.g. model, view or controller if you happen to be using an MVC architecture).

In a later topic we'll use the Express Application Generator, which creates a modular app skeleton that we can easily extend for creating web applications.

まとめ

Congratulations, you've completed the first step in your Express/Node journey! You should now understand Express and Node's main benefits, and roughly what the main parts of an Express app might look like (routes, middleware, error handling, and template code). You should also understand that with Express being an unopinionated framework, the way you pull these parts together and the libraries that you use are largely up to you!

Of course Express is deliberately a very lightweight web application framework, so much of its benefit and potential comes from third party libraries and features. We'll look at those in more detail in the following articles. In our next article we're going to look at setting up a Node development environment, so that you can start seeing some Express code in action.

関連情報

このモジュール

ドキュメントのタグと貢献者

このページの貢献者: silverskyvicto, KaoruKozuma, NULL-Coding
最終更新者: silverskyvicto,