4.x API

express.json([options])

これは Express の組み込みミドルウェア関数です。JSON ペイロードを持つ着信リクエストを解析し、body-parserに基づいています。

JSON のみを解析し、Content-Typeヘッダーがtypeオプションと一致するリクエストのみを対象とするミドルウェアを返します。このパーサーは、ボディの任意のUnicodeエンコーディングを受け入れ、gzipおよびdeflateエンコーディングの自動インフレーションをサポートしています。

ミドルウェアの後、解析されたデータを含む新しいbodyオブジェクトがrequestオブジェクトに追加されます（つまり、req.body）。解析するボディがない場合、Content-Typeが一致しない場合、またはエラーが発生した場合は、空のオブジェクト（{}）になります。

次の表は、オプションのoptionsオブジェクトのプロパティを示しています。

express.raw([options])

これは Express の組み込みミドルウェア関数です。着信リクエストペイロードをBufferに解析し、body-parserに基づいています。

すべてのボディをBufferとして解析し、Content-Typeヘッダーがtypeオプションと一致するリクエストのみを対象とするミドルウェアを返します。このパーサーは、ボディの任意のUnicodeエンコーディングを受け入れ、gzipおよびdeflateエンコーディングの自動インフレーションをサポートしています。

ミドルウェアの後、解析されたデータを含む新しいbodyBufferがrequestオブジェクトに追加されます（つまり、req.body）。解析するボディがない場合、Content-Typeが一致しない場合、またはエラーが発生した場合は、空のオブジェクト（{}）になります。

次の表は、オプションのoptionsオブジェクトのプロパティを示しています。

express.Router([options])

新しいrouterオブジェクトを作成します。

var router = express.Router([options])

オプションのoptionsパラメーターは、ルーターの動作を指定します。

アプリケーションと同様に、ミドルウェアとHTTPメソッドルート（get、put、postなど）をrouterに追加できます。

詳細については、Routerを参照してください。

express.static(root, [options])

これは Express の組み込みミドルウェア関数です。静的ファイルをサービスし、serve-staticに基づいています。

root引数は、静的アセットを提供するルートディレクトリを指定します。関数は、指定されたrootディレクトリにreq.urlを組み合わせることで、提供するファイルを決定します。ファイルが見つからない場合、404レスポンスを送信する代わりに、next()を呼び出して次のミドルウェアに進み、スタックとフォールバックを可能にします。

次の表は、optionsオブジェクトのプロパティを示しています。下記の例も参照してください。

詳細については、Expressでの静的ファイルの提供とミドルウェアの使用 - 組み込みミドルウェアを参照してください。

dotfiles

このオプションの可能な値は次のとおりです。

• “allow” - ドットファイルに対する特別な処理は行いません。
• “deny” - ドットファイルのリクエストを拒否し、403で応答してからnext()を呼び出します。
• “ignore” - ドットファイルが存在しないかのように動作し、404で応答してからnext()を呼び出します。

注記: デフォルト値では、ドットで始まるディレクトリ内のファイルは無視されません。

fallthrough

このオプションがtrueの場合、不正なリクエストや存在しないファイルへのリクエストなどのクライアントエラーが発生すると、このミドルウェアは単にnext()を呼び出してスタック内の次のミドルウェアを呼び出します。falseの場合、これらのエラー（404も）はnext(err)を呼び出します。

複数の物理ディレクトリを同じWebアドレスにマッピングする場合、またはルートで存在しないファイルを補完する場合に、このオプションをtrueに設定します。

このミドルウェアを厳密に単一のファイルシステムディレクトリとして設計されたパスにマウントしている場合は、オーバーヘッドを削減するために404をショートサーキットできるようにfalseを使用します。このミドルウェアは、すべてのメソッドにも応答します。

setHeaders

このオプションには、カスタムレスポンスヘッダーを設定する関数を指定します。ヘッダーの変更は同期的に行う必要があります。

関数のシグネチャは次のとおりです。

fn(res, path, stat)

引数

• res、レスポンスオブジェクト。
• path、送信されるファイルパス。
• stat、送信されるファイルのstatオブジェクト。

express.staticの例

詳細なオプションオブジェクトを使用してexpress.staticミドルウェア関数を使用する例を以下に示します。

var options = {
  dotfiles: 'ignore',
  etag: false,
  extensions: ['htm', 'html'],
  index: false,
  maxAge: '1d',
  redirect: false,
  setHeaders: function (res, path, stat) {
    res.set('x-timestamp', Date.now())
  }
}

app.use(express.static('public', options))

express.text([options])

これはExpressの組み込みミドルウェア関数です。受信リクエストペイロードを文字列として解析し、body-parserに基づいています。

すべての本文を文字列として解析するミドルウェアを返し、Content-Typeヘッダーがtypeオプションと一致するリクエストのみを調べます。このパーサーは本文の任意のUnicodeエンコーディングを受け入れ、gzipおよびdeflateエンコーディングの自動インフレーションをサポートしています。

ミドルウェアの後、解析されたデータを含む新しいbody文字列がリクエストオブジェクトに設定されます（つまり、req.body）。解析する本文がない場合、Content-Typeが一致しない場合、またはエラーが発生した場合は、空のオブジェクト（{}）になります。

次の表は、オプションのoptionsオブジェクトのプロパティを示しています。

express.urlencoded([options])

これはExpressの組み込みミドルウェア関数です。URLエンコードされたペイロードを含む受信リクエストを解析し、body-parserに基づいています。

URLエンコードされた本文のみを解析し、Content-Typeヘッダーがtypeオプションと一致するリクエストのみを調べるミドルウェアを返します。このパーサーは本文のUTF-8エンコーディングのみを受け入れ、gzipおよびdeflateエンコーディングの自動インフレーションをサポートしています。

ミドルウェアの後、解析されたデータを含む新しいbodyオブジェクトがリクエストオブジェクトに設定されます（つまり、req.body）。解析する本文がない場合、Content-Typeが一致しない場合、またはエラーが発生した場合は、空のオブジェクト（{}）になります。このオブジェクトにはキーと値のペアが含まれ、値は文字列または配列（extendedがfalseの場合）、または任意のタイプ（extendedがtrueの場合）になります。

次の表は、オプションのoptionsオブジェクトのプロパティを示しています。

app.locals

app.localsオブジェクトには、アプリケーション内のローカル変数であるプロパティがあり、res.renderでレンダリングされたテンプレートで使用できます。

console.dir(app.locals.title)
// => 'My App'

console.dir(app.locals.email)
// => 'me@myapp.com'

設定されると、app.localsプロパティの値はアプリケーションの存続期間中保持されます。これは、リクエストの存続期間中のみ有効なres.localsプロパティとは対照的です。

アプリケーション内でレンダリングされたテンプレートでローカル変数にアクセスできます。これは、テンプレートにヘルパー関数を提供する場合と、アプリケーションレベルのデータを提供する場合の両方で役立ちます。ローカル変数は、req.app.locals（req.appを参照）を介してミドルウェアで使用できます。

app.locals.title = 'My App'
app.locals.strftime = require('strftime')
app.locals.email = 'me@myapp.com'

app.mountpath

app.mountpathプロパティには、サブアプリケーションがマウントされた1つ以上のパスパターンが含まれています。

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オブジェクトのbaseUrlプロパティに似ていますが、req.baseUrlは一致したパターンの代わりに一致したURLパスを返します。

サブアプリケーションが複数のパスパターンにマウントされている場合、app.mountpathはマウントされているパターンのリストを返します。次の例を参照してください。

var admin = express()

admin.get('/', function (req, res) {
  console.dir(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

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)

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

このメソッドは標準のapp.METHOD()メソッドに似ていますが、すべてのHTTP動詞に一致します。

引数

例

次のコールバックは、GET、POST、PUT、DELETE、またはその他のHTTPリクエストメソッドを使用しているかどうかに関係なく、/secretへのリクエストに対して実行されます。

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

app.all()メソッドは、特定のパスプレフィックスまたは任意の一致に対する「グローバル」ロジックをマッピングする場合に役立ちます。たとえば、次のものを他のすべてのルート定義の先頭に配置すると、その時点以降のすべてのルートで認証が必要になり、ユーザーが自動的にロードされます。これらのコールバックはエンドポイントとして機能する必要はありません。loadUserはタスクを実行してからnext()を呼び出して、後続のルートの一致を続行できます。

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

または同等のもの

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

別の例は、ホワイトリストに登録された「グローバル」機能です。この例は上記の例に似ていますが、「/api」で始まるパスのみを制限します。

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

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

指定されたコールバック関数を使用して、指定されたパスにHTTP DELETEリクエストをルーティングします。詳細については、ルーティングガイドを参照してください。

引数

例

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

app.disable(name)

nameで指定されたブール値の設定をfalseに設定します。ここで、nameはアプリケーション設定テーブルのプロパティのいずれかです。ブール値のプロパティに対してapp.set('foo', false)を呼び出すことは、app.disable('foo')を呼び出すことと同じです。

例

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

app.disabled(name)

ブール値の設定nameが無効化されている（false）場合にtrueを返します。ここで、nameはアプリケーション設定テーブルのプロパティのいずれかです。

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

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

app.enable(name)

nameで指定されたブール値の設定をtrueに設定します。ここで、nameはアプリケーション設定テーブルのプロパティのいずれかです。ブール値のプロパティに対してapp.set('foo', true)を呼び出すことは、app.enable('foo')を呼び出すことと同じです。

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

app.enabled(name)

設定nameが有効化されている（true）場合にtrueを返します。ここで、nameはアプリケーション設定テーブルのプロパティのいずれかです。

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

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

app.engine(ext, callback)

指定されたテンプレートエンジンcallbackをextとして登録します。

デフォルトでは、Expressはファイル拡張子に基づいてエンジンをrequire()します。例えば、“foo.pug”ファイルをレンダリングしようとすると、Expressは内部的に以下を実行し、後続の呼び出しでのパフォーマンス向上のため、require()をキャッシュします。

app.engine('pug', require('pug').__express)

このメソッドは、.__expressをすぐに提供しないエンジン、またはテンプレートエンジンに異なる拡張子を「マップ」したい場合に使用します。

例えば、EJSテンプレートエンジンを“.html”ファイルにマップするには

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

この場合、EJSはExpressが期待するのと同じシグネチャを持つ.renderFile()メソッド（(path, options, callback)）を提供しますが、内部的にこのメソッドをejs.__expressとしてエイリアスしているため、“.ejs”拡張子を使用している場合は何もする必要はありません。

一部のテンプレートエンジンはこの規約に従っていません。consolidate.jsライブラリは、Nodeテンプレートエンジンをこの規約に従うようにマップするため、Expressとシームレスに動作します。

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

app.get(name)

nameアプリケーション設定の値を返します。ここで、nameはアプリケーション設定テーブルの文字列のいずれかです。例:

app.get('title')
// => undefined

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

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

指定されたパスとコールバック関数を使用して、HTTP GETリクエストをルーティングします。

引数

詳細については、ルーティングガイドを参照してください。

例

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

app.listen(path, [callback])

UNIXソケットを起動し、指定されたパスで接続を待ち受けます。このメソッドは、Nodeのhttp.Server.listen()と同一です。

var express = require('express')
var app = express()
app.listen('/tmp/sock')

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

指定されたホストとポートで接続をバインドして待ち受けます。このメソッドは、Nodeのhttp.Server.listen()と同一です。

ポートが省略されているか0の場合、オペレーティングシステムは任意の未使用ポートを割り当てます。これは、自動化されたタスク（テストなど）の場合に便利です。

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

express()によって返されるappは、実際にはJavaScriptのFunctionであり、リクエストを処理するコールバックとしてNodeのHTTPサーバーに渡すように設計されています。これにより、アプリがこれらのサーバーから継承しないため（単なるコールバックです）、同じコードベースでHTTPとHTTPSの両方のバージョンのアプリを簡単に提供できます。

var express = require('express')
var https = require('https')
var http = require('http')
var app = express()

http.createServer(app).listen(80)
https.createServer(options, app).listen(443)

app.listen()メソッドはhttp.Serverオブジェクトを返し（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()などです。ルーティングメソッドで完全なリストを参照してください。

引数

ルーティングメソッド

Expressは、同じ名前のHTTPメソッドに対応する以下のルーティングメソッドをサポートしています。

APIドキュメントには、最も一般的なHTTPメソッドapp.get()、app.post()、app.put()、app.delete()のみが明示的に記載されています。ただし、上記の他のメソッドもまったく同じように機能します。

無効なJavaScript変数名に変換されるメソッドをルーティングするには、ブラケット表記を使用します。例：app['m-search']('/', function ...。

メソッドapp.all()は、どのHTTPメソッドからも派生せず、指定されたパスのすべてのHTTPリクエストメソッドでミドルウェアを読み込みます。詳細については、app.allを参照してください。

ルーティングの詳細については、ルーティングガイドを参照してください。

app.param([name], callback)

ルートパラメータにコールバックトリガーを追加します。ここで、nameはパラメータの名前またはそれらの配列であり、callbackはコールバック関数です。コールバック関数の引数は、リクエストオブジェクト、レスポンスオブジェクト、次のミドルウェア、パラメータの値、パラメータの名前の順です。

nameが配列の場合、callbackトリガーは、宣言されている順に、宣言された各パラメータに対して登録されます。さらに、最後のパラメータを除く、宣言された各パラメータについて、コールバック内のnextへの呼び出しは、次の宣言されたパラメータのコールバックを呼び出します。最後のパラメータの場合、nextへの呼び出しは、nameが文字列の場合と同様に、現在処理中のルートの次のミドルウェアを呼び出します。

例えば、:userがルートパスに存在する場合、ユーザー読み込みロジックをマップしてルートにreq.userを自動的に提供したり、パラメータ入力の検証を実行したりできます。

app.param('user', function (req, res, next, id) {
  // try to get the user details from the User model and attach it to the request object
  User.find(id, function (err, user) {
    if (err) {
      next(err)
    } else if (user) {
      req.user = user
      next()
    } else {
      next(new Error('failed to load user'))
    }
  })
})

パラメータコールバック関数は、定義されているルーターにローカルです。マウントされたアプリまたはルーターでは継承されません。したがって、appで定義されたパラメータコールバックは、appルートで定義されたルートパラメータによってのみトリガーされます。

すべてのパラメータコールバックは、パラメータが発生するルートのハンドラーの前に呼び出され、以下の例に示すように、パラメータが複数のルートで一致する場合でも、リクエスト・レスポンスサイクルでそれぞれ一度だけ呼び出されます。

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 matches 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) {
  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 matches too

app.param(name, callback)メソッドの動作は、app.param()に関数のみを渡すことで完全に変更できます。この関数は、app.param(name, callback)がどのように動作するべきかのカスタム実装であり、2つのパラメータを受け取り、ミドルウェアを返す必要があります。

この関数の最初の引数は、キャプチャするURLパラメータの名前であり、2番目の引数は、ミドルウェア実装の戻り値として使用できる任意のJavaScriptオブジェクトです。

関数によって返されるミドルウェアは、URLパラメータがキャプチャされたときに何が発生するかを決定します。

この例では、app.param(name, callback)シグネチャがapp.param(name, accessId)に変更されています。app.param()は、名前とコールバックを受け入れる代わりに、名前と数値を受け入れるようになります。

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

// customizing the behavior of app.param()
app.param(function (param, option) {
  return function (req, res, next, val) {
    if (val === option) {
      next()
    } else {
      next('route')
    }
  }
})

// using the customized app.param()
app.param('id', 1337)

// route to trigger the capture
app.get('/user/:id', function (req, res) {
  res.send('OK')
})

app.listen(3000, function () {
  console.log('Ready')
})

この例では、app.param(name, callback)シグネチャは同じですが、ミドルウェアコールバックの代わりに、ユーザーIDのデータ型を検証するためのカスタムデータ型チェック関数が定義されています。

app.param(function (param, validator) {
  return function (req, res, next, val) {
    if (validator(val)) {
      next()
    } else {
      next('route')
    }
  }
})

app.param('id', function (candidate) {
  return !isNaN(parseFloat(candidate)) && isFinite(candidate)
})

// captures '1-a_6' but not '543-azser-sder'
router.get('/[0-9]+-[[\\w]]*', function (req, res, next) { next() })

// captures '1-a_6' and '543-az(ser"-sder' but not '5-a s'
router.get('/[0-9]+-[[\\S]]*', function (req, res, next) { next() })

// captures all (equivalent to '.*')
router.get('[[\\s\\S]]*', function (req, res, next) { next() })

app.path()

アプリの正規パス（文字列）を返します。

var app = express()
var blog = express()
var blogAdmin = express()

app.use('/blog', blog)
blog.use('/admin', blogAdmin)

console.dir(app.path()) // ''
console.dir(blog.path()) // '/blog'
console.dir(blogAdmin.path()) // '/blog/admin'

このメソッドの動作は、マウントされたアプリが複雑な場合、非常に複雑になる可能性があります。通常は、アプリの正規パスを取得するにはreq.baseUrlを使用する方が良いでしょう。

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

指定されたパスとコールバック関数を使用して、HTTP POSTリクエストをルーティングします。詳細については、ルーティングガイドを参照してください。

引数

例

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

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

指定されたパスとコールバック関数を使用して、HTTP PUTリクエストをルーティングします。

引数

例

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

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

callback関数を使用して、ビューのレンダリングされたHTMLを返します。ビューのローカル変数を含むオブジェクトであるオプションのパラメータを受け入れます。res.render()に似ていますが、レンダリングされたビューをクライアントに独自に送信することはできません。

app.render('email', function (err, html) {
  // ...
})

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

app.route(path)

単一のルートのインスタンスを返します。これを使用して、オプションのミドルウェアを使用してHTTP動詞を処理できます。重複したルート名（およびタイプミス）を回避するにはapp.route()を使用します。

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を割り当てます。任意の値を格納できますが、特定の名前を使用してサーバーの動作を設定できます。これらの特別な名前はアプリケーション設定テーブルにリストされています。

ブール値のプロパティに対してapp.set('foo', true)を呼び出すことは、app.enable('foo')を呼び出すことと同じです。同様に、ブール値のプロパティに対してapp.set('foo', false)を呼び出すことは、app.disable('foo')を呼び出すことと同じです。

app.get()を使用して、設定の値を取得します。

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

アプリケーション設定

次の表に、アプリケーション設定をリストします。

サブアプリは

• デフォルト値を持つ設定の値を継承しません。サブアプリケーションで値を設定する必要があります。
• デフォルト値のない設定の値を継承します。これらは以下の表で明示的に示されています。

例外：サブアプリは、デフォルト値がある場合でも（下位互換性のため）、trust proxyの設定値を継承します。サブアプリは、本番環境（NODE_ENVが「production」の場合）ではview cacheの設定値を継承しません。

app.set('trust proxy', 'loopback')

app.set('trust proxy', 'loopback, 123.123.123.123')

app.set('trust proxy', 'loopback, linklocal, uniquelocal')

app.set('trust proxy', ['loopback', 'linklocal', 'uniquelocal'])

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

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

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

指定されたパスに指定されたミドルウェア関数または関数をマウントします。ミドルウェア関数は、要求されたパスのベースがpathと一致する場合に実行されます。

引数

説明

ルートは、そのパスの直後に「/」が続くパスと一致します。例：app.use('/apple', ...)は "apple"、"apple/images"、"apple/images/news" などと一致します。

pathのデフォルトは「/」であるため、パスなしでマウントされたミドルウェアは、アプリへのすべての要求に対して実行されます。
たとえば、このミドルウェア関数はアプリへのすべての要求に対して実行されます。

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')
})

// requests will never reach this route
app.get('/', function (req, res) {
  res.send('Welcome')
})

エラー処理ミドルウェア

エラー処理ミドルウェアは常に4つの引数を取ります。エラー処理ミドルウェア関数として識別するには、4つの引数を指定する必要があります。nextオブジェクトを使用する必要がない場合でも、シグネチャを維持するために指定する必要があります。そうしないと、nextオブジェクトは通常のミドルウェアとして解釈され、エラー処理に失敗します。エラー処理ミドルウェアの詳細については、エラー処理を参照してください。

エラー処理ミドルウェア関数は、他のミドルウェア関数と同じ方法で定義しますが、3つではなく4つの引数（具体的には(err, req, res, next)シグネチャ）を使用します。

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

パスの例

次の表は、ミドルウェアのマウントのための有効なpath値の簡単な例を示しています。

app.use('/abcd', function (req, res, next) {
  next()
})

app.use('/abc?d', function (req, res, next) {
  next()
})

app.use('/ab+cd', function (req, res, next) {
  next()
})

app.use('/ab*cd', function (req, res, next) {
  next()
})

app.use('/a(bc)?d', function (req, res, next) {
  next()
})

app.use(/\/abc|\/xyz/, function (req, res, next) {
  next()
})

app.use(['/abcd', '/xyza', /\/lmn|\/pqr/], function (req, res, next) {
  next()
})

ミドルウェアコールバック関数の例

次の表は、app.use()、app.METHOD()、app.all()のcallback引数として使用できるミドルウェア関数の簡単な例を示しています。例はapp.use()向けですが、app.use()、app.METHOD()、app.all()にも有効です。

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(path.join(__dirname, 'public')))

要求パスが「/static」で始まる場合にのみ静的コンテンツを提供するために、「/static」にミドルウェアをマウントします

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

静的コンテンツ要求のログを無効にするには、静的ミドルウェアの後にロガーミドルウェアをロードします

app.use(express.static(path.join(__dirname, 'public')))
app.use(logger())

複数のディレクトリから静的ファイルを提供しますが、「./public」を他のディレクトリよりも優先します

app.use(express.static(path.join(__dirname, 'public')))
app.use(express.static(path.join(__dirname, 'files')))
app.use(express.static(path.join(__dirname, 'uploads')))

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パス。

req.baseUrlプロパティは、appオブジェクトのmountpathプロパティに似ていますが、app.mountpathは一致したパスパターンを返します。

例

var greet = express.Router()

greet.get('/jp', function (req, res) {
  console.log(req.baseUrl) // /greet
  res.send('Konichiwa!')
})

app.use('/greet', greet) // load the router on '/greet'

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

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

/greet/jpへのリクエストが行われると、req.baseUrlは“/greet”になります。/hello/jpへのリクエストが行われると、req.baseUrlは“/hello”になります。

req.body

リクエストボディで送信されたデータのキーと値のペアを含みます。デフォルトではundefinedであり、express.json()やexpress.urlencoded()などのボディパーシングミドルウェアを使用すると設定されます。

次の例は、ボディパーシングミドルウェアを使用してreq.bodyを設定する方法を示しています。

var express = require('express')

var app = express()

app.use(express.json()) // for parsing application/json
app.use(express.urlencoded({ extended: true })) // for parsing application/x-www-form-urlencoded

app.post('/profile', function (req, res, next) {
  console.log(req.body)
  res.json(req.body)
})

req.cookies

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

// Cookie: name=tj
console.dir(req.cookies.name)
// => 'tj'

Cookieが署名されている場合は、req.signedCookiesを使用する必要があります。

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

req.fresh

クライアントのキャッシュにおいてレスポンスがまだ「新鮮」な場合、trueが返され、そうでない場合は、クライアントキャッシュが古くなったことを示すfalseが返され、完全なレスポンスを送信する必要があります。

エンドツーエンドのリロードリクエストを示すためにクライアントがCache-Control: no-cacheリクエストヘッダーを送信した場合、このモジュールはfalseを返し、これらのリクエストの処理を透過的にします。

キャッシュ検証の仕組みの詳細については、HTTP/1.1 Caching Specificationを参照してください。

console.dir(req.fresh)
// => true

req.hostname

Host HTTPヘッダーから取得されたホスト名を含みます。

trust proxy設定がfalseと評価されない場合、このプロパティは代わりにX-Forwarded-Hostヘッダーフィールドの値を取得します。このヘッダーは、クライアントまたはプロキシによって設定できます。

リクエストに複数のX-Forwarded-Hostヘッダーがある場合、最初のヘッダーの値が使用されます。これには、コンマ区切りの値を含む単一のヘッダーが含まれ、その最初の値が使用されます。

// Host: "example.com:3000"
console.dir(req.hostname)
// => 'example.com'

req.ip

リクエストのリモートIPアドレスを含みます。

trust proxy設定がfalseと評価されない場合、このプロパティの値はX-Forwarded-Forヘッダーの一番左のエントリから取得されます。このヘッダーは、クライアントまたはプロキシによって設定できます。

console.dir(req.ip)
// => '127.0.0.1'

req.ips

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

たとえば、X-Forwarded-Forがclient, proxy1, proxy2の場合、req.ipsは["client", "proxy1", "proxy2"]になります。ここで、proxy2は最も下流のプロキシです。

req.method

リクエストのHTTPメソッドに対応する文字列（GET、POST、PUTなど）を含みます。

req.originalUrl

このプロパティはreq.urlと非常によく似ていますが、元のリクエストURLを保持しているため、内部ルーティングの目的でreq.urlを自由に書き換えることができます。たとえば、app.use()の「マウント」機能は、マウントポイントを削除するためにreq.urlを書き換えます。

// GET /search?q=something
console.dir(req.originalUrl)
// => '/search?q=something'

req.originalUrlはミドルウェアとルーターオブジェクトの両方で使用でき、req.baseUrlとreq.urlの組み合わせです。次の例を参照してください。

app.use('/admin', function (req, res, next) { // GET 'http://www.example.com/admin/new?sort=desc'
  console.dir(req.originalUrl) // '/admin/new?sort=desc'
  console.dir(req.baseUrl) // '/admin'
  console.dir(req.path) // '/new'
  next()
})

req.params

このプロパティは、名前付きルート「パラメーター」にマップされたプロパティを含むオブジェクトです。たとえば、/user/:nameというルートがある場合、「name」プロパティはreq.params.nameとして使用できます。このオブジェクトのデフォルトは{}です。

// GET /user/tj
console.dir(req.params.name)
// => 'tj'

ルート定義に正規表現を使用する場合、キャプチャグループはreq.params[n]を使用して配列で提供されます。ここで、nはn^thキャプチャグループです。このルールは、/file/*などの文字列ルートを持つ名前のないワイルドカード一致に適用されます。

// GET /file/javascripts/jquery.js
console.dir(req.params[0])
// => 'javascripts/jquery.js'

req.paramsのキーを変更する必要がある場合は、app.paramハンドラーを使用します。変更は、ルートパスで既に定義されているパラメーターにのみ適用されます。

ミドルウェアまたはルートハンドラーでreq.paramsオブジェクトに加えられた変更は、リセットされます。

req.path

リクエストURLのパス部分を含みます。

// example.com/users?sort=desc
console.dir(req.path)
// => '/users'

req.protocol

リクエストプロトコル文字列を含みます。「http」または（TLSリクエストの場合）「https」のいずれかです。

trust proxy設定がfalseと評価されない場合、このプロパティは存在する場合はX-Forwarded-Protoヘッダーフィールドの値を使用します。このヘッダーは、クライアントまたはプロキシによって設定できます。

console.dir(req.protocol)
// => 'http'

req.query

このプロパティは、ルート内の各クエリ文字列パラメーターのプロパティを含むオブジェクトです。クエリパーサーが無効に設定されている場合、空のオブジェクト{}であり、それ以外の場合は設定されたクエリパーサーの結果です。

このプロパティの値は、クエリパーサーアプリケーション設定を使用してアプリケーションのニーズに合わせて構成できます。非常に人気のあるクエリ文字列パーサーはqsモジュールであり、これはデフォルトで使用されます。qsモジュールは多くの設定で非常に構成可能であり、req.queryを設定するためにデフォルトとは異なる設定を使用することが望ましい場合があります。

var qs = require('qs')
app.set('query parser', function (str) {
  return qs.parse(str, { /* custom options */ })
})

クエリパーサーアプリケーション設定のドキュメントで、その他のカスタマイズオプションを確認してください。

req.res

このプロパティは、このリクエストオブジェクトに関連するレスポンスオブジェクトへの参照を保持します。

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であるブールプロパティ。次と同等です。

console.dir(req.protocol === 'https')
// => true

req.signedCookies

cookie-parserミドルウェアを使用する場合、このプロパティには、リクエストによって送信された署名付きCookieが含まれ、署名解除され、使用準備ができています。署名付きCookieは、開発者の意図を示すために別のオブジェクトに存在します。そうでない場合、悪意のある攻撃がreq.cookieの値（簡単に偽造できる）に行われる可能性があります。Cookieに署名しても、「非表示」になったり暗号化されたりすることはありません。単に改ざんを防ぐだけです（署名に使用される秘密はプライベートであるため）。

署名付きCookieが送信されない場合、プロパティのデフォルトは{}になります。

// Cookie: user=tobi.CP7AWaXDfAKIRfH49dQzKJx7sKzzSoPq7/AcBBRVwlI3
console.dir(req.signedCookies.user)
// => 'tobi'

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

req.stale

リクエストが「古くなった」かどうかを示し、req.freshとは逆です。詳細については、req.freshを参照してください。

console.dir(req.stale)
// => true

req.subdomains

リクエストのドメイン名にあるサブドメインの配列。

// Host: "tobi.ferrets.example.com"
console.dir(req.subdomains)
// => ['ferrets', 'tobi']

デフォルトで2であるアプリケーションプロパティsubdomain offsetは、サブドメインセグメントの開始を決定するために使用されます。この動作を変更するには、app.setを使用してその値を変更します。

req.xhr

リクエストのX-Requested-Withヘッダーフィールドが「XMLHttpRequest」の場合trueであるブールプロパティ。これは、jQueryなどのクライアントライブラリによってリクエストが発行されたことを示します。

console.dir(req.xhr)
// => true

req.accepts(types)

リクエストのAccept HTTPヘッダーフィールドに基づいて、指定されたコンテンツタイプが許容されるかどうかを確認します。このメソッドは最適な一致を返し、指定されたコンテンツタイプのいずれも許容されない場合はfalseを返します（この場合、アプリケーションは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')
// => false

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

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

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

リクエストのAccept-Charset HTTPヘッダーフィールドに基づいて、指定された文字セットの最初の許容される文字セットを返します。指定された文字セットのいずれも許容されない場合、falseを返します。

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

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

リクエストのAccept-Encoding HTTPヘッダーフィールドに基づいて、指定されたエンコーディングの最初の許容されるエンコーディングを返します。指定されたエンコーディングのいずれも許容されない場合、falseを返します。

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

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

リクエストのAccept-Language HTTPヘッダーフィールドに基づいて、指定された言語の最初の許容される言語を返します。指定された言語のいずれも許容されない場合、falseを返します。

lang引数が指定されていない場合、req.acceptsLanguages()はHTTPAccept-Languageヘッダーからすべての言語をArrayとして返します。

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

Express (4.x) ソース: request.js 179行目

Accepts (1.3) ソース: index.js 195行目

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」HTTPヘッダーフィールドがtypeパラメーターで指定されたMIMEタイプと一致する場合、一致するコンテンツタイプを返します。リクエストにボディがない場合はnullを返します。それ以外の場合はfalseを返します。

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

// When Content-Type is application/json
req.is('json')
// => 'json'
req.is('application/json')
// => 'application/json'
req.is('application/*')
// => 'application/*'

req.is('html')
// => false

詳細情報、または問題や懸念事項がある場合は、type-isを参照してください。

req.param(name [, defaultValue])

存在する場合、パラメーター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.range(size[, options])

Rangeヘッダーパーサー。

sizeパラメーターは、リソースの最大サイズです。

optionsパラメーターは、次のプロパティを持つオブジェクトです。

範囲の配列が返されるか、エラーの解析を示す負の数が返されます。

• -2は不正なヘッダー文字列を示します。
• -1は満たせない範囲を示します。

// parse header from request
var range = req.range(1000)

// the type of the range
if (range.type === 'bytes') {
  // the ranges
  range.forEach(function (r) {
    // do something with r.start and r.end
  })
}

res.app

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

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

res.headersSent

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

app.get('/', function (req, res) {
  console.dir(res.headersSent) // false
  res.send('OK')
  console.dir(res.headersSent) // true
})

res.locals

res.renderでレンダリングされたテンプレートでアクセス可能な変数を設定するために使用します。res.localsに設定された変数は、単一のリクエスト・レスポンスサイクル内で使用可能であり、リクエスト間で共有されません。

テンプレートレンダリングで使用するローカル変数をリクエスト間で保持するには、代わりにapp.localsを使用します。

このプロパティは、リクエストレベルの情報（リクエストパス名、認証済みユーザー、ユーザー設定など）をアプリケーション内でレンダリングされたテンプレートに公開する場合に役立ちます。

app.use(function (req, res, next) {
  // Make `user` and `authenticated` available in templates
  res.locals.user = req.user
  res.locals.authenticated = !req.user.anonymous
  next()
})

res.append(field [, value])

指定されたvalueをHTTPレスポンスヘッダーfieldに追加します。ヘッダーがまだ設定されていない場合は、指定された値でヘッダーを作成します。valueパラメーターは、文字列または配列にすることができます。

注: res.append()の後にres.set()を呼び出すと、以前に設定されたヘッダー値がリセットされます。

res.append('Link', ['<https://127.0.0.1/>', '<https://127.0.0.1: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=" パラメーターを設定します。

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])

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

optionsパラメーターは、次のプロパティを持つオブジェクトです。

例

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

res.cookieを複数回呼び出すことで、単一のレスポンスで複数のCookieを設定できます。例：

res
  .status(201)
  .cookie('access_token', 'Bearer ' + token, {
    expires: new Date(Date.now() + 8 * 3600000) // cookie will be removed after 8 hours
  })
  .cookie('test', 'test')
  .redirect(301, '/admin')

encodeオプションを使用すると、Cookie値のエンコードに使用される関数を選択できます。非同期関数はサポートされていません。

使用例：組織内の別のサイト用にドメイン全体のCookieを設定する必要があります。この別のサイト（管理下にない）は、URIエンコードされたCookie値を使用しません。

// Default encoding
res.cookie('some_cross_domain_cookie', 'http://mysubdomain.example.com', { domain: 'example.com' })
// Result: 'some_cross_domain_cookie=http%3A%2F%2Fmysubdomain.example.com; Domain=example.com; Path=/'

// Custom encoding
res.cookie('some_cross_domain_cookie', 'http://mysubdomain.example.com', { domain: 'example.com', encode: String })
// Result: 'some_cross_domain_cookie=http://mysubdomain.example.com; Domain=example.com; Path=/;'

maxAgeオプションは、現在の時刻を基準としたミリ秒単位で "expires" を設定するための便利なオプションです。以下は、上記の2番目の例と同等です。

res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })

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

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

cookie-parserミドルウェアを使用する場合、このメソッドは署名付きCookieもサポートします。signedオプションをtrueに設定するだけで済みます。その後、res.cookie()はcookieParser(secret)に渡されたシークレットを使用して値に署名します。

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

後で、req.signedCookieオブジェクトを使用してこの値にアクセスできます。

res.clearCookie(name [, options])

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

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

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

pathのファイルを "attachment" として転送します。通常、ブラウザはユーザーにダウンロードを促します。デフォルトでは、Content-Dispositionヘッダーの "filename=" パラメーターはpath引数から取得されますが、filenameパラメーターでオーバーライドできます。pathが相対パスである場合、プロセスの現在の作業ディレクトリ、または提供されている場合はrootオプションに基づきます。

次の表は、optionsパラメーターの詳細を示しています。

転送が完了した場合、またはエラーが発生した場合に、メソッドはコールバック関数fn(err)を呼び出します。コールバック関数が指定されていてエラーが発生した場合、コールバック関数は、リクエスト・レスポンスサイクルを終了するか、次のルートに制御を渡すことで、レスポンスプロセスを明示的に処理する必要があります。

res.download('/report-12345.pdf')

res.download('/report-12345.pdf', 'report.pdf')

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

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

レスポンスプロセスを終了します。このメソッドは実際にはNodeコア、具体的にはhttp.ServerResponseのresponse.end()メソッドから来ています。

データなしでレスポンスをすばやく終了するために使用します。データ付きでレスポンスする必要がある場合は、代わりにres.send()やres.json()などのメソッドを使用してください。

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

res.format(object)

存在する場合、リクエストオブジェクトのAccept HTTPヘッダーでコンテンツネゴシエーションを実行します。品質値で順序付けられた許容可能なタイプに基づいて、リクエストのハンドラーを選択するためにreq.accepts()を使用します。ヘッダーが指定されていない場合は、最初のコールバックが呼び出されます。一致が見つからない場合、サーバーは406 "Not Acceptable" で応答するか、defaultコールバックを呼び出します。

コールバックが選択されると、Content-Typeレスポンスヘッダーが設定されます。ただし、res.set()やres.type()などのメソッドを使用して、コールバック内で変更できます。

次の例は、Acceptヘッダーフィールドが "application/json" または "*/json" に設定されている場合（ただし "*/ *" の場合は "hey" がレスポンスされます）、{ "message": "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 () {
    // log the request and respond with 406
    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レスポンスを送信します。このメソッドは、JSON.stringify()を使用してパラメーターをJSON文字列に変換したレスポンス（正しいコンテンツタイプ付き）を送信します。

パラメーターはオブジェクト、配列、文字列、ブール値、数値、nullを含む任意のJSONタイプにすることができ、他の値をJSONに変換するためにも使用できます。

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

res.jsonp([body])

JSONPサポート付きのJSONレスポンスを送信します。このメソッドはres.json()と同一ですが、JSONPコールバックサポートをオプトインします。

res.jsonp(null)
// => callback(null)

res.jsonp({ user: 'tobi' })
// => callback({ "user": "tobi" })

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

デフォルトでは、JSONPコールバック名は単にcallbackです。jsonpコールバック名設定でこれをオーバーライドします。

同じコードを使用したJSONPレスポンスの例をいくつか示します。

// ?callback=foo
res.jsonp({ user: 'tobi' })
// => foo({ "user": "tobi" })

app.set('jsonp callback name', 'cb')

// ?cb=foo
res.status(500).jsonp({ error: 'message' })
// => foo({ "error": "message" })

res.links(links)

パラメーターのプロパティとして提供されたlinksを結合して、レスポンスのLink HTTPヘッダーフィールドを設定します。

たとえば、次の呼び出し：

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

次の結果が得られます。

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

res.location(path)

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

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

"back" のpath値には特別な意味があり、リクエストのRefererヘッダーで指定されたURLを参照します。Refererヘッダーが指定されていない場合は "/" を参照します。

res.redirect([status,] path)

指定されたpathから導出されたURLに、指定されたstatus（HTTPステータスコードに対応する正の整数）でリダイレクトします。指定しない場合、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')

リダイレクトは、ホスト名のルートを基準にすることができます。たとえば、アプリケーションがhttp://example.com/admin/post/newにある場合、以下はhttp://example.com/adminにリダイレクトします。

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])

viewをレンダリングし、レンダリングされたHTML文字列をクライアントに送信します。オプションのパラメーター：

• locals、そのプロパティがビューのローカル変数を定義するオブジェクト。
• callbackはコールバック関数です。指定された場合、このメソッドは発生しうるエラーとレンダリングされた文字列の両方を返しますが、自動応答は実行しません。エラーが発生すると、メソッドは内部的にnext(err)を呼び出します。

view引数は、レンダリングするビューファイルのファイルパスを表す文字列です。これは絶対パスでも、views設定に対する相対パスでも構いません。パスにファイル拡張子が含まれていない場合、view engine設定によってファイル拡張子が決定されます。パスにファイル拡張子が含まれている場合、Expressは指定されたテンプレートエンジンのモジュールを（require()を使用して）ロードし、ロードされたモジュールの__express関数を使用してレンダリングします。

詳細については、「Expressでのテンプレートエンジンの使用」を参照してください。

// send the rendered view to the client
res.render('index')

// if a callback is specified, the rendered 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.req

res.send([body])

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

bodyパラメータは、Bufferオブジェクト、String、オブジェクト、Boolean、またはArrayにすることができます。例：

res.send(Buffer.from('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-Length HTTPレスポンスヘッダーフィールドを自動的に割り当て（事前に定義されていない場合）、自動的なHEADとHTTPキャッシュの鮮度サポートを提供します。

パラメータがBufferオブジェクトの場合、このメソッドは、事前に定義されていない限り、Content-Typeレスポンスヘッダーフィールドを「application/octet-stream」に設定します（下記参照）。

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

パラメータがStringの場合、このメソッドはContent-Typeを「text/html」に設定します。

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

パラメータがArrayまたはObjectの場合、ExpressはJSON表現で応答します。

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

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

指定されたpathのファイルを転送します。ファイル名の拡張子に基づいて、Content-TypeレスポンスHTTPヘッダーフィールドを設定します。optionsオブジェクトにrootオプションが設定されていない限り、pathはファイルへの絶対パスである必要があります。

次の表は、optionsパラメーターの詳細を示しています。

転送が完了した場合、またはエラーが発生した場合に、メソッドはコールバック関数fn(err)を呼び出します。コールバック関数が指定されていてエラーが発生した場合、コールバック関数は、リクエスト・レスポンスサイクルを終了するか、次のルートに制御を渡すことで、レスポンスプロセスを明示的に処理する必要があります。

すべての引数を用いたres.sendFileの使用方法の例を以下に示します。

app.get('/file/:name', function (req, res, next) {
  var options = {
    root: path.join(__dirname, 'public'),
    dotfiles: 'deny',
    headers: {
      'x-timestamp': Date.now(),
      'x-sent': true
    }
  }

  var fileName = req.params.name
  res.sendFile(fileName, options, function (err) {
    if (err) {
      next(err)
    } else {
      console.log('Sent:', fileName)
    }
  })
})

次の例は、res.sendFileを使用して、ファイルの提供に対するきめ細かいサポートを提供する方法を示しています。

app.get('/user/:uid/photos/:file', function (req, res) {
  var uid = req.params.uid
  var file = req.params.file

  req.user.mayViewFilesFrom(uid, function (yes) {
    if (yes) {
      res.sendFile('/uploads/' + uid + '/' + file)
    } else {
      res.status(403).send("Sorry! You can't see that.")
    }
  })
})

詳細情報、または問題や懸念事項については、sendを参照してください。

res.sendStatus(statusCode)

レスポンスのHTTPステータスコードをstatusCodeに設定し、登録されたステータスメッセージをテキストレスポンスボディとして送信します。不明なステータスコードが指定された場合、レスポンスボディはコード番号のみになります。

res.sendStatus(404)

HTTPステータスコードの詳細

res.set(field [, value])

レスポンスのHTTPヘッダーfieldをvalueに設定します。複数のフィールドを一度に設定するには、オブジェクトをパラメータとして渡します。

res.set('Content-Type', 'text/plain')

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

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)

指定されたtypeによって決定されたMIMEタイプにContent-Type HTTPヘッダーを設定します。typeに「/」文字が含まれている場合、Content-Typeはtypeの正確な値に設定されます。そうでない場合は、ファイル拡張子とみなされ、express.static.mime.lookup()メソッドを使用してMIMEタイプがマッピングで検索されます。

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レスポンスヘッダーにフィールドを追加します。

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

routerオブジェクトは、ミドルウェアとルートの分離されたインスタンスです。これは、ミドルウェアとルーティング機能のみを実行できる「ミニアプリケーション」と考えることができます。すべてのExpressアプリケーションには、組み込みのアプリルーターがあります。

ルーター自体はミドルウェアのように動作するため、app.use()の引数として、または別のルーターのuse()メソッドの引数として使用できます。

最上位のexpressオブジェクトには、新しいrouterオブジェクトを作成する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)

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はGET、PUT、POSTなどのHTTPメソッドのいずれか（小文字）です。したがって、実際のメソッドはrouter.get()、router.post()、router.put()などです。

複数のコールバックを提供でき、すべてが平等に扱われ、ミドルウェアと同様に動作しますが、これらのコールバックは残りのルートコールバックをバイパスするためにnext('route')を呼び出すことができます。このメカニズムを使用して、ルートの前提条件を実行し、ルートの一致を進める理由がない場合に後続のルートに制御を渡すことができます。

次のスニペットは、可能な限り最も単純なルート定義を示しています。Expressはパス文字列を正規表現に変換し、内部的に着信リクエストの一致に使用します。これらのマッチングを実行する際にはクエリ文字列は考慮されません。たとえば、「GET /」は次のルートと一致します。「GET /?name=tobi」も同様です。

router.get('/', function (req, res) {
  res.send('hello world')
})

正規表現を使用することもできます。これは、非常に具体的な制約がある場合に便利です。たとえば、次の例は「GET /commits/71dbb9c」と「GET /commits/71dbb9c..4c084f9」の両方に一致します。

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

router.param(name, callback)

ルートパラメータにコールバックトリガーを追加します。ここで、nameはパラメータの名前、callbackはコールバック関数です。技術的にはnameはオプションですが、これなしでこのメソッドを使用することは、Express v4.11.0以降では非推奨になっています（下記参照）。

コールバック関数の引数は次のとおりです。

• req、リクエストオブジェクト。
• res、レスポンスオブジェクト。
• next、次のミドルウェア関数を示します。
• nameパラメータの値。
• パラメータの名前。

例えば、:userがルートパスに存在する場合、ユーザー読み込みロジックをマップしてルートにreq.userを自動的に提供したり、パラメータ入力の検証を実行したりできます。

router.param('user', function (req, res, next, id) {
  // try to get the user details from the User model and attach it to the request object
  User.find(id, function (err, user) {
    if (err) {
      next(err)
    } else if (user) {
      req.user = user
      next()
    } else {
      next(new Error('failed to load user'))
    }
  })
})

パラメータコールバック関数は、定義されているルーターにローカルです。マウントされたアプリやルーターには継承されません。したがって、routerで定義されたパラメータコールバックは、routerルートで定義されたルートパラメータによってのみトリガーされます。

パラメータコールバックは、リクエストレスポンスサイクルで一度だけ呼び出されます。パラメータが複数のルートで一致した場合でも、次の例に示すようにです。

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 matches too')
  res.end()
})

GET /user/42では、以下が出力されます。

CALLED ONLY ONCE
although this matches
and this matches too

router.param(name, callback)メソッドの動作は、router.param()に関数のみを渡すことで完全に変更できます。この関数は、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()

// customizing the behavior of router.param()
router.param(function (param, option) {
  return function (req, res, next, val) {
    if (val === option) {
      next()
    } else {
      res.sendStatus(403)
    }
  }
})

// using the customized router.param()
router.param('id', '1337')

// route to trigger the capture
router.get('/user/:id', function (req, res) {
  res.send('OK')
})

app.use(router)

app.listen(3000, function () {
  console.log('Ready')
})

この例では、router.param(name, callback)シグネチャは同じままですが、ミドルウェアコールバックではなく、ユーザー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.param()の例に基づいて、次のコードは、さまざまな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'))
  })

このアプローチでは、単一の/users/:user_idパスを再利用し、さまざまなHTTPメソッドのハンドラーを追加します。

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

オプションのマウントパス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 from the mount point
router.use('/bar', function (req, res, next) {
  // ... maybe some additional /bar logging ...
  next()
})

// always invoked
router.use(function (req, res, next) {
  res.send('Hello World')
})

app.use('/foo', router)

app.listen(3000)

「マウント」パスは削除され、ミドルウェア関数には表示されません。この機能の主な効果は、マウントされたミドルウェア関数が、「プレフィックス」パス名に関係なく、コード変更なしで動作できることです。

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

var logger = require('morgan')
var path = require('path')

router.use(logger())
router.use(express.static(path.join(__dirname, 'public')))
router.use(function (req, res) {
  res.send('Hello')
})

静的ファイルのリクエストのログを無視し、logger()の後で定義されたルートとミドルウェアのログを継続的に記録したいとします。ロガーミドルウェアを追加する前に、express.static()の呼び出しを先頭に移動するだけです。

router.use(express.static(path.join(__dirname, 'public')))
router.use(logger())
router.use(function (req, res) {
  res.send('Hello')
})

別の例として、複数のディレクトリからファイルを配信し、「./public」を他のディレクトリよりも優先順位を高く設定します。

router.use(express.static(path.join(__dirname, 'public')))
router.use(express.static(path.join(__dirname, 'files')))
router.use(express.static(path.join(__dirname, 'uploads')))

router.use()メソッドは、名前付きパラメータもサポートしているため、他のルーターのマウントポイントが名前付きパラメータを使用してプリロードの恩恵を受けることができます。

注：これらのミドルウェア関数は特定のルーターを介して追加されますが、実行されるタイミングは、アタッチされているパス（ルーターではありません）によって定義されます。したがって、あるルーターを介して追加されたミドルウェアは、そのルートが一致する場合、他のルーターに対しても実行される可能性があります。たとえば、このコードは、同じパスにマウントされた2つの異なるルーターを示しています。

var authRouter = express.Router()
var openRouter = express.Router()

authRouter.use(require('./authenticate').basic(usersdb))

authRouter.get('/:user_id/edit', function (req, res, next) {
  // ... Edit user UI ...
})
openRouter.get('/', function (req, res, next) {
  // ... List users ...
})
openRouter.get('/:user_id', function (req, res, next) {
  // ... View user ...
})

app.use('/users', authRouter)
app.use('/users', openRouter)

認証ミドルウェアはauthRouterを介して追加されましたが、両方のルーターが/usersにマウントされているため、openRouterで定義されたルートでも実行されます。この動作を回避するには、各ルーターに異なるパスを使用してください。