express()

express()Express アプリケーションを作成するために使用します。express()メソッドはexpressモジュールからエクスポートされるトップレベルメソッドです。

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

Methods

express.static(root, [options])

express.staticExpress で唯一の組み込みミドルウェアです。これはserver-staticモジュールを基に開発されており、Express アプリケーション内の静的リソースをホストする役割を担います。 引数rootは静的リソースが配置されているルートディレクトリです。 引数optionsはオプションで、以下のプロパティをサポートします：

ミドルウェアの使用に関する詳細については、[関連資料] を参照してください。Serving static files in Express。

Application()

appオブジェクトは通常、Express アプリケーションを表します。Express モジュールからエクスポートされたトップレベルのexpress()メソッドを呼び出して作成します：

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

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

app.listen(3000);

app オブジェクトには以下のメソッドがあります：

• HTTP リクエストをルーティングします。詳細はapp.METHODとapp.paramこれらの2つの例を参照してください。
• ミドルウェアを構成します。詳細はapp.route。
• HTML ビューをレンダリングします。詳細はapp.render。
• テンプレートエンジンを登録します。詳細はapp.engine。

また、アプリケーションの動作を変更できるプロパティ設定もいくつかあります。詳細については、[関連資料] を参照してください。Application settings。

Properties

app.locals

app.locals オブジェクトは JavaScript オブジェクトであり、そのプロパティはアプリケーションのローカル変数です。

app.locals.title
// => 'My App'
app.locals.email
// => '[email protected]'

一度設定すると、app.localsの各プロパティ値はアプリケーションのライフサイクル全体にわたって有効です。これに対して、res.localsは、このリクエストのライフサイクル内でのみ有効です。

アプリケーション内では、テンプレートをレンダリングするときにこれらのローカル変数を使用できます。これらは非常に便利で、テンプレートに役立つメソッドや、appレベルのデータを提供できます。req.app.locals（詳細はreq.app）を参照してください。Locals はミドルウェアで使用できます。

app.locals.title = 'My App';
app.locals.strftime = require('strftime');
app.locals.email = '[email protected]';

app.mountpath

app.mountpathプロパティは、サブアプリケーションがマウントされるパスパターンです。

サブアプリケーションはexpressのインスタンスであり、リクエストを処理するためのルートハンドラとして使用できます。

var express = require('express');
var app = express(); // the main app
var admin = express(); // the sub app
admin.get('/', function(req, res) {
    console.log(admin.mountpath); // /admin
    res.send('Admin Homepage');
});
app.use('/admin', admin); // mount the sub app

これは req オブジェクトのreq.baseUrl）プロパティに似ています。ただし、req.baseUrl はマッチした URL パスであり、マッチしたパターンではない点が異なります。サブアプリケーションが複数のパスパターンにマウントされている場合、app.mountpath はマウントパスパターンのリストになります。次の例のようになります。

var admin = express();

admin.get('/', function (req, res) {
  console.log(admin.mountpath); // [ '/adm*n', '/manager' ]
  res.send('Admin Homepage');
});

var secret = express();
secret.get('/', function (req, res) {
  console.log(secret.mountpath); // /secr*t
  res.send('Admin Secret');
});

admin.use('/secr*t', secret); // load the 'secret' router on '/secr*t', on the 'admin' sub app
app.use(['/adm*n', '/manager'], admin); // load the 'admin' router on '/adm*n' and '/manager', on the parent app

Events

app.on('mount', callback(parent))

サブアプリケーションが親アプリケーションにマウントされると、mount イベントが発行されます。親アプリケーションのオブジェクトが引数としてコールバックメソッドに渡されます。

var admin = express();
admin.on('mount', function(parent) {
    console.log('Admin Mounted');
    console.log(parent); // refers to the parent app
});
admin.get('/', function(req, res) {
    res.send('Admin Homepage');
});
app.use('/admin', admin);

Methods

app.all(path, callback[, callback ...]

app.allメソッドは標準のapp.METHOD()メソッドに似ていますが、すべての HTTP 動詞にマッチする点が異なります。 特定のプレフィックスにグローバルなロジック処理をマッピングしたり、無条件にマッチさせたりするのに非常に有効です。例えば、以下の内容を他のすべてのルート定義の前に置くと、この時点以降のすべてのルートで認証が必要になり、ユーザーが自動的にロードされます。これらのコールバックは必ずしも終端ではないことに注意してください:loadUserタスクを完了した後に、next()メソッドを呼び出して、後続のルートのマッチングを続行できます。

app.all('*', requireAuthentication, loadUser);

または、これと同等の形式です:

app.all('*', requireAuthentication);
app.all('*', loadUser);

もう1つの例は、グローバルなホワイトリスト方式です。この例は前のものと非常に似ていますが、単に/apiで始まるパスのみに制限しています。

app.all('/api/*', requireAuthentication);

app.delete(path, callback[, callback ...])

ルートHTTP DELETEリクエストを特別なコールバックメソッドを持つ特定のパスにルーティングします。詳細については、routing guideを参照してください。 複数のコールバック関数を提供できます。これらはミドルウェアと同じように動作しますが、これらのコールバックはnext('router')を呼び出すことで残りのルートコールバックをバイパスできます。このメカニズムを使用して、ルートにいくつかの前提条件を設定できます。現在のルートの処理条件を満たせない場合は、後続のルートに制御を渡すことができます。

app.delete('/', function(req, res) {
    res.send('DELETE request to homepage');
});

app.disable(name)

ブール型の設定で、設定名がnameの値をfalseに設定します。ここのnameであるapp settings tableは各プロパティの1つです。app.set('foo', false)呼び出しapp.disable('foo')は同等です。 例:

app.disable('trust proxy');
app.get('trust proxy');
// => false

app.disabled(name)

返しますtrueブール型の設定値nameが false (無効) の場合false、ここのnameであるapp settings tableは各プロパティの1つです。

app.disabled('trust proxy');
// => true
app.enable('trust proxy');
app.disabled('trust proxy');
// => false

app.enable(name)

ブール型の設定値を設定します。nameためにtrue、ここのnameであるapp settings tableは各プロパティの1つです。app.set('foo', true)呼び出すこととapp.enable('foo')は同等です。

app.enable('trust proxy');
app.get('trust proxy');
// => true

app.enabled(name)

返しますtrueブール型の設定値nameが true (有効) の場合true、ここのnameであるapp settings tableは各プロパティの1つです。

app.enabled('trust proxy');
// => false
app.enable('trust proxy');
app.enabled('trust proxy');
// => true

app.engine(ext, callback)

指定されたエンジンのコールバックを登録して、ext ファイルのレンダリングを処理します。 デフォルトでは、Express はrequire()を使用して、ファイル拡張子に基づくエンジンをロードする必要があります。例えば、foo.jadeファイルをレンダリングしようとすると、Express は内部的に以下の内容を呼び出し、同時にrequire()結果をキャッシュして後続の呼び出しに備え、パフォーマンスを向上させます。

app.engine('jade', require('jade').__express);

以下の方法は、すぐに使える.__expressメソッドを提供していないテンプレートや、別のテンプレートエンジン拡張子を使用したい場合に使用します。 例えば、EJS テンプレートエンジンを使用して.htmlファイルをレンダリングします：

app.engine('html', require('ejs').renderFile);

この例では、EJS は.renderFileメソッドを提供しています。このメソッドは Express が規定するシグネチャ規則を満たしています：(path, options, callback)ただし、内部的には単にejs.__expressのエイリアスであることに注意してください。そのため、何もせずに直接.ejs拡張子を使用できます。 一部のテンプレートエンジンはこの規約に従っていません。consolidate.jsライブラリはテンプレートエンジンを以下の方法でマッピングするため、Express とシームレスに連携できます。

var engines = require('consolidate');
app.engine('haml', engines.haml);
app.engine('html', engines.hogan);

app.get(name)

設定名がnameの app 設定の値を取得します。ここのnameであるapp settings tableは各プロパティの1つです。 次のとおりです：

app.get('title');
// => undefined
app.set('title', 'My Site');
app.get('title');
// => 'My Site'

app.get(path, callback [, callback ...])

ルートHTTP GETリクエストを特別なコールバックを持つ特定のパスにルーティングします。詳細については、routing guideを参照してください。 複数のコールバック関数を提供できます。これらはミドルウェアと同じように動作しますが、これらのコールバックはnext('router')を呼び出すことで残りのルートコールバックをバイパスできます。このメカニズムを使用してルートに前提条件を設定できます。リクエストが現在のルートの処理条件を満たしていない場合は、後続のルートに制御を渡します。

app.get('/', function(req, res) {
    res.send('GET request to homepage');
});

app.listen(port, [hostname], [backlog], [callback])

アプリケーションのリスニングポートを指定したホストとポート番号にバインドします。このメソッドはNodeのhttp.Server.listen()と同じです。

var express = require('express');
var app = express();
app.listen(3000);

呼び出しによってexpress()返されるappは実際には JavaScript のFunctionであり、Node HTTP serversにコールバックとして渡すように設計されています。これにより、同じコードに基づいて HTTP と HTTPS の両方のバージョンを簡単に提供できます。そのため、app はこれらから継承していません(単なるコールバックです)。

var express = require('express');
var https = require('https');
var http = require('http');
http.createServer(app).listen(80);
https.createServer(options, app).listen(443);

app.listen() メソッドは、以下に示す便利なメソッドです(HTTP プロトコルのみ):

app.listen = function() {
    var server = http.createServer(this);
    return server.listen.apply(server, arguments);
};

app.METHOD(path, callback [, callback ...])

HTTP リクエストをルーティングします。METHODはこのリクエストの HTTP メソッドです。例えばGET，PUT，POSTなどです。小文字であることに注意してください。したがって、実際のメソッドはapp.get()，app.post()，app.put()などです。以下にメソッドの完全な表があります。

詳細については、routing guideを参照してください。 Express は、同じ名前の HTTP メソッドに対応する以下のルーティングメソッドをサポートしています：

上記のメソッドを使用すると、無効な JavaScript の変数名になる場合があります。その場合は、ブラケット記法を使用できます。例:app['m-search']('/', function ...

複数のコールバック関数を提供できます。これらはミドルウェアと同じように動作しますが、これらのコールバックはnext('router')を呼び出すことで残りのルートコールバックをバイパスできます。このメカニズムを使用してルートに前提条件を設定できます。リクエストが現在のルートの処理条件を満たしていない場合は、後続のルートに制御を渡します。

この API ドキュメントでは、よく使われる HTTP メソッドapp.get()，app.post，app.put()，app.delete()を個別の項目として説明しています。ただし、上記の他のメソッドもまったく同じように動作します。

app.all()は特別なルーティングメソッドであり、HTTP プロトコルで規定されたメソッドには属しません。これはパスにミドルウェアをロードし、すべてのリクエストメソッドに対して有効です。

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

app.param([name], callback)

ルートパラメータにコールバックトリガーを追加します。ここでのnameはパラメータ名またはパラメータの配列です。functionはコールバックメソッドです。コールバックメソッドの引数は順に、リクエストオブジェクト，レスポンスオブジェクト，次のミドルウェア，パラメータ値とパラメータ名です。nameが配列の場合、各パラメータが配列内で宣言された順序に従ってコールバックトリガーが登録されます。また、最後のパラメータ以外のパラメータについては、それらのコールバック内でnext()次の宣言されたパラメータのコールバックを呼び出します。最後のパラメータの場合、コールバック内で呼び出します。next()現在処理中のルートにある次のミドルウェアを呼び出します。もしname単なるstringそれと同じです（つまり、パラメータが1つだけの場合、それは最後のパラメータであり、配列の最後のパラメータと同じです）。:userルートパスに出現する場合、ユーザーの読み込み処理をマッピングして自動的に提供できます。req.userこのルートに提供したり、入力パラメータを検証したりします。

app.param('user', function(req, res, next, id) {
    User.find(id, function(error, user) {
        if (err) {
            next(err);
        }
        else if (user){
            req.user = user;
        } else {
            next(new Error('failed to load user'));
        }
    });
});

についてParamのコールバックで定義されたルートについては、それらはローカルです。マウントされたappやルートには継承されません。したがって、app上のParamコールバックは、app上のルートがこのルートパラメータを持っている場合にのみ機能します。

を定義したparamルート上で、paramコールバックは最初に呼び出され、それらはリクエストとレスポンスのサイクル内で一度だけ呼び出されます。複数のルートがマッチする場合でも、次の例のようになります。

app.param('id', function(req, res, next, id) {
    console.log('CALLED ONLY ONCE');
    next();
});
app.get('/user/:id', function(req, res, next) {
    console.log('although this matches');
    next();
});
app.get('/user/:id', function(req, res) {
    console.log('and this mathces too');
    res.end();
});

GET /user/42 の場合、次の結果が得られます:

CALLED ONLY ONCE
although this matches
and this matches too

app.param(['id', 'page'], function(req, res, next, value) {
    console.log('CALLED ONLY ONCE with', value);
    next();
});
app.get('/user/:id/:page', function(req. res, next) {
    console.log('although this matches');
    next();
});
app.get('/user/:id/:page', function (req, res, next) {
    console.log('and this matches too');
    res.end();
});

GET /user/42/3 を実行すると、結果は次のようになります:

CALLED ONLY ONCE with 42
CALLED ONLY ONCE with 3
although this matches
and this mathes too

以下のセクションで説明するapp.param(callback)v4.11.0以降で非推奨になりました。

コールバックパラメータを1つだけ渡すことによってapp.param(name, callback)メソッドに、app.param(naem, callback)メソッドの動作は完全に変更されます。このコールバックパラメータは、app.param(name, callback)の動作がどうあるべきかを定義するカスタムメソッドです。このメソッドは2つのパラメータを受け取り、ミドルウェアを返す必要があります。app.param(name, callback)パラメータシグネチャが次のように変更されました。app.param(name, accessId)。置換はパラメータ名とコールバックを受け取り、app.param()は現在、パラメータ名と数値を受け取ります。

var express = require('express');
var app = express();
app.param(function(param, option){
    return function(req, res, next, val) {
        if (val == option) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
app.param('id', 1337);
app.get('/user/:id', function(req, res) {
    res.send('Ok');
});
app.listen(3000, function() {
    console.log('Ready');
}); 

この例では、app.param(name, callback) のパラメータシグネチャは元のままですが、カスタムのデータ型チェックメソッドを定義するミドルウェアに置き換えられ、user idの型が正しいかどうかを検証します。

app.param(function(param, validator) {
    return function(req, res, next, val) {
        if (validator(val)) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
app.param('id', function(candidate) {
    return !isNaN(parseFloat(candidate)) && isFinite(candidate);
});

正規表現を使用する際は、使用しないでください。.。たとえば、使用することはできません。/user-.+/を使用してキャプチャするuser-gami、代わりに使用して[\\s\\S]または[\\w\\>W]で置き換えます（ちょうど/user-[\\s\\S]+/)。

//captures '1-a_6' but not '543-azser-sder'
router.get('/[0-9]+-[[\\w]]*', function); 
//captures '1-a_6' and '543-az(ser"-sder' but not '5-a s'
router.get('/[0-9]+-[[\\S]]*', function); 
//captures all (equivalent to '.*')
router.get('[[\\s\\S]]*', function); 

app.path()

このメソッドによって取得できますapp典型的なパス、それはstring。

 var app = express()
      , blog = express()
      , blogAdmin = express();
    app.use('/blog', blog);
    app.use('/admin', blogAdmin);
    console.log(app.path()); // ''
    console.log(blog.path()); // '/blog'
    console.log(blogAdmin.path()); // '/blog/admin'

appのマウントが複雑な場合、このメソッドの動作も複雑になります。より使いやすい方法は、req.baseUrlを使用してこのappの典型的なパスを取得することです。

app.post(path, callback, [callback ...])

HTTP POSTリクエストを、特別なコールバックを持つ特別なパスにルーティングします。詳細については、[ルーティングガイド](http://expressjs.com/guide/routing.html)を参照してください。

複数のコールバック関数を提供できます。これらはミドルウェアと同様に動作しますが、next('router')を呼び出すことで残りのルートコールバックをバイパスできます。このメカニズムを使用して、ルートに前提条件を設定できます。リクエストが現在のルートの処理条件を満たさない場合は、後続のルートに制御を渡します。

app.post('/', function(req, res) {
    res.send('POST request to homepage')
});

app.put(path, callback, [callback ...])

ルーティングHTTP PUTリクエストを特別なコールバックを持つ特別なパスにルーティングします。詳細については、を参照してください。routing guide。

複数のコールバック関数を提供できます。これらはミドルウェアと同様に動作しますが、これらのコールバックは、next('router')を呼び出して残りのルートコールバックをバイパスできます。このメカニズムを使用して、ルートに前提条件を設定できます。リクエストが現在のルートの処理条件を満たさない場合、後続のルートに制御を渡します。

app.put('/', function(req, res) {
    res.send('PUT request to homepage');
});

app.render(view, [locals], callback)

によってcallbackコールバックは、viewレンダリング後に得られるHTMLテキスト。オプションのパラメータを受け取ることができ、そのオプションパラメータにはこのviewで必要とされるローカルデータが含まれます。このメソッドは、～に似ています。res.render()，レンダリングされたHTMLテキストをクライアントに送信できないことを除いて。

将app.render()レンダリングされたビュー文字列を生成できるユーティリティメソッドと見なせます。res.render()内部では、まさにapp.render()を使用してビューをレンダリングします。

ビューキャッシュが有効になっている場合、ローカル変数キャッシュは保持されます。開発中にビューをキャッシュしたい場合は、それをtrue。本番環境では、ビューキャッシュはデフォルトで有効です。

app.render('email', function(err, html) {
// ...
});
app.render('email', {name:'Tobi'}, function(err, html) {
// ...
});

app.route(path)

シングルトンパターンのルートインスタンスを返します。その後、その上にさまざまなHTTPアクションのミドルウェアを適用できます。使用してapp.route()ルート名の重複（例：タイプミス）を避けます。つまり、使用するapp.router()このシングルトンメソッドを使用して、同じパスに対する複数のルートインスタンスを避けます。

var app = express();
app.route('/events')
.all(function(req, res, next) {
  // runs for all HTTP verbs first
  // think of it as route specific middleware!
})
.get(function(req, res, next) {
  res.json(...);
})
.post(function(req, res, next) {
  // maybe add a new event...
})

app.set(name, value)

name設定項目にvalue値を割り当てます。nameはApplication settingsの属性の1つです。ブール型のプロパティに対してapp.set('foo', ture)を呼び出すことは、app.enable('foo')を呼び出すことと同等です。同様に、app.set('foo', false)を呼び出すことは、app.disable('foo')を呼び出すことと同等です。

app.get() を使用して設定値を取得できます：

app.set('title', 'My Site');
    app.get('title'); // 'My Site'

Application Settings

もしnameがアプリ設定の1つである場合、アプリの動作に影響します。以下にアプリの設定を示します。

trust proxyオプション設定参照してExpress behind proxies詳細情報を取得します。

app.set('trust proxy', 'loopback') // specify a single subnet
app.set('trust proxy', 'loopback, 123.123.123.123') // specify a subnet and an address
app.set('trust proxy', 'loopback, linklocal, uniquelocal') // specify multiple subnets as CSV
app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal']) // specify multiple subnets as an array

app.set('trust proxy', function (ip) {
    if (ip === '127.0.0.1' || ip === '123.123.123.123') return true; // trusted IPs
    else return false;
  })

etag設定オプション ETag機能の実装はetagパッケージを使用しています。詳細については、そのドキュメントを参照してください。

app.set('etag', function (body, encoding) {
  return generateHash(body, encoding); // consider the function is defined
  })

app.use([path,], function [, function...])

マウントミドルウェアメソッドをパスにマウントします。パスが指定されていない場合、デフォルトは "/" です。

ルートは、パスがルートの設定パスの直後に "/" が続く場合、任意のパスにマッチします。例えば：app.use('/appale', ...)"/apple"、"/apple/images"、"/apple/images/news" などにマッチします。

ミドルウェア内のreq.originalUrlであるreq.baseUrlとreq.pathの組み合わせは、以下の例のとおりです。

app.use('/admin', function(req, res, next) {
// GET 'http://www.example.com/admin/new'
console.log(req.originalUrl); // '/admin/new'
console.log(req.baseUrl); // '/admin'
console.log(req.path);// '/new'
});

あるパスにミドルウェアをマウントした後、リクエストのパスのプレフィックス部分がそのルートパスに一致するたびに、そのミドルウェアが実行されます。デフォルトのパスは/であるため、ミドルウェアのマウントにパスが指定されていない場合、すべてのリクエストに対してこのミドルウェアが実行されます。

 // this middleware will be executed for every request to the app.
app.use(function(req, res, next) {
    console.log('Time: %d', Date.now());
    next();
});

ミドルウェアメソッドは順番に処理されるため、ミドルウェアが含まれる順序は非常に重要です。

// this middleware will not allow the request to  go beyond it
app.use(function(req, res, next) {
    res.send('Hello World');
});
// this middleware will never reach this route
app.use('/', function(req, res) {
    res.send('Welcome');
});

パスは、パスを表す文字列、パスパターン、パスに一致する正規表現、またはそれらの組み合わせのセットです。

以下にパスの簡単な例を示します。

// will match paths starting with /abcd
app.use('/abcd', function (req, res, next) {
  next();
})

// will match paths starting with /abcd and /abd
app.use('/abc?d', function (req, res, next) {
  next();
})

// will match paths starting with /abcd, /abbcd, /abbbbbcd and so on
app.use('/ab+cd', function (req, res, next) {
  next();
})

// will match paths starting with /abcd, /abxcd, /abFOOcd, /abbArcd and so on
app.use('/ab\*cd', function (req, res, next) {
  next();
})

// will match paths starting with /ad and /abcd
app.use('/a(bc)?d', function (req, res, next) {
  next();
})

// will match paths starting with /abc and /xyz
app.use(/\/abc|\/xyz/, function (req, res, next) {
  next();
})

// will match paths starting with /abcd, /xyza, /lmn, and /pqr
app.use(['/abcd', '/xyza', /\/lmn|\/pqr/], function (req, res, next) {
  next();
})

メソッドは、ミドルウェアメソッド、一連のミドルウェアメソッド、ミドルウェアメソッドの配列、またはそれらの組み合わせです。routerとappはミドルウェアインターフェースを実装しているため、他のミドルウェアメソッドと同様に使用できます。

app.use(function (req, res, next) {
  next();
})

var router = express.Router();
router.get('/', function (req, res, next) {
  next();
})
app.use(router);

var subApp = express();
subApp.get('/', function (req, res, next) {
  next();
})
app.use(subApp);

var r1 = express.Router();
r1.get('/', function (req, res, next) {
  next();
})

var r2 = express.Router();
r2.get('/', function (req, res, next) {
  next();
})

app.use(r1, r2);

var r1 = express.Router();
r1.get('/', function (req, res, next) {
  next();
})

var r2 = express.Router();
r2.get('/', function (req, res, next) {
  next();
})

app.use('/', [r1, r2]);

function mw1(req, res, next) { next(); }
function mw2(req, res, next) { next(); }

var r1 = express.Router();
r1.get('/', function (req, res, next) { next(); });

var r2 = express.Router();
r2.get('/', function (req, res, next) { next(); });

var subApp = express();
subApp.get('/', function (req, res, next) { next(); });

app.use(mw1, [mw2, r1, r2], subApp);

以下は、Expressアプリでexpress.staticミドルウェアを使用する例です。

アプリのディレクトリにあるpublicディレクトリの静的ファイルをアプリでホストします:

// GET /style.css etc
app.use(express.static(__dirname + '/public'));

に/static静的ファイルのホスティングを提供するためにパスにミドルウェアをマウントし、リクエストが/staticをプレフィックスとする場合のみです。

// GET /static/style.css etc.
app.use('/static', express.static(express.__dirname + '/public'));

静的ファイルミドルウェアを設定した後にログミドルウェアをロードすることで、静的ファイルリクエストのログ記録を無効にします。

app.use(express.static(__dirname + '/public'));
app.use(logger());

異なるパスから静的ファイルをホストしますが、./publicパスは他よりもマッチしやすくなっています:

app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/files'));
app.use(express.static(__dirname + '/uploads'));

Request

reqオブジェクトはHTTPリクエストを表し、リクエスト内のデータを保持するいくつかのプロパティを持っています。たとえば、query string，parameters，body，HTTP headersなどです。このドキュメントでは、慣例により、このオブジェクトは常にreq（HTTPレスポンスは略してres）と呼ばれますが、実際の名前は、そのコールバックメソッドが使用される場所のパラメータによって決まります。 次の例のとおりです。

app.get('/user/:id', function(req, res) {
    res.send('user' + req.params.id);
});

実際には、次のように書くこともできます：

app.get('/user/:id', function(request, response) {
    response.send('user' + request.params.id);
});

Properties

にExpress 4では、req.filesデフォルトではreqオブジェクト内では利用できません。を介してreq.filesオブジェクトを使用してアップロードされたファイルを取得するには、次を使用できます。multipart-handling（多様な処理のツールセット）ミドルウェア、たとえばbusboy，multer，formidable，multipraty，connect-multipartyまたはpez。

req.app

このプロパティはexpressアプリインスタンスへの参照を保持し、ミドルウェアとして使用できます。

このパターンに従うと、ミドルウェアをエクスポートするモジュールを作成し、そのミドルウェアをメインファイルでのみrequire()使用する場合、そのミドルウェアはreq.appを使用してexpressインスタンスを取得できます。例:

// index.js
app.get("/viewdirectory", require('./mymiddleware.js'));

// mymiddleware.js
module.exports = function(req, res) {
    res.send('The views directory is ' + req.app.get('views'));
};

req.baseUrl

ルートインスタンスがマウントされているURLパス。

var greet = express.Router();
greet.get('/jp', function(req, res) {
    console.log(req.baseUrl); // greet
    res.send('Konichiwa!');
});
app.use('/greet', greet);

パスパターンまたは一連のパスパターンを使用してルートをロードした場合でも、baseUrlプロパティは、ルートパターンではなく一致した文字列を返します。次の例では、greetルートは2つのパスパターンでロードされます。

app.use(['/gre+t', 'hel{2}o'], greet); // load the on router on '/gre+t' and '/hel{2}o'

リクエストパスが/greet/jp，baseUrlである/greetの場合、リクエストパスが/hello/jp，req.baseUrlである/hello。 req.baseUrlとappオブジェクトのmountpathプロパティに似ています。ただし、app.mountpath返されるのはパスマッチングパターンです。

req.body

リクエストのbodyには、送信されたキーと値のペアのデータが保存されます。デフォルトでは、undefinedです。たとえば、次を使用する場合body-parserとmulterこの種の解析を行うbodyデータのミドルウェアを使用すると、そのbodyは設定されます。次の例は、使用方法を示しています。body-parserミドルウェアを使用してreq.body。

var app = require('express');
var bodyParser = require('body-parser');
var multer = require('multer')；// v1.0.5
var upload = multer(); // for parsing multipart/form-data
app.use(bodyParser.json()); // for parsing application/json
app.use(bodyParser.urlencoded({extended:true})); // for parsing application/x-www-form-urlencoded
app.post('/profile', upload.array(), function(req, res, next) {
    console.log(req.body);
    res.json(req.body);
});

req.cookies

cookie-parserミドルウェアを使用すると、このプロパティはリクエストによって送信されたcookieを含むオブジェクトになります。リクエストにcookieがない場合、その値は{}です。

// Cookie: name=tj
req.cookies.name
// => "tj"

詳細、問題、または懸念事項については、次を参照してください。cookie-parser。

req.fresh

このリクエストがフレッシュかどうかを示します。これはreq.staleとは逆です。 次の場合cache-controlリクエストヘッダーにno-cacheの指示がなく、かつ以下のいずれかの条件がtrueである場合、それはtrue：

• if-modified-sinceリクエストヘッダーが指定され、かつlast-modifiedリクエストヘッダーがmodifiedレスポンスヘッダーと等しいか、またはそれ以前である。
• if-none-matchリクエストヘッダーが*。
• if-none-matchリクエストヘッダーがそのディレクティブに解析された後、およびetagレスポンスヘッダーの値と等しくない

注：If-None-Matchの作用: If-None-MatchはETagと連動して動作します。仕組みは、HTTPレスポンスにETag情報を追加することです。ユーザーが再度そのリソースをリクエストすると、HTTPリクエストにIf-None-Match情報（ETagの値）が追加されます。サーバーがリソースのETagに変更がない（そのリソースが更新されていない）ことを検証すると、304ステータスを返してクライアントにローカルキャッシュファイルを使用するように指示します。それ以外の場合は、200ステータスと新しいリソースおよびEtagを返します。このようなメカニズムを使用すると、ウェブサイトのパフォーマンスが向上します。

req.fresh
// => true

req.hostname

由来するものを含みますHostHTTPヘッダーのhostname。

当trust proxy設定が有効な値に設定されている場合、X-Forwarded-HostヘッダーはHostの代わりに使用されます。このヘッダーはクライアントまたはプロキシによって設定できます。

// Host: "example.com"
req.hostname
// => "example.com"

req.ips

当trust proxy設定が有効な値に設定されている場合、このプロパティにはX-Forwarded-Forリクエストヘッダーで指定されたIPアドレスが含まれます。そうでない場合は、空の配列が含まれます。このヘッダーはクライアントまたはプロキシによって設定できます。

たとえば、X-Forwarded-Forであるclient，proxy1，proxy2，req.ipsの場合、["clinet", "proxy1", "proxy2"]ここでproxy2が最も遠い下流です。

req.originalUrl

req.urlはネイティブのExpressプロパティではなく、Node's http module。

このプロパティはreq.urlに非常に似ています。ただし、元のリクエストURLを保持しているため、自由にリダイレクトできます。req.url内部ルートへ。たとえば、app.use()のmountingの機能により、リダイレクトできますreq.urlマウントポイントにジャンプします。

// GET /search?q=something
req.originalUrl
// => "/search?q=something"

req.params

ルート内の名前付きパラメータ名に対応する一連のプロパティを含むオブジェクトです。たとえば、/user/:nameルートがある場合、nameプロパティはreq.params.nameとして利用できます。このオブジェクトのデフォルト値は{}。

// GET /user/tj
req.params.name
// => "tj"

正規表現を使用してルートルールを定義する場合、キャプチャグループの組み合わせは通常req.params[n]を使用します。ここでのnは何番目のキャプチャグループかを示します。この規則は、名前のないワイルドカードマッチにも適用されます。たとえば/file/*のルート:

// GET /file/javascripts/jquery.js
req.params[0]
// => "javascripts/jquery.js"

req.path

リクエストURLの一部のパスが含まれます。

// example.com/users?sort=desc
req.path
// => "/users"

ミドルウェア内で呼び出されると、マウントポイントはreq.pathには含まれません。次を参照してください。app.use()詳細情報を取得できます。

req.protocol

リクエストのプロトコル。通常はhttpですが、TLS暗号化が有効な場合はhttps。

当trust proxy有効な設定がある場合、X-Forwarded-Protoヘッダーが存在すると、それが信頼されて使用されます。このヘッダーはクライアントまたはプロキシによって設定できます。

req.ptotocol
// => "http"

req.query

ルート内の各query stringパラメータにプロパティを割り当てるオブジェクト。もしquery stringがない場合、それは空のオブジェクトです。{}。

// GET /search?q=tobi+ferret
req.query.q
// => "tobi ferret"
// GET /shoes?order=desc&shoe[color]=blue&shoe[type]=converse
req.query.order
// => "desc"
req.query.shoe.color
// => "blue"
req.query.shoe.type
// => "converse"

req.route

現在一致しているルートで、文字列です。例：

app.get('/user/:id?', function userIdHandler(req, res) {
    console.log(req.route);
    res.send('GET')
})

前述のスニペットの出力は次のとおりです:

{ path:"/user/:id?"
    stack:
    [
        { handle:[Function:userIdHandler],
          name:"userIdHandler",
          params:undefined,
          path:undefined,
          keys:[],
          regexp:/^\/?$/i,
          method:'get'
        }
    ]
    methods:{get:true}
}

req.secure

ブール値で、TLS接続が確立されている場合はtrueです。次と同等です：

'https' == req.protocol;

req.signedCookies

を使用する場合、cookie-parserミドルウェアを使うと、このプロパティにはリクエストから送信された署名cookiesが含まれます。このプロパティは、署名を含まない直接使用できる値を取得します。署名されたcookiesは、開発者の意図を反映するために別のオブジェクトに保存されます。そうしないと、悪意のある攻撃がreq.cookie値に対して行われる可能性があります（これは簡単に偽造できます）。覚えておいてください、署名することはcookieそれを隠したり暗号化したりするのではなく、単に改ざんを防ぐだけです（署名に使用される暗号化はプライベートであるため）。署名されたcookieが送信されない場合、このプロパティのデフォルトは{}。

// Cookie： user=tobi.CP7AWaXDfAKIRfH49dQzKJx7sKzzSoPq7/AcBBRVwlI3
req.signedCookies.user
// => "tobi"

詳細、問題、または懸念事項については、次を参照してください。cookie-parser。

req.stale

このリクエストがstale（古い）かどうかを示します。これはreq.freshとは逆です。詳細については、次を参照してください。req.fresh。

req.stale
// => true

req.subdomains

リクエスト内のドメインのサブドメイン配列。

// Host: "tobi.ferrets.example.com"
req.subdomains
// => ["ferrets", "tobi"]

req.xhr

ブール値で、X-Requested-Withの値がXMLHttpRequestの場合、その値はtrueであり、このリクエストがクライアントライブラリによって送信されたことを示します。たとえばjQuery。

req.xhr
// => true

Methods

req.accepts(types)

リクエストのAccept HTTPヘッダーに基づいて、指定されたコンテンツタイプが受け入れられるかどうかを確認します。このメソッドは最適なマッチを返します。一致するものがない場合はundefinedを返します（この場合、サーバーは406と「Not Acceptable」を返す必要があります）。

type値は、単一のMIMEタイプ文字列（例: application/json）、jsonのような拡張子、カンマ区切りのリスト、または配列です。リストまたは配列の場合、このメソッドは最適な項目を返します（存在する場合）。

// Accept: text/html
req.accepts('html');
// => "html"
// Accept: text/*, application/json
req.accepts('html');
// => "html"
req.accepts('text/html');
// => "text/html"
req.accepts(['json', 'text']);
// => "json"
req.accepts('application/json');
// => "application/json"
// Accept: text/*, application/json
req.accepts('image/png');
req.accepts('png');
// => undefined
// Accept: text/*;q=.5, application/json
req.accepts(['html', 'json']);
// => "json"

詳細は、または問題や懸念がある場合は、次を参照してください。accepts。

req.acceptsCharsets(charset[, ...])

リクエストに基づいて、指定された文字セットの集合の中で最初に設定された文字セットを返します。Accept-CharsetHTTPヘッダー。指定された文字セットに一致するものがない場合は、falseを返します。 詳細については、または質問や懸念がある場合は、参照してください。accepts。

req.acceptsEncodings(encoding[, ...])

指定されたエンコーディングセットの中で最初に設定されたエンコーディングを返します。リクエストのAccept-EncodingHTTPヘッダー。指定されたエンコーディングセットに一致するものがない場合は、falseを返します。 詳細については、または質問や懸念がある場合は、参照してください。accepts。

req.acceptsLanguages(lang [, ...])

指定された言語セットの中で最初に設定された言語を返します。リクエストのAccept-LanguageHTTPヘッダー。指定された言語セットに一致するものがない場合は、falseを返します。 詳細については、または質問や懸念がある場合は、参照してください。accepts。

req.get(field)

指定されたリクエストHTTPヘッダーのフィールド内容を返します（大文字と小文字を区別しません）。ReferrerとRefererのフィールド内容は互換性があります。

req.get('Content-type');
// => "text/plain"
req.get('content-type');
// => "text/plain"
req.get('Something')
// => undefined

これはreq.header(field) のエイリアスです。

req.is(type)

入ってくるリクエストのContent-typeヘッダーフィールドが一致するパラメータtype指定されたMIME typeに一致する場合、これはtrueを返します。それ以外の場合はfalse。

// With Content-Type: text/html; charset=utf-8
req.is('html');
req.is('text/html');
req.is('text/*');
// => true
// When Content-Type is application/json
req.is('json');
req.is('application/json');
req.is('application/*');
// => true
req.is('html');
// => false

詳細については、または質問や懸念がある場合は、参照してください。type-is。

req.param(naem, [, defaultValue])

非推奨です。適切な場合は、次を使用してください。req.params，req.bodyまたはreq.query。

現在のパラメータnameの値を返します。

// ?name=tobi
req.param('name')
// => "tobi"
// POST name=tobi
req.param('name')
// => "tobi"
// /user/tobi for /user/:name
req.param('name')
// => "tobi"

以下に示す順序で検索します：

• req.params
• req.body
• req.query

オプションで、次を指定できます。defaultValueこのパラメータがリクエストオブジェクトのいずれにも見つからない場合に、デフォルト値を設定します。

直接req.params，req.body，req.queryを取得する方が明確です。各オブジェクトの入力を確信している場合を除きます。Body-parserミドルウェアをロードする必要があります。次を使用する場合req.param()。詳細は次を参照してください。req.body。

Response

resオブジェクトは、HTTPリクエストが到着したときにExpressプログラムが返すHTTPレスポンスを表します。このドキュメントでは、慣例により、このオブジェクトは常にres（HTTPリクエストはreqと略されます）。ただし、実際の名前は、そのコールバックメソッドが使用される場所のパラメータによって決まります。

app.get('/user/:id', function(req, res) {
    res.send('user' + req.params.id);
});

次のように書いても同じです：

app.get('/user/:id', function(request, response) {
    response.send('user' + request.params.id);
});

Properties

res.app

このプロパティはexpressアプリケーションインスタンスへの参照を保持し、ミドルウェア内で使用できます。

res.app とリクエストオブジェクトの req.app プロパティは同じです。/p>

res.headersSent

このレスポンスがHTTPヘッダーを送信済みかどうかを示すブール型のプロパティです。

app.get('/', function(req, res) {
    console.log(res.headersSent); // false
    res.send('OK'); // send之后就发送了头部
    console.log(res.headersSent); // true
});

res.locals

このリクエストのレスポンス内の変数を含むオブジェクトです。したがって、その変数は、このリクエストレスポンスの期間中のビューレンダリングでのみ使用できます（ビューがある場合）。 他の点では、これはapp.localsと同じです。

このパラメータは、リクエストパス、認証済みユーザー、ユーザー設定など、リクエストレベルの情報をエクスポートするのに非常に役立ちます。

app.use(function(req, res, next) {
    res.locals.user = req.user;
    res.locals.authenticated = !req.user.anonymous;
    next();
});

Methods

res.append(field [, value])

res.append() メソッドはExpresxsバージョン4.11.0以上でのみサポートされます。

指定されたfieldのHTTPヘッダーに指定の値を追加します。value。このヘッダーが設定されていない場合は、valueを使用してこのヘッダーを新規作成します。valueは文字列または配列にすることができます。

注意：res.append()の後にapp.set()関数を呼び出すと、以前に設定された値がリセットされます。

res.append('Lind', ['<http://localhost>', '<http://localhost:3000>']);
res.append('Set-Cookie', 'foo=bar;Path=/;HttpOnly');
res.append('Warning', '199 Miscellaneous warning');

res.attachment([filename])

HTTPレスポンスのContent-Dispositionヘッダー内容を"attachment"に設定します。filenameの場合、次を使用しますres.type()拡張子を取得して設定しますContent-Type、そして設定しますContent-Disposition内容を"filename="parameter とします。

res.attachment();
// Content-Disposition: attachment
res.attachment('path/to/logo.png');
// Content-Disposition: attachment; filename="logo.png"
// Content-Type: image/png

res.cookie(name, value [,options])

設定nameとvalueのcookie，valueパラメータは文字列、またはJSON文字列に変換されたオブジェクトにすることができます。

options はオブジェクトであり、次のプロパティを持つことができます。

res.cookie() は、提供されたoptionsパラメータに基づいてSet-Cookieヘッダーを設定します。何も指定されていない場合options、デフォルト値はRFC6265で指定されます。

使用例：

res.cookie('name', 'tobi', {'domain':'.example.com', 'path':'/admin', 'secure':true});
res.cookie('remenberme', '1', {'expires':new Date(Date.now() + 90000), 'httpOnly':true});

maxAge は有効期限を設定するための便利なオプションで、現在時刻からの経過ミリ秒数で計算されます。次の例は、上記の2番目の例と同じ効果があります。

res.cookie('rememberme', '1', {'maxAge':90000}, "httpOnly":true);

value パラメータとしてオブジェクトを渡すことができます。その後、JSON文字列にシリアライズされ、bodyParser() ミドルウェアによって解析されます。

res.cookie('cart', {'items':[1, 2, 3]});
res.cookie('cart', {'items':[1, 2, 3]}, {'maxAge':90000});

cookie-parser ミドルウェアを使用する場合、このメソッドは署名付きcookieもサポートします。簡単に言うと、options を設定するときに signed オプションを true に含めます。すると res.cookie() は cookieParser(secret) に渡された秘密鍵を使用してその値を署名します。

res.cookie('name', 'tobi', {'signed':true});

res.clearCookie(name [,options])

指定されたnameに基づいて対応するcookieをクリアします。詳細についてはoptionsオブジェクトを参照してください。res.cookie()。

res.cookie('name', 'tobi', {'path':'/admin'});
res.clearCookie('name', {'path':'admin'});

res.download(path, [,filename], [,fn])

転送pathファイルを添付ファイルとして指定します。通常、ブラウザはユーザーにダウンロードを促します。デフォルトでは、Content-Dispositionヘッダーの"filename="パラメータはpath（通常はブラウザのダイアログに表示されます）。次を指定することでfilenameパラメータでデフォルト値を上書きします。

エラーが発生したとき、または転送が完了したとき、このメソッドはfn指定されたコールバックメソッドを呼び出します。このメソッドはres.sendFile()を使用してファイルを転送します。

res.download('/report-12345.pdf');
res.download('/report-12345.pdf', 'report.pdf');
res.download('report-12345.pdf', 'report.pdf', function(err) {
// Handle error, but keep in mind the response may be partially-sent
// so check res.headersSent
if (err) {
} else {
// decrement a download credit, etc.
}
});

res.end([data] [, encoding])

このレスポンスのプロセスを終了します。このメソッドは実際にはNodeコアモジュール、具体的にはresponse.end() method of http.ServerResponse。

を使用して、データなしでリクエストをすばやく終了します。データを送信する必要がある場合は、次を使用できます。res.send()とres.json()などのメソッドです。

res.end();
res.status(404).end();

res.format(object)

コンテンツネゴシエーションを実行します。リクエストオブジェクト内のAcceptHTTPヘッダーで指定された受け入れ内容に基づきます。 req.accepts() を使用して、リクエストを処理するハンドラを選択します。これらのハンドラは品質値でソートされます。このヘッダーが指定されていない場合、最初のメソッドがデフォルトで呼び出されます。一致しない場合、サーバーは406"Not Acceptable" を返すか、defaultコールバックを呼び出します。

Content-Typeコールバックメソッドが選択されると、リクエストヘッダーが設定されます。ただし、このメソッド内で次のようなメソッドを使用して変更できます。res.set()またはres.type()。

次の例では、応答します{"message":"hey"}、リクエストオブジェクトのAcceptヘッダーが"application/json"または"*/json"に設定されている場合（ただし、*/*の場合は、応答は"hey"になります）。

res.format({
    'text/plain':function() {
        res.send('hey');
    },
    'text/html':function() {
        res.send('<p>hey</p>');
    },
    'application/json':function() {
        res.send({message:'hey'});
    },
    'default':function() {
        res.status(406).send('Not Acceptable');
    }
})

正規化されたMIMEタイプに加えて、拡張子を使用してこれらのタイプをマッピングし、冗長な実装を避けることもできます：

res.format({
    text:function() {
        res.send('hey');
    },
    html:function() {
        res.send('<p>hey</p>');
    },
    json:function() {
        res.send({message:'hey'});
    }
})

res.get(field)

返すのは、field指定されたHTTPレスポンスのヘッダーです。一致は大文字と小文字を区別します。

res.get('Content-Type');
// => "text/plain"

res.json([body])

JSONレスポンスを送信します。このメソッドは、オブジェクトまたは配列をパラメータとしてres.send()メソッドに渡すのと同じ効果があります。ただし、このメソッドを使用して他の値をJSONに変換できます。例えばnull，undefined（これらは技術的には無効なJSONですが）。

res.json(null);
res.json({user:'tobi'});
res.status(500).json({error:'message'});

res.jsonp([body])

JSONレスポンスを送信し、JSONPをサポートします。このメソッドは res.json() と同じ効果ですが、オプションでJSONPコールバックをサポートする点が異なります。

res.jsonp(null)
// => null
res.jsonp({user:'tobi'})
// => {"user" : "tobi"}
res.status(500).jsonp({error:'message'})
// => {"error" : "message"}

デフォルトでは、JSONPコールバックメソッドは単に callback と記述されます。次を使用してjsonp callback name設定を上書きできます。

以下は同じコードを使用したJSONPレスポンスの例です：

// ?callback=foo
res.jsonp({user:'tobo'})
// => foo({"user":"tobi"})
app.set('jsonp callback name', 'cb')
// ?cb=foo
res.status(500).jsonp({error:'message'})
// => foo({"error":"message"})

res.links(links)

これらのlinks，linksは渡されたパラメータのプロパティとして提供され、連結された内容はレスポンスのLink HTTPヘッダーを埋めるために使用されます。

res.links({
    next:'http://api.example.com/users?page=2',
    last:'http://api.example.com/user?page=5'
});

結果：

Link:<http://api.example.com/users?page=2>;rel="next",
<http://api.example.com/users?page=5>;rel="last"

res.location(path)

レスポンスのLocationHTTPヘッダーを指定されたpathパラメータに設定します。

res.location('/foo/bar');
res.location('http://example.com');
res.location('back');

当pathパラメータがbackの場合、特別な意味を持ちます。URLをリクエストオブジェクトのRefererヘッダーで指定されたURLに設定します。リクエストで指定されていない場合は、"/"になります。

Expressは指定されたURL文字列をブラウザへのレスポンス内のLocationヘッダーの値として渡します。検出や操作は行いません。ただし、backこのパラメータは除きます。ブラウザはユーザーをlocationで設定されたURL、またはRefererのURL（backパラメータの場合）

res.redirect([status,] path)

リダイレクトは、指定されたpathのURLと、指定されたHTTP status codestatusに基づきます。指定しない場合status、ステータスコードはデフォルトで"302 Found"になります。

res.redirect('/foo/bar');
res.redirect('http://example.com');
res.redirect(301, 'http://example.com');
res.redirect('../login');

リダイレクトは完全なURLにすることもでき、異なるサイトにリダイレクトできます。

res.redirect('http://google.com');</p><p>
重定向也可以相对于主机的根路径。比如，如果程序的路径为<strong>http://example.com/admin/post/new</strong>，那么下面将重定向到<strong>http://example.com/admim</strong>:</p>
<pre>res.redirect('/admin');

リダイレクトは現在のURLに対する相対パスにすることもできます。例えば、http://example.com/blog/admin/（末尾の/に注意してください）。以下はhttp://example.com/blog/admin/post/new。

res.redirect('post/new');

にリダイレクトされます。もし元がhttp://example.com/blog/admin（末尾なし/）、リダイレクトpost/new、リダイレクト先はhttp://example.com/blog/post/new。もし上記が混乱していると感じたら、パスセグメントをディレクトリ（'/'付き）またはファイルと見なすこともできます。相対パスへのリダイレクトも可能です。現在のパスがhttp://example.com/admin/post/newの場合、以下の操作はリダイレクト先をhttp://example.com/admin/post：

res.redirect('..');

backリダイレクトリクエストをreferer、もしrefererがない場合、デフォルトは/。

res.redirect('back');

res.render(view [, locals] [, callback])

ビューをレンダリングし、レンダリングされたHTMLドキュメントをクライアントに送信します。オプションのパラメータは次のとおりです:

• locals、ビューのローカルパラメータのプロパティを定義するオブジェクト。
• callback、コールバックメソッド。このパラメータが指定された場合、renderメソッドはエラーとレンダリング後のテンプレートを返し、自動的にはレスポンスを送信しません。エラーが発生した場合は、このコールバック内でnext(err)メソッドを呼び出すことができます。

ローカル変数キャッシュはビューキャッシュを有効にします。開発環境でビューをキャッシュするには、手動でtrueに設定する必要があります。ビューキャッシュは本番環境ではデフォルトで有効です。

// send the rendered view to the client
res.render('index');
// if a callback is specified, the render HTML string has to be sent explicitly
res.render('index', function(err, html) {
    res.send(html);
});
// pass a local variable to  the view
res.render('user', {name:'Tobi'}, function(err, html) {
    // ...
});

res.send([body])

HTTPレスポンスを送信します。

bodyパラメータには、Bufferオブジェクト、文字列、オブジェクト、または配列を指定できます。例：

res.send(new Buffer('whoop'));
res.send({some:'json'});
res.send('<p>some html</p>');
res.status(404).send('Sorry, we cannot find that!');
res.status(500).send({ error: 'something blew up' });

一般的な非ストリームリクエストの場合、このメソッドは多くの有用なタスクを実行できます。たとえば、Content-LengthHTTPレスポンスヘッダーに自動的に値を設定し（事前に定義されていない場合）、自動的なHEADおよびHTTPキャッシュ更新もサポートします。

パラメータがBufferオブジェクトの場合、このメソッドはContent-Typeレスポンスヘッダーをapplication/octet-streamに設定します（事前に指定されていない限り）。次のようになります:

res.set('Content-Type', 'text/html');
res.send(new Buffer('<p>some html</p>'));

パラメータが文字列の場合、このメソッドはContent-Typeレスポンスヘッダーをtext/htmlに設定します:

res.send('<p>some html</p>');

パラメータがオブジェクトまたは配列の場合、ExpressはJSON形式で表現します:

res.send({user:'tobi'});
res.send([1, 2, 3]);

res.sendFile(path [, options] [, fn])

res.sendFile()からExpress v4.8.0サポートを開始しました。

転送path指定されたファイル。ファイルの拡張子に応じてContent-TypeHTTPヘッダーを設定します。ただし、options内にrootに関する設定がない限り、pathは必ずファイルの絶対パスに関するものです。optionsパラメータの詳細:

転送が完了したか、何らかのエラーが発生した場合、このメソッドはfnコールバックメソッドを呼び出します。このコールバックパラメータが指定され、かつエラーが発生した場合、コールバックメソッドは、リクエスト/レスポンスサイクルを終了するか、次のルートに制御を渡すことによって、レスポンス処理を明示的に処理する必要があります。

以下は、すべてのパラメータを使用したres.sendFile()の例です：

app.get('/file/:name', function(req, res, next) {
    var options = {
        root:__dirname + '/public',
        dotfile:'deny',
        headers:{
            'x-timestamp':Date.now(),
            'x-sent':true
        }
    };
    var fileName = req.params.name;
    res.sendFile(fileName, options, function(err) {
        if (err) {
            console.log(err);
            res.status(err.status).end();
        }
        else {
            console.log('sent', fileName);
        }
    });
});

res.sendFileはファイルサービスのきめ細かいサポートを提供します。次の例で説明します：

app.get('/user/:uid/photos/:file', function(req, res) {
    var uid = req.params.uid
        , file = req.params.file;
    req.user.mayViewFilesFrom(uid, function(yes) {
        if (yes) {
            res.sendFile('/upload/' + uid + '/' + file);
        }
        else {
            res.status(403).send('Sorry! you cant see that.');
        }
    });
})

詳細については、または問題や懸念がある場合は、次を参照してください。send。

res.sendStatus(statusCode)

レスポンスオブジェクトのHTTP status codeためにstatusCodeを設定し、送信します。statusCodeその対応する文字列形式をレスポンスのBodyとして。

res.sendStatus(200); // equivalent to res.status(200).send('OK');
res.sendStatus(403); // equivalent to res.status(403).send('Forbidden');
res.sendStatus(404); // equivalent to res.status(404).send('Not Found');
res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')

サポートされていないステータスが指定された場合、このHTTPステータスは依然としてstatusCodeに設定され、このコードの文字列がBodyとして使用されます。

res.sendStatus(2000); // equivalent to res.status(2000).send('2000');

More about HTTP Status Codes

res.set(field [, value])

レスポンスオブジェクトのHTTPヘッダーを設定します。fieldためにvalue複数の値を一度に設定するには、オブジェクトをパラメータとして渡すことができます。

res.set('Content-Type', 'text/plain');
res.set({
    'Content-Type':'text/plain',
    'Content-Length':'123',
    'ETag':'123456'
})

これはres.header(field [,value])と同じ効果です。

res.status(code)

このメソッドを使用して、レスポンスオブジェクトのHTTPステータスを設定します。これはNodeのresponse.statusCodeの一貫性のあるエイリアスです。

res.status(403).end();
res.status(400).send('Bad Request');
res.status(404).sendFile('/absolute/path/to/404.png');

res.type(type)

プログラムはContent-TypeHTTPヘッダーのMIMEタイプを設定します。もしこの設定されたtypeがmime.lookup正しいものに解析できるContent-Type。もしtypeに/文字が含まれている場合、プログラムは直接Content-Typeためにtype。

res.type('.html');              // => 'text/html'
res.type('html');               // => 'text/html'
res.type('json');               // => 'application/json'
res.type('application/json');   // => 'application/json'
res.type('png');                // => image/png:

res.vary(field)

Varyレスポンスヘッダーがない場合は、Varyレスポンスヘッダーを追加します。

追記：varyの意味は、プロキシサーバー/キャッシュ/CDNに対して、リクエストが同じかどうかを判断する方法を伝えることです。vary内の組み合わせが、サーバー/キャッシュ/CDNが判断する際の基準になります。たとえば、VaryにUser-Agentがある場合、同じリクエストであっても、ユーザーがIEでページを開き、その後Firefoxで同じページを開いた場合、CDN/プロキシは異なるページと見なします。VaryにUser-Agentがない場合、CDN/プロキシは同じページと見なし、キャッシュされたページを直接ユーザーに返し、Webサーバーにそのページを再度リクエストしません。簡単に言うと、fieldキャッシュのkeyとして、キャッシュにヒットするかどうかを判断するために使用されます

res.vary('User-Agent').render('docs');

Router

1つのrouterオブジェクトは、ミドルウェアとルーティングに関する独立したインスタンスです。これは「mini-application」（ミニアプリケーション）と考えることができ、ミドルウェアとルートメソッドを操作する機能を持ちます。各Expressプログラムには組み込みのappルートがあります。app.use()メソッドのパラメータとして、または別のルートのuse()パラメータとして使用できます。expressオブジェクトにはRouter()メソッドがあり、Router()を使用して新しいrouterオブジェクトを作成できます。

res.vary('User-Agent').render('docs');

Router([options])

次のように、ルートを作成できます：

var router = express.Router([options]);

optionsパラメータはルートの動作を指定でき、次の選択肢があります：

あなたはrouterをプログラムとして扱い、その上にミドルウェアやHTTPルートメソッドを追加できます（例：get，put，postなど）。

// invoked for any requests passed to this router
router.use(function(req, res, next) {
  // .. some logic here .. like any other middleware
  next();
});
// will handle any request that ends in /events
// depends on where the router is "use()'d"
router.get('/events', function(req, res, next) {
  // ..
});

特別なルートURLにルートをマウントできます。これにより、各ルートを別々のファイルや、さらにミニプログラムに配置することができます。

// only requests to /calendar/* will be sent to our "router"
app.use('/calendar', router);

Methods

router.all(path, [callback, ...] callback)

このメソッドはrouter.METHOD()メソッドと同じですが、このメソッドはすべてのHTTPアクションにマッチする点が異なります。

このメソッドは、グローバルなロジック処理を特別なパスプレフィックスや任意のマッチングにマッピングしたい場合に非常に便利です。たとえば、次に示すルートを他のルートの前に置くと、そのポイント以降のすべてのルートで検証操作とユーザー情報の自動読み込みが要求されます。これらのグローバルなロジック操作は、リクエスト/レスポンスサイクルを終了する必要がないことに注意してください：loaduserタスクを実行してから、next()を呼び出して、実行フローを後続のルートに引き渡すことができます。

router.all('*', requireAuthentication, loadUser);

同等の形式:

router.all('*', requireAuthentication)
router.all('*', loadUser);

これはホワイトリストのグローバル機能の例です。この例は前のものとよく似ていますが、/apiで始まるパスのみに作用します:

router.all('/api/*', requireAuthentication);

router.METHOD(path, [callback, ...] callback)

router.METHOD()メソッドは、ルートメソッドをExpress内で提供します。ここでのMETHODはHTTPメソッドの1つで、たとえばGET，PUT，POSTなどです。ただし、router内のMETHODは小文字です。したがって、実際のメソッドはrouter.get()，router.put()，router.post()などです。

複数のコールバック関数を提供できます。それらはミドルウェアと同じように動作しますが、これらのコールバックはnext('router')を呼び出して残りのルートコールバックをバイパスできる点が異なります。このメカニズムを使用して、ルートにいくつかの前提条件を設定できます。リクエストが現在のルートの処理条件を満たしていない場合は、後続のルートに制御を渡します。

以下の断片は、最も簡単なルート定義を示しています。Expressはpath文字列を正規表現に変換し、受信リクエストを内部的にマッチングします。マッチングの際には、Query stringsは考慮されません。たとえば、"GET /"は以下のルートにマッチし、"GET /?name=tobi"も同様です。

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

マッチングするpathに特別な制限がある場合は、正規表現を使用できます。たとえば、次は"GET /commits/71dbb9c"と"GET /commits/71bb92..4c084f9"にマッチします。

router.get(/^\/commits\/(\w+)(?:\.\.(\w+))?$/, function(req, res) {
    var from = req.params[0];
    var to = req.params[1];
    res.send('commit range ' + from + '..' + to);
});

router.param(name, callback)

ルートパラメータにコールバックトリガーを追加します。ここでのnameはパラメータ名、functionはコールバックメソッドです。コールバックメソッドのパラメータは、順にリクエストオブジェクト、レスポンスオブジェクト、次のミドルウェア、パラメータ値、パラメータ名です。nameは技術的にはオプションですが、Express V4.11.0以降のバージョンでは推奨されません（下記参照）。

とは異なり、app.param()，router.param()はルートパラメータとして配列を受け入れません。

たとえば、:userがルートパスに現れる場合、ユーザー読み込みのロジック処理をマッピングして、このルートにreq.userを自動的に提供したり、入力パラメータを検証したりできます。

router.param('user', function(req, res, next, id) {
    User.find(id, function(error, user) {
        if (err) {
            next(err);
        }
        else if (user){
            req.user = user;
        } else {
            next(new Error('failed to load user'));
        }
    });
});

に関しては、Paramのコールバックで定義されたルートはローカルです。それらはマウントされたappやルートには継承されません。したがって、router上で定義されたparamコールバックは、それがrouter上のルートがこのルートパラメータを持っている場合にのみ有効です。

が定義されたparamルート上では、paramコールバックはすべて最初に呼び出されます。それらはリクエスト-レスポンスサイクル内で一度だけ呼び出されます。複数のルートがマッチする場合でも同様です。以下の例のとおりです：

router.param('id', function(req, res, next, id) {
    console.log('CALLED ONLY ONCE');
    next();
});
router.get('/user/:id', function(req, res, next) {
    console.log('although this matches');
    next();
});
router.get('/user/:id', function(req, res) {
    console.log('and this mathces too');
    res.end();
});

GET /user/42 の場合、次の結果が得られます：

CALLED ONLY ONCE
although this matches
and this matches too

以下のセクションで説明するrouter.param(callback)は、v4.11.0以降で非推奨になりました。

コールバックパラメータを1つだけrouter.param(name, callback)メソッドに渡すと、router.param(naem, callback)メソッドの動作は完全に変わります。このコールバックパラメータは、router.param(name, callback)どのような動作を持つべきかを定義するカスタムメソッドです。このメソッドは2つのパラメータを受け取り、ミドルウェアを返す必要があります。

このコールバックの最初のパラメータは、キャプチャする必要があるURLのパラメータ名です。2番目のパラメータは任意のJavaScriptオブジェクトで、ミドルウェアを返す実装で使用される可能性があります。 このコールバックメソッドが返すミドルウェアは、URLにこのパラメータが含まれている場合に実行される動作を決定します。

以下の例では、router.param(name, callback)パラメータシグネチャはrouter.param(name, accessId)に変更されました。置き換え先はパラメータ名とコールバックを受け取り、router.param()現在はパラメータ名と数値を受け取ります。

var express = require('express');
var app = express();
var router = express.Router();
router.param(function(param, option){
    return function(req, res, next, val) {
        if (val == option) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
router.param('id', 1337);
router.get('/user/:id', function(req, res) {
    res.send('Ok');
});
app.use(router);
app.listen(3000, function() {
    console.log('Ready');
}); 

この例では、router.param(name. callback) のパラメータシグネチャは元のままですが、ミドルウェアに置き換えられており、user idの型が正しいかどうかを検出するカスタムデータ型検出メソッドが定義されています。

router.param(function(param, validator) {
    return function(req, res, next, val) {
        if (validator(val)) {
            next();
        }
        else {
            res.sendStatus(403);
        }
    }
});
router.param('id', function(candidate) {
    return !isNaN(parseFloat(candidate)) && isFinite(candidate);
});

router.route(path)

シングルトンパターンのルートインスタンスを返します。その後、その上にさまざまなHTTPメソッドのミドルウェアを適用できます。router.route()を使用して、ルート名の重複（例：タイプミスによるエラー）を避けます。つまり、意図しているのはrouter.route()このシングルトンメソッドを使用して、同じパスに複数のルートインスタンスが存在するのを避けることです。

上記のrouter.param()例に基づいて、以下のコードは、router.route()を使用してさまざまなHTTPメソッドのハンドラを指定する方法を示しています。

var router = express.Router();
router.param('user_id', function(req, res, next, id) {
    // sample user, would actually fetch from DB, etc...
    req.user = {
        id:id,
        name:"TJ"
    };
    next();
});
router.route('/users/:user_id')
    .all(function(req, res, next) {
        // runs for all HTTP verbs first
        // think of it as route specific middleware!
        next();
    })
    .get(function(req, res, next) {
        res.json(req.user);
    })
    .put(function(req, res, next) {
        // just an example of maybe updating the user
        req.user.name = req.params.name;
        // save user ... etc
        res.json(req.user);
    })
    .post(function(req, res, next) {
        next(new Error('not implemented'));
    })
    .delete(function(req, res, next) {
        next(new Error('not implemented'));
    })

この方法では、単一の/usrs/:useridパスを再利用して、さまざまなHTTPメソッドを追加しています。

router.use([path], [function, ...] function)

オプションのpathパラメータで指定されたパスに、指定されたミドルウェアメソッドをマウントします。未指定のpathパラメータの場合、デフォルト値は/です。 このメソッドはapp.use()に似ています。簡単な例と使用例を以下に説明します。app.use()を参照して、詳細情報を得てください。

ミドルウェアは配管のようなものです。リクエストは、あなたが定義した最初のミドルウェアから始まり、ミドルウェアスタックを下っていきます。パスがマッチした場合、そのリクエストが処理されます。

var express = require('express');
var app = express();
var router = express.Router();
// simple logger for this router`s requests
// all requests to this router will first hit this middleware
router.use(function(req, res, next) {
    console.log('%s %s %s', req.method, req.url, req.path);
    next();
})
// this will only be invoked if the path starts with /bar form the mount ponit
router.use('/bar', function(req, res, next) {
    // ... maybe some additional /bar logging ...
    next();
})
// always be invoked
router.use(function(req, res, next) {
    res.send('hello world')；
})
app.use('/foo', router);
app.listen(3000);

ミドルウェアfunctionの場合、マウントされたパスは取り除かれ、見えなくなります。この特性の主な影響は、異なるパスに同じミドルウェアをマウントしても、プレフィックスが変更されていても、コードを変更する必要がないことです。

router.use()でミドルウェアを定義する順序は重要です。ミドルウェアは順番に呼び出されるため、順序がミドルウェアの優先順位を決定します。たとえば、通常ログは最初に使用するミドルウェアであり、すべてのリクエストが記録されるようにします。

var logger = require('morgan');
router.use(logger());
router.use(express.static(__dirname + '/public'));
router.use(function(req, res) {
    res.send('Hello');
});

さて、静的ファイルのリクエストを記録したくないが、[X]の後に定義されたlogger()ルートとミドルウェアは記録し続けたいとします。単純にstatic()を先頭に移動することで解決できます：

router.use(express.static(__dirname + '/public'));
router.use(logger());
router.use(function(req, res){
  res.send('Hello');
});

もう1つの確実な例は、異なるパスから静的ファイルをホストする場合です。[X]を./public先頭に置くことで、より高い優先順位を得られます：

app.use(express.static(__dirname + '/public'));
app.use(express.static(__dirname + '/files'));
app.use(express.static(__dirname + '/uploads'));

router.use()メソッドは名前付きパラメータもサポートしています。これにより、マウントポイントが他のルートに対して名前付きパラメータを使用してプリロードできるようになり、非常に有益です。

原文アドレス：https://github.com/bajian/express_api_4.x_chinese