5.x API

express.json([options])

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

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

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

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

express.static(root, [options])

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

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

次の表は、options オブジェクトのプロパティについて説明しています。以下の例も参照してください。

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

dotfiles

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

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

fallthrough

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

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

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

setHeaders

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

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

fn(res, path, stat)

引数

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

express.static の例

express.static ミドルウェア関数を精巧なオプションオブジェクトとともに使用する例を次に示します

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

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

express.Router([options])

新しい ルータ オブジェクトを作成します。

const router = express.Router([options])

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

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

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

express.urlencoded([options])

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

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

解析されたデータを含む新しい body オブジェクトは、ミドルウェアの後 (つまり req.body) に request オブジェクトに設定されます。解析する 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 つ以上のパスパターンが含まれています。

const express = require('express')

const app = express() // the main app
const admin = express() // the sub app

admin.get('/', (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 は、次の例に示すように、マウントされているパターンのリストを返します。

const admin = express()

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

const secret = express()
secret.get('/', (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.router

アプリケーションに組み込まれた router のインスタンス。これは、最初のアクセス時に遅延的に作成されます。

const express = require('express')
const app = express()
const router = app.router

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

app.listen(3000)

アプリケーションと同じように、router にミドルウェアと HTTP メソッドルートを追加できます。

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

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

mount イベントは、サブアプリが親アプリにマウントされたときに、サブアプリで発生します。親アプリはコールバック関数に渡されます。

const admin = express()

admin.on('mount', (parent) => {
  console.log('Admin Mounted')
  console.log(parent) // refers to the parent app
})

admin.get('/', (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', (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('/', (req, res) => {
  res.send('DELETE request to homepage')
})

app.disable(name)

ブール値の設定 name を false に設定します。ここで、name は アプリ設定テーブル のプロパティの 1 つです。ブール値のプロパティに対して app.set('foo', false) を呼び出すことは、app.disable('foo') を呼び出すことと同じです。

例えば

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

app.disabled(name)

ブール値の設定 name が無効 (false) になっている場合、true を返します。ここで、name は アプリ設定テーブル のプロパティの 1 つです。

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

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

app.enable(name)

ブール値の設定 name を true に設定します。ここで、name は アプリ設定テーブル のプロパティの 1 つです。ブール値のプロパティに対して app.set('foo', true) を呼び出すことは、app.enable('foo') を呼び出すことと同じです。

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

app.enabled(name)

設定 name が有効 (true) になっている場合、true を返します。ここで、name は アプリ設定テーブル のプロパティの 1 つです。

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 が予期するのと同じシグネチャ (path, options, callback) を持つ .renderFile() メソッドを提供しますが、このメソッドは内部で ejs.__express としてエイリアスされているため、「.ejs」拡張子を使用している場合は何もする必要はありません。

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

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

app.get(name)

name アプリ設定の値を返します。ここで、name は アプリ設定テーブル の文字列の 1 つです。例えば

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

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

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

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

引数

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

例

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

app.listen(path, [callback])

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

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

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

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

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

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

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

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

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

app.listen() メソッドは、http.Server オブジェクトを返し (HTTP の場合)、以下の便利なメソッドです。

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

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

HTTP リクエストをルーティングします。ここで、METHOD は、GET、PUT、POST など、リクエストの HTTP メソッドを小文字で表します。したがって、実際のメソッドは 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', (req, res, next, id) => {
  // try to get the user details from the User model and attach it to the request object
  User.find(id, (err, user) => {
    if (err) {
      next(err)
    } else if (user) {
      req.user = user
      next()
    } else {
      next(new Error('failed to load user'))
    }
  })
})

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

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

app.param('id', (req, res, next, id) => {
  console.log('CALLED ONLY ONCE')
  next()
})

app.get('/user/:id', (req, res, next) => {
  console.log('although this matches')
  next()
})

app.get('/user/:id', (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'], (req, res, next, value) => {
  console.log('CALLED ONLY ONCE with', value)
  next()
})

app.get('/user/:id/:page', (req, res, next) => {
  console.log('although this matches')
  next()
})

app.get('/user/:id/:page', (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.path()

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

const app = express()
const blog = express()
const blogAdmin = express()

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

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

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

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

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

引数

例

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

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

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

引数

例

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

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

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

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

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

app.route(path)

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

const app = express()

app.route('/events')
  .all((req, res, next) => {
    // runs for all HTTP verbs first
    // think of it as route specific middleware!
  })
  .get((req, res, next) => {
    res.json({})
  })
  .post((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', (ip) => {
  if (ip === '127.0.0.1' || ip === '123.123.123.123') return true // trusted IPs
  else return false
})

app.set('etag', (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((req, res, next) => {
  console.log('Time: %d', Date.now())
  next()
})

ミドルウェア関数は順番に実行されるため、ミドルウェアをインクルードする順序が重要です。

// this middleware will not allow the request to go beyond it
app.use((req, res, next) => {
  res.send('Hello World')
})

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

エラー処理ミドルウェア

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

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

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

パスの例

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

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

app.use('/ab(c?)d', (req, res, next) => {
  next()
})

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

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

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

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

app.use((req, res, next) => {
  next()
})

const router = express.Router()
router.get('/', (req, res, next) => {
  next()
})
app.use(router)

const subApp = express()
subApp.get('/', (req, res, next) => {
  next()
})
app.use(subApp)

const r1 = express.Router()
r1.get('/', (req, res, next) => {
  next()
})

const r2 = express.Router()
r2.get('/', (req, res, next) => {
  next()
})

app.use(r1, r2)

const r1 = express.Router()
r1.get('/', (req, res, next) => {
  next()
})

const r2 = express.Router()
r2.get('/', (req, res, next) => {
  next()
})

app.use([r1, r2])

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

const r1 = express.Router()
r1.get('/', (req, res, next) => { next() })

const r2 = express.Router()
r2.get('/', (req, res, next) => { next() })

const subApp = express()
subApp.get('/', (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 = (req, res) => {
  res.send(`The views directory is ${req.app.get('views')}`)
}

req.baseUrl

ルーターインスタンスがマウントされたURLパスです。

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

例えば

const greet = express.Router()

greet.get('/jp', (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で、body-parserやmulterなどのボディ解析ミドルウェアを使用すると設定されます。

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

const app = require('express')()
const bodyParser = require('body-parser')
const multer = require('multer') // v1.0.5
const 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(), (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キャッシュ仕様を参照してください。

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

req.host

Host HTTPヘッダーから派生したホストが含まれています。

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

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

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

// Host: "[::1]:3000"
console.dir(req.host)
// => '[::1]:3000'

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の組み合わせです。次の例を考えてみましょう。

// GET 'http://www.example.com/admin/new?sort=desc'
app.use('/admin', (req, res, next) => {
  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番目のキャプチャグループです。このルールは、/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を設定するためにデフォルトとは異なる設定を使用することが望ましい場合があります。

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

他のカスタマイズオプションについては、クエリパーサーアプリケーション設定のドキュメントをご覧ください。

req.res

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

req.route

現在一致しているルート（文字列）が含まれています。例えば

app.get('/user/:id?', (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となるブール型プロパティです。以下と同等です。

req.protocol === 'https'

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」など）、カンマ区切りのリスト、または配列 olabilir。リストまたは配列の場合、メソッドは*最適な*一致（存在する場合）を返します。

// 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を返します。

詳細については、または問題や懸念がある場合は、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」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.range(size[, options])

Rangeヘッダーパーサー。

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

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

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

• -2は、ヘッダー文字列の形式が正しくないことを示します。
• -1は、満たせない範囲を示します。

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

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

res.app

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

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

res.headersSent

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

app.get('/', (req, res) => {
  console.log(res.headersSent) // false
  res.send('OK')
  console.log(res.headersSent) // true
})

res.locals

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

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

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

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

res.req

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

res.append(field [, value])

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

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

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

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

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.signedCookiesオブジェクトを介してこの値にアクセスできます。

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にあるファイルを「添付ファイル」として転送します。通常、ブラウザはユーザーにダウンロードを促します。デフォルトでは、Content-Dispositionヘッダーの「filename =」パラメータはpath引数から派生しますが、filenameパラメータでオーバーライドできます。pathが相対パスの場合、プロセスの現在の作業ディレクトリに基づいています。

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

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

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

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

res.download('/report-12345.pdf', 'report.pdf', (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” に設定されている場合、{ "message": "hey" } で応答します（ただし、”*/*” の場合は、レスポンスは “hey” になります）。

res.format({
  'text/plain' () {
    res.send('hey')
  },

  'text/html' () {
    res.send('<p>hey</p>')
  },

  'application/json' () {
    res.send({ message: 'hey' })
  },

  default () {
    // log the request and respond with 406
    res.status(406).send('Not Acceptable')
  }
})

正規化された MIME タイプに加えて、これらのタイプにマップされた拡張子を使用して、少し冗長性を減らした実装を行うこともできます。

res.format({
  text () {
    res.send('hey')
  },

  html () {
    res.send('<p>hey</p>')
  },

  json () {
    res.send({ message: 'hey' })
  }
})

res.get(field)

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

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

res.json([body])

JSON レスポンスを送信します。このメソッドは、パラメータを JSON.stringify() を使用して JSON 文字列に変換したレスポンス（正しい content-type を使用）を送信します。

パラメータは、オブジェクト、配列、文字列、ブール値、数値、または 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 callback name 設定でこれをオーバーライドします。

以下は、同じコードを使用した 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')

path 値が “back” の場合は特別な意味を持ち、リクエストの 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 にある場合、以下は URL http://example.com/admin にリダイレクトします。

res.redirect('/admin')

リダイレクトは、現在の URL からの相対パスにすることができます。たとえば、http://example.com/blog/admin/（末尾のスラッシュに注意）からは、以下は URL 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 でのテンプレートエンジンの使用 を参照してください。

**注意：** view 引数は、ディスクからファイルを読み取ったり、Node.js モジュールを評価したりするなど、ファイルシステム操作を実行するため、セキュリティ上の理由からエンドユーザーからの入力を含めてはなりません。

// 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', (err, html) => {
  res.send(html)
})

// pass a local variable to the view
res.render('user', { name: 'Tobi' }, (err, html) => {
  // ...
})

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 キャッシュ freshness サポートを提供します。

パラメータが 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', (req, res, next) => {
  const options = {
    root: path.join(__dirname, 'public'),
    dotfiles: 'deny',
    headers: {
      'x-timestamp': Date.now(),
      'x-sent': true
    }
  }

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

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

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

  req.user.mayViewFilesFrom(uid, (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)

Content-Type HTTP ヘッダーを、指定された type によって決定される MIME タイプに設定します。 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((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', (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)

このもう1つの例は、ホワイトリストに登録された「グローバル」機能です。ここでの例は以前とほぼ同じですが、「/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('/', (req, res) => {
  res.send('hello world')
})

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

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

next プリミティブを使用して、特定のプログラム状態に基づいて、異なるミドルウェア関数間のフロー制御を実装できます。文字列 'router' を指定して next を呼び出すと、そのルーターの残りのすべてのルートコールバックがバイパスされます。

次の例は、next('router') の使用方法を示しています。

function fn (req, res, next) {
  console.log('I come here')
  next('router')
}
router.get('/foo', fn, (req, res, next) => {
  console.log('I dont come here')
})
router.get('/foo', (req, res, next) => {
  console.log('I dont come here')
})
app.get('/foo', (req, res) => {
  console.log(' I come here too')
  res.end('good')
})

router.param(name, callback)

ルートパラメータにコールバックトリガーを追加します。ここで、name はパラメータの名前、callback はコールバック関数です。name は技術的には省略可能ですが、Express v4.11.0 以降、このメソッドを指定せずに使用することは非推奨です（以下を参照）。

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

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

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

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

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

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

router.param('id', (req, res, next, id) => {
  console.log('CALLED ONLY ONCE')
  next()
})

router.get('/user/:id', (req, res, next) => {
  console.log('although this matches')
  next()
})

router.get('/user/:id', (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() は名前と数値を受け入れるようになりました。

const express = require('express')
const app = express()
const router = express.Router()

// customizing the behavior of router.param()
router.param((param, option) => {
  return (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', (req, res) => {
  res.send('OK')
})

app.use(router)

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

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

router.param((param, validator) => {
  return (req, res, next, val) => {
    if (validator(val)) {
      next()
    } else {
      res.sendStatus(403)
    }
  }
})

router.param('id', (candidate) => {
  return !isNaN(parseFloat(candidate)) && isFinite(candidate)
})

router.route(path)

単一のルートのインスタンスを返します。これを使用して、オプションのミドルウェアを使用して HTTP 動詞を処理できます。router.route() を使用すると、ルート名の重複、ひいては入力ミスを防ぐことができます。

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

const router = express.Router()

router.param('user_id', (req, res, next, id) => {
  // sample user, would actually fetch from DB, etc...
  req.user = {
    id,
    name: 'TJ'
  }
  next()
})

router.route('/users/:user_id')
  .all((req, res, next) => {
  // runs for all HTTP verbs first
  // think of it as route specific middleware!
    next()
  })
  .get((req, res, next) => {
    res.json(req.user)
  })
  .put((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((req, res, next) => {
    next(new Error('not implemented'))
  })
  .delete((req, res, next) => {
    next(new Error('not implemented'))
  })

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

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

指定されたミドルウェア関数（複数可）を使用します。オプションのマウントパス path はデフォルトで「/」です。

このメソッドは app.use() に似ています。簡単な例とユースケースを以下に示します。詳細については、app.use() を参照してください。

ミドルウェアは配管パイプのようなものです。リクエストは定義された最初のミドルウェア関数から始まり、ミドルウェアスタックを「下って」処理され、一致するパスごとに処理されます。

const express = require('express')
const app = express()
const router = express.Router()

// simple logger for this router's requests
// all requests to this router will first hit this middleware
router.use((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', (req, res, next) => {
  // ... maybe some additional /bar logging ...
  next()
})

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

app.use('/foo', router)

app.listen(3000)

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

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

const logger = require('morgan')

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

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

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

別の例として、複数のディレクトリからファイルを提供し、「./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')))

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

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

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

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

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

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

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