HTTP

[Stable: 2 - Stable]

ソースコード: lib/http.js

このモジュールは、クライアントとサーバーの両方を含み、require('node:http') (CommonJS) または import * as http from 'node:http' (ES モジュール) でインポートできます。

Node.js の HTTP インターフェースは、従来使いにくかったプロトコルの多くの機能をサポートするように設計されています。特に、大きな、おそらくチャンクエンコードされたメッセージです。インターフェースは、リクエストやレスポンス全体をバッファリングしないように注意されており、ユーザーはデータをストリーミングできます。

HTTP メッセージヘッダーは、次のようなオブジェクトで表されます。

json

{
  "content-length": "123",
  "content-type": "text/plain",
  "connection": "keep-alive",
  "host": "example.com",
  "accept": "*/*"
}

キーは小文字です。値は変更されません。

可能な HTTP アプリケーションの全範囲をサポートするために、Node.js HTTP API は非常に低レベルです。ストリーム処理とメッセージ解析のみを扱います。メッセージをヘッダーとボディに解析しますが、実際のヘッダーやボディを解析しません。

重複ヘッダーの処理方法の詳細については、message.headers を参照してください。

受信したとおりの生のヘッダーは、rawHeaders プロパティに保持されます。これは [key, value, key2, value2, ...] の配列です。たとえば、前のメッセージヘッダーオブジェクトには、次のような rawHeaders リストがある場合があります。

;[
  'ConTent-Length',
  '123456',
  'content-LENGTH',
  '123',
  'content-type',
  'text/plain',
  'CONNECTION',
  'keep-alive',
  'Host',
  'example.com',
  'accepT',
  '*/*',
]

クラス: `http.Agent`

追加: v0.3.4

Agent は、HTTP クライアントの接続の永続性と再利用を管理する役割を担います。指定されたホストとポートの保留中のリクエストのキューを維持し、キューが空になるまで、各リクエストに対して単一のソケット接続を再利用します。その後、ソケットは破棄されるか、同じホストとポートへのリクエストに再び使用されるようにプールに入れられます。破棄されるかプールされるかは、keepAlive オプションによって異なります。

プールされた接続では TCP Keep-Alive が有効になっていますが、サーバーはアイドル状態の接続を閉じることがあります。その場合、プールから削除され、そのホストとポートへの新しい HTTP リクエストが行われると、新しい接続が作成されます。サーバーは、同じ接続で複数のリクエストを許可することを拒否することもできます。その場合、接続はリクエストごとに再作成する必要があり、プールすることはできません。Agent は、そのサーバーへのリクエストを続行しますが、それぞれが新しい接続で行われます。

クライアントまたはサーバーによって接続が閉じられると、プールから削除されます。プール内の未使用のソケットは、未処理のリクエストがない場合に Node.js プロセスを実行し続けないように、アンレフされます（socket.unref() を参照）。

未使用のソケットは OS リソースを消費するため、Agent インスタンスを使用しなくなった場合は、destroy() するのが良い習慣です。

ソケットは、ソケットが 'close' イベントまたは 'agentRemove' イベントのいずれかを発生させると、エージェントから削除されます。1 つの HTTP リクエストをエージェントに保持せずに長時間開いたままにする場合は、次のようなことを行うことができます。

http
  .get(options, res => {
    // 何かをする
  })
  .on('socket', socket => {
    socket.emit('agentRemove')
  })

エージェントは、個々のリクエストにも使用できます。http.get() または http.request() 関数へのオプションとして {agent: false} を指定すると、デフォルトオプションの 1 回限りの Agent がクライアント接続に使用されます。

agent:false:

http.get(
  {
    hostname: 'localhost',
    port: 80,
    path: '/',
    agent: false, // この 1 つのリクエスト専用に新しいエージェントを作成
  },
  res => {
    // レスポンスで何かをする
  }
)

`new Agent([options])`

[履歴]

バージョン	変更点
v15.6.0, v14.17.0	デフォルトのスケジューリングを 'fifo' から 'lifo' に変更。
v14.5.0, v12.20.0	フリーソケットのスケジューリング戦略を指定する `scheduling` オプションを追加。
v14.5.0, v12.19.0	エージェントコンストラクターに `maxTotalSockets` オプションを追加。
v0.3.4	v0.3.4 で追加。

options <Object> エージェントに設定する設定可能なオプションのセット。以下のフィールドを持つことができます。
- keepAlive <boolean> 未処理のリクエストがない場合でもソケットを保持し、TCP 接続を再確立することなく将来のリクエストに使用できるようにします。Connection ヘッダーの keep-alive 値と混同しないでください。Connection ヘッダーが明示的に指定されている場合、または keepAlive および maxSockets オプションがそれぞれ false および Infinity に設定されている場合を除き、エージェントを使用するときは常に Connection: keep-alive ヘッダーが送信されます。この場合、Connection: close が使用されます。デフォルト: false。
- keepAliveMsecs <number> keepAlive オプションを使用する場合、TCP Keep-Alive パケットの初期遅延を指定します。keepAlive オプションが false または undefined の場合は無視されます。デフォルト: 1000。
- maxSockets <number> ホストごとに許可するソケットの最大数。同じホストが複数の同時接続を開く場合、maxSockets 値に達するまで、各リクエストは新しいソケットを使用します。ホストが maxSockets より多くの接続を開こうとすると、追加のリクエストは保留中のリクエストキューに入り、既存の接続が終了するとアクティブな接続状態になります。これにより、特定のホストから、常に最大で maxSockets のアクティブな接続があることが保証されます。デフォルト: Infinity。
- maxTotalSockets <number> すべてのホストで許可されるソケットの最大総数。最大値に達するまで、各リクエストは新しいソケットを使用します。デフォルト: Infinity。
- maxFreeSockets <number> フリー状態で開いたままにするホストごとのソケットの最大数。keepAlive が true に設定されている場合にのみ関連します。デフォルト: 256。
- scheduling <string> 使用する次のフリーソケットを選択するときに適用するスケジューリング戦略。 'fifo' または 'lifo' を指定できます。2 つのスケジューリング戦略の主な違いは、'lifo' が最後に使用されたソケットを選択するのに対し、'fifo' は最後に使用されたソケットを選択することです。1 秒あたりのリクエストレートが低い場合、'lifo' スケジューリングは、非アクティブのためにサーバーによって閉じられた可能性のあるソケットを選択するリスクを低減します。1 秒あたりのリクエストレートが高い場合、'fifo' スケジューリングは開いているソケットの数を最大化しますが、'lifo' スケジューリングは可能な限り低く保ちます。デフォルト: 'lifo'。
- timeout <number> ソケットのタイムアウト（ミリ秒単位）。これにより、ソケットが作成されるときにタイムアウトが設定されます。

socket.connect() の options もサポートされています。

いずれかを設定するには、カスタム http.Agent インスタンスを作成する必要があります。

ESMCJS

import { Agent, request } from 'node:http'
const keepAliveAgent = new Agent({ keepAlive: true })
options.agent = keepAliveAgent
request(options, onResponseCallback)

const http = require('node:http')
const keepAliveAgent = new http.Agent({ keepAlive: true })
options.agent = keepAliveAgent
http.request(options, onResponseCallback)

`agent.createConnection(options[, callback])`

追加: v0.11.4

options <Object> コネクション詳細を含むオプション。オプションの形式についてはnet.createConnection()を確認してください。
callback <Function> 作成されたソケットを受け取るコールバック関数
戻り値: <stream.Duplex>

HTTP リクエストで使用されるソケット/ストリームを生成します。

デフォルトでは、この関数はnet.createConnection()と同じです。しかし、カスタムエージェントはより高い柔軟性が望ましい場合にこのメソッドをオーバーライドすることができます。

ソケット/ストリームは、この関数からソケット/ストリームを返すか、ソケット/ストリームをcallbackに渡すことの 2 つの方法で提供できます。

このメソッドは、ユーザーが<net.Socket>以外のソケットタイプを指定しない限り、<net.Socket>クラスのインスタンス、つまり<stream.Duplex>のサブクラスを返すことが保証されています。

callbackのシグネチャは(err, stream)です。

`agent.keepSocketAlive(socket)`

追加: v8.1.0

socket <stream.Duplex>

socketがリクエストからデタッチされ、Agentによって保持される可能性がある場合に呼び出されます。デフォルトの動作は次のとおりです。

socket.setKeepAlive(true, this.keepAliveMsecs)
socket.unref()
return true

このメソッドは、特定のAgentサブクラスによってオーバーライドできます。このメソッドが偽の値を返す場合、ソケットは次のリクエストで使用するために保持される代わりに破棄されます。

socket引数は、<net.Socket>のインスタンス、つまり<stream.Duplex>のサブクラスである場合があります。

`agent.reuseSocket(socket, request)`

追加: v8.1.0

socket <stream.Duplex>
request <http.ClientRequest>

keep-alive オプションのために保持された後、socketがrequestにアタッチされるときに呼び出されます。デフォルトの動作は次のとおりです。

socket.ref()

このメソッドは、特定のAgentサブクラスによってオーバーライドできます。

socket引数は、<net.Socket>のインスタンス、つまり<stream.Duplex>のサブクラスである場合があります。

`agent.destroy()`

追加: v0.11.4

エージェントが現在使用しているソケットをすべて破棄します。

通常、これを行う必要はありません。ただし、keepAlive が有効になっているエージェントを使用している場合は、不要になったときにエージェントを明示的にシャットダウンするのが最善です。そうしないと、サーバーが終了するまでソケットが開いたままになる可能性があります。

`agent.freeSockets`

[履歴]

バージョン	変更点
v16.0.0	プロパティが `null` プロトタイプになりました。
v0.11.4	追加: v0.11.4

<Object>

keepAlive が有効になっているときに、エージェントによる使用を現在待機しているソケットの配列を含むオブジェクト。変更しないでください。

freeSockets リスト内のソケットは、'timeout'時に自動的に破棄され、配列から削除されます。

`agent.getName([options])`

[履歴]

バージョン	変更点
v17.7.0, v16.15.0	`options` パラメータがオプションになりました。
v0.11.4	追加: v0.11.4

options <Object> 名前生成の情報を提供するオプションのセット
- host <string> リクエストを送信するサーバーのドメイン名または IP アドレス
- port <number> リモートサーバーのポート
- localAddress <string> リクエスト発行時にネットワーク接続をバインドするローカルインターフェース
- family <integer> これが undefined と等しくない場合、4 または 6 である必要があります。
返り値: <string>

接続を再利用できるかどうかを判断するために、リクエストオプションのセットの一意の名前を取得します。HTTP エージェントの場合、これは host:port:localAddress または host:port:localAddress:family を返します。HTTPS エージェントの場合、名前には、ソケットの再利用性を決定する CA、証明書、暗号、およびその他の HTTPS/TLS 固有のオプションが含まれます。

`agent.maxFreeSockets`

追加: v0.11.7

<number>

デフォルトでは 256 に設定されています。keepAliveが有効になっているエージェントの場合、これは空き状態のままになるソケットの最大数を設定します。

`agent.maxSockets`

追加: v0.3.6

<number>

デフォルトではInfinityに設定されています。エージェントがオリジンごとにオープンできる同時ソケット数を決定します。オリジンはagent.getName()の返り値です。

`agent.maxTotalSockets`

追加: v14.5.0, v12.19.0

<number>

デフォルトではInfinityに設定されています。エージェントがオープンできる同時ソケット数を決定します。maxSocketsとは異なり、このパラメーターはすべてのオリジンに適用されます。

`agent.requests`

[履歴]

バージョン	変更
v16.0.0	このプロパティは `null` プロトタイプを持つようになりました。
v0.5.9	追加: v0.5.9

<Object>

まだソケットに割り当てられていないリクエストのキューを含むオブジェクトです。変更しないでください。

`agent.sockets`

[履歴]

バージョン	変更
v16.0.0	このプロパティは `null` プロトタイプを持つようになりました。
v0.3.6	追加: v0.3.6

<Object>

エージェントによって現在使用中のソケットの配列を含むオブジェクトです。変更しないでください。

クラス: `http.ClientRequest`

追加: v0.1.17

拡張: <http.OutgoingMessage>

このオブジェクトは内部的に作成され、http.request()から返されます。これは、ヘッダーが既にキューに入れられている進行中のリクエストを表します。ヘッダーは、setHeader(name, value)、getHeader(name)、removeHeader(name) API を使用して変更可能です。実際のヘッダーは、最初のデータチャンクとともに送信されるか、request.end()を呼び出すときに送信されます。

レスポンスを取得するには、リクエストオブジェクトに'response'のリスナーを追加します。レスポンスヘッダーが受信されると、リクエストオブジェクトから'response'が発行されます。'response'イベントは、http.IncomingMessageのインスタンスである 1 つの引数で実行されます。

'response'イベント中には、レスポンスオブジェクトにリスナーを追加できます。特に、'data'イベントをリッスンするために追加できます。

'response'ハンドラーが追加されていない場合、レスポンスは完全に破棄されます。ただし、'response'イベントハンドラーが追加されている場合、レスポンスオブジェクトからのデータは、'readable'イベントがあるたびにresponse.read()を呼び出すか、'data'ハンドラーを追加するか、.resume()メソッドを呼び出すことによって、消費する必要があります。データが消費されるまで、'end'イベントは発生しません。また、データが読み取られるまで、メモリを消費し続け、最終的には「プロセスがメモリ不足」エラーにつながる可能性があります。

下位互換性のため、resは'error'リスナーが登録されている場合にのみ'error'を発行します。

レスポンスボディのサイズを制限するには、Content-Lengthヘッダーを設定します。response.strictContentLengthがtrueに設定されている場合、Content-Lengthヘッダーの値が一致しないと、code: 'ERR_HTTP_CONTENT_LENGTH_MISMATCH'で識別されるErrorがスローされます。

Content-Lengthの値は、文字数ではなくバイト単位である必要があります。Buffer.byteLength()](/ja/api/buffer#static-method-bufferbytelengthstring-encoding)を使用して、ボディの長さをバイト単位で判別します。

イベント: `'abort'`

追加: v1.4.1

非推奨: v17.0.0, v16.12.0 以降

[安定性: 0 - 非推奨]

安定性: 0 安定性: 0 - 非推奨。代わりに'close'イベントをリッスンしてください。

クライアントによってリクエストが中断されたときに発行されます。このイベントは、abort()の最初の呼び出しでのみ発行されます。

イベント: `'close'`

追加: v0.5.4

リクエストが完了したか、基盤となる接続が（レスポンス完了前に）早期に終了したことを示します。

イベント: `'connect'`

追加: v0.7.0

サーバーがCONNECTメソッドでリクエストに応答するたびに発行されます。このイベントがリッスンされていない場合、CONNECTメソッドを受信するクライアントは接続を閉じられます。

このイベントには、<net.Socket>クラスのインスタンスが必ず渡されます。これは<stream.Duplex>のサブクラスであり、ユーザーが<net.Socket>以外のソケットタイプを指定しない限りです。

'connect'イベントをリッスンする方法を示すクライアントとサーバーのペア：

ESMCJS

import { createServer, request } from 'node:http'
import { connect } from 'node:net'
import { URL } from 'node:url'

// HTTPトンネルプロキシを作成する
const proxy = createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
proxy.on('connect', (req, clientSocket, head) => {
  // オリジンサーバーに接続する
  const { port, hostname } = new URL(`http://${req.url}`)
  const serverSocket = connect(port || 80, hostname, () => {
    clientSocket.write('HTTP/1.1 200 Connection Established\r\n' + 'Proxy-agent: Node.js-Proxy\r\n' + '\r\n')
    serverSocket.write(head)
    serverSocket.pipe(clientSocket)
    clientSocket.pipe(serverSocket)
  })
})

// プロキシが実行された
proxy.listen(1337, '127.0.0.1', () => {
  // トンネルプロキシへのリクエストを作成する
  const options = {
    port: 1337,
    host: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80',
  }

  const req = request(options)
  req.end()

  req.on('connect', (res, socket, head) => {
    console.log('got connected!')

    // HTTPトンネルを介してリクエストを作成する
    socket.write('GET / HTTP/1.1\r\n' + 'Host: www.google.com:80\r\n' + 'Connection: close\r\n' + '\r\n')
    socket.on('data', chunk => {
      console.log(chunk.toString())
    })
    socket.on('end', () => {
      proxy.close()
    })
  })
})

const http = require('node:http')
const net = require('node:net')
const { URL } = require('node:url')

// HTTPトンネルプロキシを作成する
const proxy = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
proxy.on('connect', (req, clientSocket, head) => {
  // オリジンサーバーに接続する
  const { port, hostname } = new URL(`http://${req.url}`)
  const serverSocket = net.connect(port || 80, hostname, () => {
    clientSocket.write('HTTP/1.1 200 Connection Established\r\n' + 'Proxy-agent: Node.js-Proxy\r\n' + '\r\n')
    serverSocket.write(head)
    serverSocket.pipe(clientSocket)
    clientSocket.pipe(serverSocket)
  })
})

// プロキシが実行された
proxy.listen(1337, '127.0.0.1', () => {
  // トンネルプロキシへのリクエストを作成する
  const options = {
    port: 1337,
    host: '127.0.0.1',
    method: 'CONNECT',
    path: 'www.google.com:80',
  }

  const req = http.request(options)
  req.end()

  req.on('connect', (res, socket, head) => {
    console.log('got connected!')

    // HTTPトンネルを介してリクエストを作成する
    socket.write('GET / HTTP/1.1\r\n' + 'Host: www.google.com:80\r\n' + 'Connection: close\r\n' + '\r\n')
    socket.on('data', chunk => {
      console.log(chunk.toString())
    })
    socket.on('end', () => {
      proxy.close()
    })
  })
})

イベント: `'continue'`

追加: v0.3.2

サーバーが '100 Continue' HTTP レスポンスを送信したときに発生します。通常、リクエストに 'Expect: 100-continue' が含まれているためです。これは、クライアントがリクエストボディを送信する必要があるという指示です。

イベント: `'finish'`

追加: v0.3.6

リクエストが送信されたときに発生します。より具体的には、レスポンスヘッダーとボディの最後のセグメントが、ネットワークを介した送信のためにオペレーティングシステムに引き渡されたときに、このイベントが発生します。サーバーがまだ何かを受信したという意味ではありません。

イベント: `'information'`

追加: v10.0.0

info <Object>
- httpVersion <string>
- httpVersionMajor <integer>
- httpVersionMinor <integer>
- statusCode <integer>
- statusMessage <string>
- headers <Object>
- rawHeaders <string[]>

サーバーが 1xx の中間レスポンス（101 Upgrade を除く）を送信したときに発生します。このイベントのリスナーは、HTTP バージョン、ステータスコード、ステータスメッセージ、キーと値のヘッダーオブジェクト、および生ヘッダー名とその値を順番に格納した配列を含むオブジェクトを受け取ります。

ESMCJS

import { request } from 'node:http'

const options = {
  host: '127.0.0.1',
  port: 8080,
  path: '/length_request',
}

// リクエストを作成
const req = request(options)
req.end()

req.on('information', info => {
  console.log(`Got information prior to main response: ${info.statusCode}`)
})

const http = require('node:http')

const options = {
  host: '127.0.0.1',
  port: 8080,
  path: '/length_request',
}

// リクエストを作成
const req = http.request(options)
req.end()

req.on('information', info => {
  console.log(`Got information prior to main response: ${info.statusCode}`)
})

101 Upgrade ステータスは、WebSocket、インプレース TLS アップグレード、HTTP 2.0 などの従来の HTTP リクエスト/レスポンスチェーンからの逸脱により、このイベントを発生させません。101 Upgrade 通知を受け取るには、代わりに'upgrade'イベントをリッスンしてください。

イベント: `'response'`

追加: v0.1.0

response <http.IncomingMessage>

このリクエストに対してレスポンスが受信されたときに発生します。このイベントは一度だけ発生します。

イベント: `'socket'`

追加: v0.5.3

socket <stream.Duplex>

このイベントは、ユーザーが<net.Socket>以外のソケットタイプを指定しない限り、<net.Socket>クラスのインスタンス、つまり<stream.Duplex>のサブクラスを渡されることが保証されています。

イベント: `'timeout'`

追加: v0.7.8

基になるソケットが非アクティブ状態からタイムアウトしたときに発生します。これは、ソケットがアイドル状態になったことを通知するだけです。リクエストは手動で破棄する必要があります。

参照: request.setTimeout()。

イベント: `'upgrade'`

追加: v0.1.94

サーバーがアップグレードでリクエストに応答するたびに発生します。このイベントがリッスンされておらず、レスポンスのステータスコードが 101 Switching Protocols の場合、アップグレードヘッダーを受信するクライアントは接続が閉じられます。

'upgrade'イベントをリッスンする方法を示すクライアント/サーバーのペア。

ESMCJS

import http from 'node:http'
import process from 'node:process'

// HTTPサーバーを作成する
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
server.on('upgrade', (req, socket, head) => {
  socket.write(
    'HTTP/1.1 101 Web Socket Protocol Handshake\r\n' + 'Upgrade: WebSocket\r\n' + 'Connection: Upgrade\r\n' + '\r\n'
  )

  socket.pipe(socket) // エコーバック
})

// サーバーが実行されたので
server.listen(1337, '127.0.0.1', () => {
  // リクエストを行う
  const options = {
    port: 1337,
    host: '127.0.0.1',
    headers: {
      Connection: 'Upgrade',
      Upgrade: 'websocket',
    },
  }

  const req = http.request(options)
  req.end()

  req.on('upgrade', (res, socket, upgradeHead) => {
    console.log('got upgraded!')
    socket.end()
    process.exit(0)
  })
})

const http = require('node:http')

// HTTPサーバーを作成する
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('okay')
})
server.on('upgrade', (req, socket, head) => {
  socket.write(
    'HTTP/1.1 101 Web Socket Protocol Handshake\r\n' + 'Upgrade: WebSocket\r\n' + 'Connection: Upgrade\r\n' + '\r\n'
  )

  socket.pipe(socket) // エコーバック
})

// サーバーが実行されたので
server.listen(1337, '127.0.0.1', () => {
  // リクエストを行う
  const options = {
    port: 1337,
    host: '127.0.0.1',
    headers: {
      Connection: 'Upgrade',
      Upgrade: 'websocket',
    },
  }

  const req = http.request(options)
  req.end()

  req.on('upgrade', (res, socket, upgradeHead) => {
    console.log('got upgraded!')
    socket.end()
    process.exit(0)
  })
})

`request.abort()`

追加: v0.3.8

非推奨: v14.1.0, v13.14.0

[安定版: 0 - 非推奨]

安定版: 0 安定度: 0 - 非推奨: 代わりに request.destroy() を使用してください。

リクエストを中止としてマークします。これを呼び出すと、レスポンスに残っているデータは破棄され、ソケットは破棄されます。

`request.aborted`

[履歴]

バージョン	変更点
v17.0.0, v16.12.0	非推奨: v17.0.0, v16.12.0
v11.0.0	`aborted` プロパティはタイムスタンプの数値ではなくなりました。
v0.11.14	追加: v0.11.14

[安定版: 0 - 非推奨]

安定版: 0 安定度: 0 - 非推奨。代わりに request.destroyed を確認してください。

<boolean>

リクエストが中止された場合、request.aborted プロパティは true になります。

`request.connection`

追加: v0.3.0

非推奨: v13.0.0

[安定版: 0 - 非推奨]

安定版: 0 安定度: 0 - 非推奨。request.socket を使用してください。

<stream.Duplex>

request.socket を参照してください。

`request.cork()`

追加: v13.2.0, v12.16.0

writable.cork() を参照してください。

`request.end([data[, encoding]][, callback])`

[履歴]

バージョン	変更点
v15.0.0	`data` パラメータは `Uint8Array` にすることができるようになりました。
v10.0.0	このメソッドは `ClientRequest` への参照を返すようになりました。
v0.1.90	追加: v0.1.90

data <string> | <Buffer> | <Uint8Array>
encoding <string>
callback <Function>
戻り値: <this>

リクエストの送信を終了します。本文の一部が未送信の場合、それらはストリームにフラッシュされます。リクエストがチャンク化されている場合、これは終端の '0\r\n\r\n' を送信します。

data が指定されている場合、これは request.write(data, encoding) を呼び出した後に request.end(callback) を呼び出すことと同等です。

callback が指定されている場合、リクエストストリームが終了したときに呼び出されます。

`request.destroy([error])`

[履歴]

バージョン	変更点
v14.5.0	他の Readable ストリームとの一貫性を保つために、関数が `this` を返すようになりました。
v0.3.0	追加: v0.3.0

error <Error> オプション。'error' イベントで発生させるエラー。
戻り値: <this>

リクエストを破棄します。オプションで 'error' イベントを発生させ、'close' イベントを発生させます。これを呼び出すと、レスポンスに残っているデータが破棄され、ソケットが破棄されます。

詳細については、writable.destroy() を参照してください。

`request.destroyed`

追加: v14.1.0, v13.14.0

<boolean>

request.destroy() が呼び出された後、true になります。

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

`request.finished`

追加: v0.0.1

非推奨: v13.4.0, v12.16.0 以降

[安定: 0 - 非推奨]

安定: 0 安定度: 0 - 非推奨。request.writableEnded を使用してください。

<boolean>

request.end() が呼び出された場合、request.finished プロパティは true になります。リクエストが http.get() を介して開始された場合、request.end() は自動的に呼び出されます。

`request.flushHeaders()`

追加: v1.6.0

リクエストヘッダーをフラッシュします。

効率上の理由から、Node.js は通常、request.end() が呼び出されるか、リクエストデータの最初のチャンクが書き込まれるまで、リクエストヘッダーをバッファリングします。次に、リクエストヘッダーとデータを単一の TCP パケットにパックしようとします。

これは通常は望ましいことですが (TCP のラウンドトリップが節約されます)、最初のデータがかなり後になるまで送信されない場合は望ましくありません。request.flushHeaders() は最適化をバイパスし、リクエストを開始します。

`request.getHeader(name)`

追加: v1.6.0

name <string>
戻り値: <any>

リクエストのヘッダーを読み取ります。名前は大文字と小文字を区別しません。戻り値の型は、request.setHeader() に提供された引数に依存します。

request.setHeader('content-type', 'text/html')
request.setHeader('Content-Length', Buffer.byteLength(body))
request.setHeader('Cookie', ['type=ninja', 'language=javascript'])
const contentType = request.getHeader('Content-Type')
// 'contentType' は 'text/html'
const contentLength = request.getHeader('Content-Length')
// 'contentLength' は number 型
const cookie = request.getHeader('Cookie')
// 'cookie' は string[] 型

`request.getHeaderNames()`

追加: v7.7.0

戻り値: <string[]>

現在の送信ヘッダーの一意の名前を含む配列を返します。すべてのヘッダー名は小文字です。

request.setHeader('Foo', 'bar')
request.setHeader('Cookie', ['foo=bar', 'bar=baz'])

const headerNames = request.getHeaderNames()
// headerNames === ['foo', 'cookie']

`request.getHeaders()`

追加: v7.7.0

戻り値: <Object>

現在の送信ヘッダーの浅いコピーを返します。浅いコピーが使用されているため、配列の値は、さまざまなヘッダー関連の http モジュールメソッドをさらに呼び出すことなく変更できます。返されたオブジェクトのキーはヘッダー名で、値はそれぞれのヘッダー値です。すべてのヘッダー名は小文字です。

request.getHeaders() メソッドによって返されるオブジェクトは、JavaScript の Object からプロトタイプ的に継承 しません。これは、obj.toString()、obj.hasOwnProperty() などの一般的な Object メソッドが定義されておらず、機能しない ことを意味します。

request.setHeader('Foo', 'bar')
request.setHeader('Cookie', ['foo=bar', 'bar=baz'])

const headers = request.getHeaders()
// headers === { foo: 'bar', 'cookie': ['foo=bar', 'bar=baz'] }

`request.getRawHeaderNames()`

追加: v15.13.0, v14.17.0

戻り値: <string[]>

現在送信中の生ヘッダーの一意の名前を含む配列を返します。ヘッダー名は、設定された正確な大文字小文字で返されます。

request.setHeader('Foo', 'bar')
request.setHeader('Set-Cookie', ['foo=bar', 'bar=baz'])

const headerNames = request.getRawHeaderNames()
// headerNames === ['Foo', 'Set-Cookie']

`request.hasHeader(name)`

追加: v7.7.0

name <string>
戻り値: <boolean>

name で識別されるヘッダーが送信ヘッダーに現在設定されている場合は true を返します。ヘッダー名のマッチングは大文字小文字を区別しません。

const hasContentType = request.hasHeader('content-type')

`request.maxHeadersCount`

<number> デフォルト: 2000

最大レスポンスヘッダー数を制限します。0 に設定すると、制限は適用されません。

`request.path`

追加: v0.4.0

<string> リクエストパス。

`request.method`

追加: v0.1.97

<string> リクエストメソッド。

`request.host`

追加: v14.5.0, v12.19.0

<string> リクエストホスト。

`request.protocol`

追加: v14.5.0, v12.19.0

<string> リクエストプロトコル。

`request.removeHeader(name)`

追加: v1.6.0

name <string>

ヘッダーオブジェクトに既に定義されているヘッダーを削除します。

request.removeHeader('Content-Type')

`request.reusedSocket`

追加: v13.0.0, v12.16.0

<boolean> リクエストが再利用されたソケットを通じて送信されたかどうか。

keep-alive が有効なエージェントを通じてリクエストを送信する場合、基盤となるソケットが再利用されることがあります。しかし、サーバーが不運なタイミングで接続を閉じると、クライアントは「ECONNRESET」エラーに遭遇する可能性があります。

ESMCJS

import http from 'node:http'

// サーバーのデフォルトのkeep-aliveタイムアウトは5秒
http
  .createServer((req, res) => {
    res.write('hello\n')
    res.end()
  })
  .listen(3000)

setInterval(() => {
  // keep-aliveエージェントを適用
  http.get('http://localhost:3000', { agent }, res => {
    res.on('data', data => {
      // 何もしない
    })
  })
}, 5000) // 5秒間隔でリクエストを送信することで、アイドルタイムアウトに遭遇しやすくする

const http = require('node:http')

// サーバーのデフォルトのkeep-aliveタイムアウトは5秒
http
  .createServer((req, res) => {
    res.write('hello\n')
    res.end()
  })
  .listen(3000)

setInterval(() => {
  // keep-aliveエージェントを適用
  http.get('http://localhost:3000', { agent }, res => {
    res.on('data', data => {
      // 何もしない
    })
  })
}, 5000) // 5秒間隔でリクエストを送信することで、アイドルタイムアウトに遭遇しやすくする

リクエストがソケットを再利用したかどうかをマークすることで、それに基づいて自動エラー再試行を行うことができます。

ESMCJS

import http from 'node:http'
const agent = new http.Agent({ keepAlive: true })

function retriableRequest() {
  const req = http
    .get('http://localhost:3000', { agent }, res => {
      // ...
    })
    .on('error', err => {
      // 再試行が必要かどうかを確認
      if (req.reusedSocket && err.code === 'ECONNRESET') {
        retriableRequest()
      }
    })
}

retriableRequest()

const http = require('node:http')
const agent = new http.Agent({ keepAlive: true })

function retriableRequest() {
  const req = http
    .get('http://localhost:3000', { agent }, res => {
      // ...
    })
    .on('error', err => {
      // 再試行が必要かどうかを確認
      if (req.reusedSocket && err.code === 'ECONNRESET') {
        retriableRequest()
      }
    })
}

retriableRequest()

`request.setHeader(name, value)`

追加: v1.6.0

name <string>
value <any>

headers オブジェクトの単一のヘッダー値を設定します。送信される予定のヘッダーにこのヘッダーが既に存在する場合、その値は置き換えられます。同じ名前で複数のヘッダーを送信するには、ここで文字列の配列を使用します。文字列以外の値は、変更されずに保存されます。したがって、request.getHeader() は文字列以外の値を返す可能性があります。ただし、文字列以外の値は、ネットワーク送信のために文字列に変換されます。

request.setHeader('Content-Type', 'application/json')

または

request.setHeader('Cookie', ['type=ninja', 'language=javascript'])

値が文字列の場合、latin1 エンコーディングの範囲外の文字が含まれていると例外がスローされます。

値に UTF-8 文字を渡す必要がある場合は、RFC 8187 標準を使用して値をエンコードしてください。

const filename = 'Rock 🎵.txt'
request.setHeader('Content-Disposition', `attachment; filename*=utf-8''${encodeURIComponent(filename)}`)

`request.setNoDelay([noDelay])`

追加: v0.5.9

noDelay <boolean>

このリクエストにソケットが割り当てられ、接続されると、socket.setNoDelay() が呼び出されます。

`request.setSocketKeepAlive([enable][, initialDelay])`

追加: v0.5.9

enable <boolean>
initialDelay <number>

このリクエストにソケットが割り当てられ、接続されると、socket.setKeepAlive() が呼び出されます。

`request.setTimeout(timeout[, callback])`

[履歴]

バージョン	変更点
v9.0.0	ソケットが接続されたときにのみ、一貫してソケットタイムアウトを設定します。
v0.5.9	v0.5.9 で追加。

timeout <number> リクエストがタイムアウトするまでのミリ秒数。
callback <Function> タイムアウトが発生したときに呼び出されるオプションの関数。'timeout' イベントへのバインディングと同じです。
戻り値: <http.ClientRequest>

ソケットがこのリクエストに割り当てられ、接続されると、socket.setTimeout() が呼び出されます。

`request.socket`

追加: v0.3.0

<stream.Duplex>

基になるソケットへの参照。通常、ユーザーはこのプロパティにアクセスする必要はありません。特に、プロトコルパーサーがソケットにアタッチする方法のため、ソケットは 'readable' イベントを発生させません。

ESMCJS

import http from 'node:http'
const options = {
  host: 'www.google.com',
}
const req = http.get(options)
req.end()
req.once('response', res => {
  const ip = req.socket.localAddress
  const port = req.socket.localPort
  console.log(`Your IP address is ${ip} and your source port is ${port}.`)
  // Consume response object
})

const http = require('node:http')
const options = {
  host: 'www.google.com',
}
const req = http.get(options)
req.end()
req.once('response', res => {
  const ip = req.socket.localAddress
  const port = req.socket.localPort
  console.log(`Your IP address is ${ip} and your source port is ${port}.`)
  // Consume response object
})

このプロパティは、ユーザーが<net.Socket>以外のソケットタイプを指定した場合を除き、<stream.Duplex> のサブクラスである<net.Socket> クラスのインスタンスであることが保証されています。

`request.uncork()`

追加: v13.2.0, v12.16.0

writable.uncork() を参照してください。

`request.writableEnded`

追加: v12.9.0

<boolean>

request.end() が呼び出された後、true になります。このプロパティは、データがフラッシュされたかどうかを示すものではありません。代わりに request.writableFinished を使用してください。

`request.writableFinished`

追加: v12.7.0

<boolean>

すべてのデータが基礎となるシステムにフラッシュされた場合、'finish' イベントが発生する直前に true になります。

`request.write(chunk[, encoding][, callback])`

[履歴]

バージョン	変更点
v15.0.0	`chunk` パラメーターに `Uint8Array` を指定できるようになりました。
v0.1.29	追加: v0.1.29

chunk <string> | <Buffer> | <Uint8Array>
encoding <string>
callback <Function>
戻り値: <boolean>

本体のチャンクを送信します。このメソッドは複数回呼び出すことができます。Content-Length が設定されていない場合、データは自動的に HTTP Chunked Transfer Encoding でエンコードされるため、サーバーはデータの終了を認識できます。Transfer-Encoding: chunked ヘッダーが追加されます。リクエストの送信を完了するには、request.end() を呼び出す必要があります。

encoding 引数はオプションであり、chunk が文字列の場合にのみ適用されます。デフォルトは 'utf8' です。

callback 引数はオプションであり、このデータチャンクがフラッシュされたときに呼び出されます。ただし、チャンクが空でない場合に限ります。

すべてのデータがカーネルバッファに正常にフラッシュされた場合は true を返します。データの一部またはすべてがユーザーメモリにキューイングされた場合は false を返します。バッファが再び空くと 'drain' が発行されます。

write 関数が空の文字列またはバッファで呼び出された場合、何もせず、追加の入力を待ちます。

クラス: `http.Server`

追加: v0.1.17

継承: <net.Server>

イベント: `'checkContinue'`

追加: v0.3.0

request <http.IncomingMessage>
response <http.ServerResponse>

HTTP Expect: 100-continue を含むリクエストを受信するたびに発行されます。このイベントをリッスンしない場合、サーバーは必要に応じて 100 Continue で自動的に応答します。

このイベントを処理するには、クライアントがリクエストボディを送信し続ける必要がある場合は response.writeContinue() を呼び出し、クライアントがリクエストボディを送信し続ける必要がない場合は適切な HTTP 応答 (例: 400 Bad Request) を生成します。

このイベントが発行され、処理されると、'request' イベントは発行されません。

イベント: `'checkExpectation'`

追加: v5.5.0

request <http.IncomingMessage>
response <http.ServerResponse>

HTTP Expect ヘッダーを含むリクエストを受信するたびに発行されます。ただし、その値が 100-continue ではない場合です。このイベントをリッスンしない場合、サーバーは必要に応じて 417 Expectation Failed で自動的に応答します。

このイベントが発行され、処理されると、'request' イベントは発行されません。

イベント: `'clientError'`

[履歴]

バージョン	変更点
v12.0.0	HPE_HEADER_OVERFLOW エラーが発生した場合、デフォルトの動作は 431 Request Header Fields Too Large を返すようになります。
v9.4.0	`rawPacket` は、解析されたばかりの現在のバッファーです。このバッファーを `'clientError'` イベントのエラーオブジェクトに追加することで、開発者が破損したパケットをログに記録できるようにします。
v6.0.0	`'clientError'` のリスナーがアタッチされている場合、`socket` で `.destroy()` を呼び出すデフォルトのアクションは発生しなくなります。
v0.1.94	追加: v0.1.94

exception <Error>
socket <stream.Duplex>

クライアント接続が 'error' イベントを発行した場合、ここに転送されます。このイベントのリスナーは、基礎となるソケットをクローズ/破棄する責任があります。たとえば、接続を突然切断する代わりに、カスタム HTTP 応答でソケットをより適切にクローズしたい場合があります。リスナーが終了する前に、ソケットを クローズまたは破棄 する必要があります。

このイベントは、ユーザーが <net.Socket> 以外のソケットタイプを指定しない限り、<stream.Duplex> のサブクラスである <net.Socket> クラスのインスタンスが渡されることが保証されています。

デフォルトの動作は、HTTP '400 Bad Request'、または HPE_HEADER_OVERFLOW エラーの場合は HTTP '431 Request Header Fields Too Large' でソケットをクローズすることです。ソケットが書き込み可能でない場合、または現在アタッチされている http.ServerResponse のヘッダーが送信されている場合は、すぐに破棄されます。

socket は、エラーの発生元となった net.Socket オブジェクトです。

ESMCJS

import http from 'node:http'

const server = http.createServer((req, res) => {
  res.end()
})
server.on('clientError', (err, socket) => {
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
})
server.listen(8000)

const http = require('node:http')

const server = http.createServer((req, res) => {
  res.end()
})
server.on('clientError', (err, socket) => {
  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
})
server.listen(8000)

'clientError' イベントが発生した場合、request オブジェクトまたは response オブジェクトはないため、応答ヘッダーやペイロードを含む HTTP 応答は、必ず socket オブジェクトに直接書き込む必要があります。応答が正しくフォーマットされた HTTP 応答メッセージであることを確認するために注意が必要です。

err は、次の 2 つの追加列を持つ Error のインスタンスです。

bytesParsed: Node.js が正しく解析した可能性があるリクエストパケットのバイト数。
rawPacket: 現在のリクエストの生のパケット。

ECONNRESET エラーの場合のように、クライアントが応答をすでに受信しているか、またはソケットがすでに破棄されている場合があります。ソケットにデータを送信する前に、ソケットがまだ書き込み可能であることを確認することをお勧めします。

server.on('clientError', (err, socket) => {
  if (err.code === 'ECONNRESET' || !socket.writable) {
    return
  }

  socket.end('HTTP/1.1 400 Bad Request\r\n\r\n')
})

Event: `'close'`

追加: v0.1.4

サーバーがクローズされたときに発生します。

Event: `'connect'`

追加: v0.7.0

request <http.IncomingMessage> 'request' イベントと同様の、HTTP リクエストの引数
socket <stream.Duplex> サーバーとクライアント間のネットワークソケット
head <Buffer> トンネリングストリームの最初のパケット（空の場合もあります）

クライアントが HTTP CONNECTメソッドをリクエストするたびに発生します。このイベントがリスンされない場合、CONNECTメソッドをリクエストするクライアントの接続は閉じられます。

このイベントは、ユーザーが<net.Socket>以外のソケットタイプを指定しない限り、<stream.Duplex>のサブクラスである<net.Socket>クラスのインスタンスが渡されることが保証されています。

このイベントが発生した後、リクエストのソケットには'data'イベントリスナーがないため、そのソケットでサーバーに送信されたデータを処理するためにバインドする必要があります。

Event: `'connection'`

追加: v0.1.0

socket <stream.Duplex>

新しい TCP ストリームが確立されたときにこのイベントが発生します。通常、socketはnet.Socket型のオブジェクトです。通常、ユーザーはこのイベントにアクセスしたくないでしょう。特に、プロトコルパーサーがソケットにどのようにアタッチされるかにより、ソケットは'readable'イベントを発生させません。socketはrequest.socketでもアクセスできます。

このイベントは、HTTP サーバーに接続を注入するために、ユーザーが明示的に発生させることもできます。その場合、任意のDuplexストリームを渡すことができます。

ここでsocket.setTimeout()が呼び出されると、ソケットがリクエストを処理したとき（server.keepAliveTimeoutがゼロでない場合）、タイムアウトはserver.keepAliveTimeoutに置き換えられます。

このイベントは、ユーザーが<net.Socket>以外のソケットタイプを指定しない限り、<stream.Duplex>のサブクラスである<net.Socket>クラスのインスタンスが渡されることが保証されています。

イベント: `'dropRequest'`

追加バージョン: v18.7.0, v16.17.0

request <http.IncomingMessage> HTTP リクエストの引数。'request' イベントの場合と同じです。
socket <stream.Duplex> サーバーとクライアント間のネットワークソケット

ソケット上のリクエスト数が server.maxRequestsPerSocket のしきい値に達すると、サーバーは新しいリクエストをドロップし、代わりに 'dropRequest' イベントを発生させ、クライアントに 503 を送信します。

イベント: `'request'`

追加バージョン: v0.1.0

request <http.IncomingMessage>
response <http.ServerResponse>

リクエストがあるたびに発生します。（HTTP Keep-Alive 接続の場合、1 つの接続で複数のリクエストが発生する可能性があります）。

イベント: `'upgrade'`

[履歴]

バージョン	変更点
v10.0.0	クライアントが Upgrade ヘッダーを送信した場合、このイベントをリッスンしないことによってソケットが破棄されることはなくなりました。
v0.1.94	追加バージョン: v0.1.94

request <http.IncomingMessage> HTTP リクエストの引数。'request' イベントの場合と同じです。
socket <stream.Duplex> サーバーとクライアント間のネットワークソケット
head <Buffer> アップグレードされたストリームの最初のパケット（空の場合もあります）

クライアントが HTTP アップグレードをリクエストするたびに発生します。このイベントのリッスンはオプションであり、クライアントはプロトコルの変更を主張することはできません。

このイベントが発生した後、リクエストのソケットには 'data' イベントリスナーがなくなるため、そのソケットでサーバーに送信されたデータを処理するためにはバインドする必要があります。

このイベントは、ユーザーが<net.Socket>以外のソケットタイプを指定しない限り、<stream.Duplex>のサブクラスである<net.Socket>クラスのインスタンスに渡されることが保証されます。

`server.close([callback])`

[履歴]

バージョン	変更点
v19.0.0	このメソッドは、戻る前にアイドル状態の接続を閉じます。
v0.1.90	v0.1.90 で追加

callback <Function>

サーバーが新しい接続を受け入れるのを停止し、リクエストを送信していない、またはレスポンスを待機していないこのサーバーに接続されているすべての接続を閉じます。net.Server.close() を参照してください。

const http = require('node:http')

const server = http.createServer({ keepAliveTimeout: 60000 }, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)
// 10秒後にサーバーを閉じる
setTimeout(() => {
  server.close(() => {
    console.log('ポート8000のサーバーが正常に閉じました')
  })
}, 10000)

`server.closeAllConnections()`

追加: v18.2.0

このサーバーに接続されている確立されたすべての HTTP(S)接続を閉じます。これには、リクエストを送信中またはレスポンスを待機中のこのサーバーに接続されているアクティブな接続が含まれます。これは、WebSocket や HTTP/2 など、別のプロトコルにアップグレードされたソケットを破棄する ものではありません。

const http = require('node:http')

const server = http.createServer({ keepAliveTimeout: 60000 }, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)
// 10秒後にサーバーを閉じる
setTimeout(() => {
  server.close(() => {
    console.log('ポート8000のサーバーが正常に閉じました')
  })
  // すべての接続を閉じ、サーバーが正常に閉じるようにします
  server.closeAllConnections()
}, 10000)

`server.closeIdleConnections()`

追加: v18.2.0

リクエストを送信していない、またはレスポンスを待機していないこのサーバーに接続されているすべての接続を閉じます。

const http = require('node:http')

const server = http.createServer({ keepAliveTimeout: 60000 }, (req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)
// 10秒後にサーバーを閉じる
setTimeout(() => {
  server.close(() => {
    console.log('ポート8000のサーバーが正常に閉じました')
  })
  // キープアライブ接続などのアイドル接続を閉じます。残りのアクティブな接続が終了すると、サーバーは閉じます
  server.closeIdleConnections()
}, 10000)

`server.headersTimeout`

[履歴]

バージョン	変更点
v19.4.0, v18.14.0	デフォルト値が 60000 (60 秒) または `requestTimeout` の小さい方に設定されるようになりました。
v11.3.0, v10.14.0	追加: v11.3.0, v10.14.0

<number> デフォルト: server.requestTimeout または 60000 の小さい方。

パーサーが HTTP ヘッダー全体を受信するまで待機する時間制限を設定します。

タイムアウトした場合、サーバーはリクエストをリクエストリスナーに転送せずにステータス 408 で応答し、接続を閉じます。

サーバーがリバースプロキシなしでデプロイされる場合、潜在的なサービス拒否攻撃から保護するため、ゼロ以外の値 (例: 120 秒) に設定する必要があります。

`server.listen()`

接続をリッスンする HTTP サーバーを起動します。このメソッドは net.Server の server.listen() と同じです。

`server.listening`

追加: v5.7.0

<boolean> サーバーが接続をリッスンしているかどうかを示します。

`server.maxHeadersCount`

追加: v0.7.0

<number> デフォルト: 2000

受信ヘッダーの最大数を制限します。0 に設定すると、制限は適用されません。

`server.requestTimeout`

[履歴]

バージョン	変更点
v18.0.0	デフォルトのリクエストタイムアウトがタイムアウトなしから 300 秒 (5 分) に変更されました。
v14.11.0	追加: v14.11.0

<number> デフォルト: 300000

クライアントからリクエスト全体を受信するまでのタイムアウト値をミリ秒単位で設定します。

タイムアウトした場合、サーバーはリクエストをリクエストリスナーに転送せずにステータス 408 で応答し、接続を閉じます。

`server.setTimeout([msecs][, callback])`

[履歴]

バージョン	変更
v13.0.0	デフォルトのタイムアウトが 120 秒から 0 (タイムアウトなし) に変更されました。
v0.9.12	追加: v0.9.12

msecs <number> デフォルト: 0 (タイムアウトなし)
callback <Function>
戻り値: <http.Server>

ソケットのタイムアウト値を設定します。タイムアウトが発生した場合、Server オブジェクトで 'timeout' イベントが発生し、ソケットが引数として渡されます。

Server オブジェクトに 'timeout' イベントリスナーがある場合、タイムアウトしたソケットが引数として渡されて呼び出されます。

デフォルトでは、Server はソケットをタイムアウトさせません。ただし、Server の 'timeout' イベントにコールバックが割り当てられている場合は、タイムアウトを明示的に処理する必要があります。

`server.maxRequestsPerSocket`

追加: v16.10.0

<number> ソケットあたりのリクエスト数。 デフォルト: 0 (制限なし)

キープアライブ接続を閉じる前にソケットが処理できるリクエストの最大数。

値が 0 の場合、制限は無効になります。

制限に達すると、Connection ヘッダーの値が close に設定されますが、実際には接続は閉じられません。制限に達した後に送信された後続のリクエストは、503 Service Unavailable として応答を受け取ります。

`server.timeout`

[履歴]

バージョン	変更
v13.0.0	デフォルトのタイムアウトが 120 秒から 0 (タイムアウトなし) に変更されました。
v0.9.12	追加: v0.9.12

<number> タイムアウト (ミリ秒単位)。 デフォルト: 0 (タイムアウトなし)

ソケットがタイムアウトしたとみなされるまでの非アクティブ時間 (ミリ秒単位)。

値が 0 の場合、受信接続でのタイムアウト動作は無効になります。

ソケットのタイムアウトロジックは接続時に設定されるため、この値を変更すると、サーバーへの新しい接続のみに影響し、既存の接続には影響しません。

`server.keepAliveTimeout`

追加: v8.0.0

<number> ミリ秒単位のタイムアウト。デフォルト: 5000 (5 秒)。

ソケットが破棄される前に、サーバーが最後の応答の書き込みを完了した後、追加の受信データを待機する必要がある非アクティブなミリ秒数。キープアライブタイムアウトが発火する前にサーバーが新しいデータを受信した場合、server.timeoutと同様に、通常の非アクティブタイムアウトがリセットされます。

0の値は、着信接続に対するキープアライブタイムアウトの動作を無効にします。0の値は、キープアライブタイムアウトがなかった Node.js の 8.0.0 より前のバージョンと同様に HTTP サーバーを動作させます。

ソケットタイムアウトロジックは接続時に設定されるため、この値を変更しても、既存の接続ではなく、サーバーへの新しい接続にのみ影響します。

`server[Symbol.asyncDispose]()`

追加: v20.4.0

[安定版: 1 - 試験的]

安定版: 1 安定性: 1 - 試験的

server.close()を呼び出し、サーバーが閉じられたときに完了する Promise を返します。

クラス: `http.ServerResponse`

追加: v0.1.17

拡張: <http.OutgoingMessage>

このオブジェクトは、ユーザーではなく、HTTP サーバーによって内部的に作成されます。'request'イベントへの 2 番目のパラメータとして渡されます。

イベント: `'close'`

追加: v0.6.7

応答が完了したか、または基になる接続が（応答が完了する前に）途中で終了したことを示します。

イベント: `'finish'`

追加: v0.3.6

応答が送信されたときに発生します。より具体的には、このイベントは、応答ヘッダーと本文の最後のセグメントがネットワーク経由で送信するためにオペレーティングシステムに渡されたときに発生します。クライアントがまだ何かを受信したという意味ではありません。

`response.addTrailers(headers)`

追加: v0.3.0

headers <Object>

このメソッドは、HTTP トレーリングヘッダー（メッセージの最後にあるヘッダー）をレスポンスに追加します。

トレーラーは、レスポンスにチャンクエンコーディングが使用されている場合にのみ送信されます。そうでない場合（例えば、リクエストが HTTP/1.0 の場合）、トレーラーは黙って破棄されます。

HTTP では、トレーラーを送信するために、値にヘッダーフィールドのリストを持つTrailerヘッダーを送信する必要があります。例：

response.writeHead(200, { 'Content-Type': 'text/plain', Trailer: 'Content-MD5' })
response.write(fileData)
response.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' })
response.end()

無効な文字を含むヘッダーフィールド名または値を設定しようとすると、TypeErrorがスローされます。

`response.connection`

追加: v0.3.0

非推奨: v13.0.0 以降

[安定: 0 - 非推奨]

安定: 0 安定性: 0 - 非推奨。response.socketを使用してください。

<stream.Duplex>

response.socketを参照してください。

`response.cork()`

追加: v13.2.0, v12.16.0

writable.cork()を参照してください。

`response.end([data[, encoding]][, callback])`

[履歴]

バージョン	変更点
v15.0.0	`data` パラメータが `Uint8Array` になりました。
v10.0.0	このメソッドは、`ServerResponse`への参照を返すようになりました。
v0.1.90	追加: v0.1.90

data <string> | <Buffer> | <Uint8Array>
encoding <string>
callback <Function>
戻り値: <this>

このメソッドは、レスポンスヘッダーと本文がすべて送信されたことをサーバーに通知します。サーバーはこのメッセージが完了したと見なす必要があります。response.end()メソッドは、各レスポンスで必ず呼び出す必要があります。

dataが指定されている場合、response.write(data, encoding)を呼び出した後にresponse.end(callback)を呼び出すのと同じ効果があります。

callbackが指定されている場合、レスポンスストリームが終了したときに呼び出されます。

`response.finished`

追加: v0.0.2

非推奨: v13.4.0, v12.16.0

[安定版: 0 - 非推奨]

安定版: 0 安定度: 0 - 非推奨。response.writableEnded を使用してください。

<boolean>

response.end() が呼び出された場合、response.finished プロパティは true になります。

`response.flushHeaders()`

追加: v1.6.0

レスポンスヘッダーをフラッシュします。以下も参照してください: request.flushHeaders()。

`response.getHeader(name)`

追加: v0.4.0

name <string>
戻り値: <any>

すでにキューに入れられているが、クライアントに送信されていないヘッダーを読み取ります。名前は大文字と小文字を区別しません。戻り値の型は、response.setHeader() に提供された引数によって異なります。

response.setHeader('Content-Type', 'text/html')
response.setHeader('Content-Length', Buffer.byteLength(body))
response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript'])
const contentType = response.getHeader('content-type')
// contentType は 'text/html'
const contentLength = response.getHeader('Content-Length')
// contentLength は number 型
const setCookie = response.getHeader('set-cookie')
// setCookie は string[] 型

`response.getHeaderNames()`

追加: v7.7.0

戻り値: <string[]>

現在送信中のヘッダーの一意の名前を含む配列を返します。すべてのヘッダー名は小文字です。

response.setHeader('Foo', 'bar')
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz'])

const headerNames = response.getHeaderNames()
// headerNames === ['foo', 'set-cookie']

`response.getHeaders()`

追加: v7.7.0

戻り値: <Object>

現在送信中のヘッダーの浅いコピーを返します。浅いコピーが使用されているため、さまざまなヘッダー関連の http モジュールメソッドをさらに呼び出さなくても、配列値を変更できます。返されるオブジェクトのキーはヘッダー名であり、値はそれぞれのヘッダー値です。すべてのヘッダー名は小文字です。

response.getHeaders() メソッドによって返されるオブジェクトは、JavaScript の Object からプロトタイプ的に継承しません。これは、obj.toString()、obj.hasOwnProperty() などの一般的な Object メソッドが定義されておらず、機能しないことを意味します。

response.setHeader('Foo', 'bar')
response.setHeader('Set-Cookie', ['foo=bar', 'bar=baz'])

const headers = response.getHeaders()
// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }

`response.hasHeader(name)`

追加: v7.7.0

name <string>
戻り値: <boolean>

name で識別されるヘッダーが送信ヘッダーに現在設定されている場合、true を返します。ヘッダー名の一致は大文字と小文字を区別しません。

const hasContentType = response.hasHeader('content-type')

`response.headersSent`

追加: v0.9.3

<boolean>

ブール値（読み取り専用）。ヘッダーが送信された場合は true、それ以外の場合は false です。

`response.removeHeader(name)`

追加: v0.4.0

name <string>

暗黙的な送信のためにキューに入れられているヘッダーを削除します。

response.removeHeader('Content-Encoding')

`response.req`

追加: v15.7.0

<http.IncomingMessage>

元の HTTP request オブジェクトへの参照。

`response.sendDate`

追加: v0.7.5

<boolean>

true の場合、ヘッダーに Date ヘッダーがまだ存在しない場合、自動的に生成されてレスポンスで送信されます。デフォルトは true です。

これはテストのためだけに無効にする必要があります。HTTP ではレスポンスに Date ヘッダーが必要です。

`response.setHeader(name, value)`

追加: v0.4.0

name <string>
value <any>
戻り値: <http.ServerResponse>

レスポンスオブジェクトを返します。

暗黙的なヘッダーに対して単一のヘッダー値を設定します。このヘッダーが送信されるヘッダーにすでに存在する場合、その値は置き換えられます。同じ名前で複数のヘッダーを送信するには、ここに文字列の配列を使用します。文字列以外の値は変更せずに保存されます。したがって、response.getHeader() は文字列以外の値を返す場合があります。ただし、文字列以外の値はネットワーク送信のために文字列に変換されます。同じレスポンスオブジェクトが呼び出し元に返され、メソッドチェーンを有効にします。

response.setHeader('Content-Type', 'text/html')

または

response.setHeader('Set-Cookie', ['type=ninja', 'language=javascript'])

無効な文字を含むヘッダーフィールド名または値を設定しようとすると、TypeErrorがスローされます。

response.setHeader()でヘッダーが設定されている場合、response.writeHead()に渡されたヘッダーとマージされ、response.writeHead()に渡されたヘッダーが優先されます。

// content-type = text/plain を返します
const server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html')
  res.setHeader('X-Foo', 'bar')
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('ok')
})

response.writeHead()メソッドが呼び出され、このメソッドが呼び出されていない場合、提供されたヘッダー値を内部にキャッシュせずにネットワークチャネルに直接書き込み、ヘッダーのresponse.getHeader()は期待される結果を生成しません。ヘッダーの段階的な設定を将来の取得および変更の可能性とともに実行する場合は、response.writeHead()の代わりにresponse.setHeader()を使用してください。

`response.setTimeout(msecs[, callback])`

追加: v0.9.12

msecs <number>
callback <Function>
戻り値: <http.ServerResponse>

ソケットのタイムアウト値を msecs に設定します。コールバックが提供されている場合、それはレスポンスオブジェクトの 'timeout' イベントのリスナーとして追加されます。

リクエスト、レスポンス、またはサーバーに 'timeout' リスナーが追加されていない場合、ソケットはタイムアウト時に破棄されます。ハンドラーがリクエスト、レスポンス、またはサーバーの 'timeout' イベントに割り当てられている場合、タイムアウトしたソケットは明示的に処理する必要があります。

`response.socket`

追加: v0.3.0

<stream.Duplex>

基になるソケットへの参照。通常、ユーザーはこのプロパティにアクセスしたくありません。特に、プロトコルパーサーがソケットにアタッチする方法のため、ソケットは 'readable' イベントを発行しません。response.end() の後、プロパティは null になります。

ESMCJS

import http from 'node:http'
const server = http
  .createServer((req, res) => {
    const ip = res.socket.remoteAddress
    const port = res.socket.remotePort
    res.end(`Your IP address is ${ip} and your source port is ${port}.`)
  })
  .listen(3000)

const http = require('node:http')
const server = http
  .createServer((req, res) => {
    const ip = res.socket.remoteAddress
    const port = res.socket.remotePort
    res.end(`Your IP address is ${ip} and your source port is ${port}.`)
  })
  .listen(3000)

このプロパティは、ユーザーが<net.Socket>以外のソケットタイプを指定した場合を除き、<stream.Duplex>のサブクラスである<net.Socket>クラスのインスタンスであることが保証されています。

`response.statusCode`

追加: v0.4.0

<number> デフォルト: 200

暗黙的なヘッダーを使用している場合（response.writeHead()を明示的に呼び出していない場合）、このプロパティは、ヘッダーがフラッシュされたときにクライアントに送信されるステータスコードを制御します。

response.statusCode = 404

レスポンスヘッダーがクライアントに送信された後、このプロパティは送信されたステータスコードを示します。

`response.statusMessage`

追加: v0.11.8

<string>

暗黙的なヘッダーを使用している場合（response.writeHead()を明示的に呼び出さない場合）、このプロパティは、ヘッダーがフラッシュされたときにクライアントに送信されるステータスメッセージを制御します。これがundefinedのままの場合、ステータスコードの標準メッセージが使用されます。

response.statusMessage = 'Not found'

レスポンスヘッダーがクライアントに送信された後、このプロパティは送信されたステータスメッセージを示します。

`response.strictContentLength`

追加: v18.10.0, v16.18.0

<boolean> デフォルト: false

trueに設定すると、Node.js はContent-Lengthヘッダーの値と本文のサイズ（バイト単位）が等しいかどうかを確認します。Content-Lengthヘッダーの値が一致しない場合、code: 'ERR_HTTP_CONTENT_LENGTH_MISMATCH'で識別されるErrorがスローされます。

`response.uncork()`

追加: v13.2.0, v12.16.0

writable.uncork()を参照してください。

`response.writableEnded`

追加: v12.9.0

<boolean>

response.end()が呼び出された後、trueになります。このプロパティは、データがフラッシュされたかどうかを示すものではありません。これには代わりにresponse.writableFinishedを使用してください。

`response.writableFinished`

追加: v12.7.0

<boolean>

すべてのデータが基盤となるシステムにフラッシュされた場合、'finish'イベントが発行される直前にtrueになります。

`response.write(chunk[, encoding][, callback])`

[履歴]

バージョン	変更点
v15.0.0	`chunk`パラメータは`Uint8Array`にできるようになりました。
v0.1.29	追加: v0.1.29

chunk <string> | <Buffer> | <Uint8Array>
encoding <string> デフォルト: 'utf8'
callback <Function>
戻り値: <boolean>

このメソッドが呼び出され、response.writeHead()が呼び出されていない場合、暗黙的なヘッダーモードに切り替わり、暗黙的なヘッダーをフラッシュします。

これはレスポンスボディのチャンクを送信します。このメソッドは、ボディの連続した部分を提供するために複数回呼び出すことができます。

createServerでrejectNonStandardBodyWritesが true に設定されている場合、リクエストメソッドまたはレスポンスステータスがコンテンツをサポートしていない場合、ボディへの書き込みは許可されません。HEAD リクエストまたは204または304レスポンスの一部としてボディに書き込もうとすると、コードERR_HTTP_BODY_NOT_ALLOWEDを持つ同期的なErrorがスローされます。

chunkは文字列またはバッファにすることができます。chunkが文字列の場合、2 番目のパラメータは、それをバイトストリームにエンコードする方法を指定します。このデータのチャンクがフラッシュされると、callbackが呼び出されます。

これは生の HTTP ボディであり、使用される可能性のある高レベルのマルチパートボディエンコーディングとは関係ありません。

response.write()が最初に呼び出されると、バッファリングされたヘッダー情報とボディの最初のチャンクがクライアントに送信されます。response.write()が 2 回目に呼び出されると、Node.js はデータがストリーミングされると仮定し、新しいデータを個別に送信します。つまり、レスポンスはボディの最初のチャンクまでバッファリングされます。

すべてのデータがカーネルバッファに正常にフラッシュされた場合はtrueを返します。データの一部またはすべてがユーザーメモリにキューイングされた場合はfalseを返します。バッファが再び空になると、'drain'が発行されます。

`response.writeContinue()`

追加: v0.3.0

クライアントに HTTP/1.1 100 Continue メッセージを送信し、リクエストボディを送信する必要があることを示します。Server の 'checkContinue' イベントを参照してください。

`response.writeEarlyHints(hints[, callback])`

[履歴]

バージョン	変更点
v18.11.0	hints をオブジェクトとして渡せるように変更。
v18.11.0	追加: v18.11.0

hints <Object>
callback <Function>

HTTP/1.1 103 Early Hints メッセージを、Link ヘッダー付きでクライアントに送信し、ユーザーエージェントがリンクされたリソースをプリロード/プリコネクトできることを示します。hintsは、early hints メッセージとともに送信されるヘッダーの値を含むオブジェクトです。オプションの callback 引数は、レスポンスメッセージが書き込まれたときに呼び出されます。

例

const earlyHintsLink = '</styles.css>; rel=preload; as=style'
response.writeEarlyHints({
  link: earlyHintsLink,
})

const earlyHintsLinks = ['</styles.css>; rel=preload; as=style', '</scripts.js>; rel=preload; as=script']
response.writeEarlyHints({
  link: earlyHintsLinks,
  'x-trace-id': 'id for diagnostics',
})

const earlyHintsCallback = () => console.log('early hints message sent')
response.writeEarlyHints(
  {
    link: earlyHintsLinks,
  },
  earlyHintsCallback
)

`response.writeHead(statusCode[, statusMessage][, headers])`

[履歴]

バージョン	変更点
v14.14.0	headers を配列として渡せるように変更。
v11.10.0, v10.17.0	`writeHead()`から`this`を返すようにして、`end()`とのチェインが可能に。
v5.11.0, v4.4.5	`statusCode`が`[100, 999]`の範囲の数値でない場合、`RangeError`がスローされる。
v0.1.30	追加: v0.1.30

statusCode <number>
statusMessage <string>
headers <Object> | <Array>
戻り値: <http.ServerResponse>

リクエストに応答ヘッダーを送信します。ステータスコードは、404のような 3 桁の HTTP ステータスコードです。最後の引数 headers は、応答ヘッダーです。オプションで、人間が読める statusMessage を 2 番目の引数として指定できます。

headers は、キーと値が同じリストにある Array でも構いません。これはタプルのリスト ではありません。したがって、偶数番目のオフセットはキーの値で、奇数番目のオフセットは関連付けられた値です。配列は、request.rawHeaders と同じ形式です。

ServerResponseへの参照を返すので、呼び出しをチェーンすることができます。

const body = 'hello world'
response
  .writeHead(200, {
    'Content-Length': Buffer.byteLength(body),
    'Content-Type': 'text/plain',
  })
  .end(body)

このメソッドは、メッセージに対して一度だけ呼び出す必要があり、response.end() が呼び出される前に呼び出す必要があります。

response.write() または response.end() がこれを呼び出す前に呼び出された場合、暗黙的/可変ヘッダーが計算され、この関数が呼び出されます。

response.setHeader() でヘッダーが設定されている場合、それらは response.writeHead() に渡されたヘッダーとマージされ、response.writeHead() に渡されたヘッダーが優先されます。

このメソッドが呼び出され、response.setHeader() が呼び出されていない場合、内部にキャッシュすることなく、指定されたヘッダー値をネットワークチャネルに直接書き込み、ヘッダーに対する response.getHeader() は期待される結果を生成しません。ヘッダーの進歩的な設定が将来の取得と変更の可能性を伴う場合、代わりにresponse.setHeader()を使用してください。

// content-type = text/plainを返します
const server = http.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html')
  res.setHeader('X-Foo', 'bar')
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('ok')
})

Content-Length は文字数ではなくバイト数で読み取られます。Buffer.byteLength() を使用して、本文の長さをバイト単位で決定してください。Node.js は Content-Length と送信された本文の長さが等しいかどうかをチェックします。

無効な文字を含むヘッダーフィールド名または値を設定しようとすると、[Error][] がスローされます。

`response.writeProcessing()`

追加: v10.0.0

HTTP/1.1 102 Processing メッセージをクライアントに送信し、リクエストボディを送信する必要があることを示します。

クラス: `http.IncomingMessage`

[履歴]

バージョン	変更
v15.5.0	受信データが消費された後、`destroyed` 値が `true` を返すようになりました。
v13.1.0, v12.16.0	`readableHighWaterMark` 値がソケットの値を反映するようになりました。
v0.1.17	追加: v0.1.17

拡張: <stream.Readable>

IncomingMessage オブジェクトは、http.Server または http.ClientRequest によって作成され、それぞれ 'request' および 'response' イベントの最初の引数として渡されます。レスポンスステータス、ヘッダー、およびデータにアクセスするために使用できます。

<stream.Duplex> のサブクラスである socket 値とは異なり、IncomingMessage 自体は <stream.Readable> を拡張し、受信 HTTP ヘッダーとペイロードを解析および発行するために個別に作成されます。基礎となるソケットは、keep-alive の場合、複数回再利用される可能性があるためです。

イベント: `'aborted'`

追加: v0.3.8

非推奨: v17.0.0, v16.12.0 から

[安定: 0 - 非推奨]

安定: 0 安定性: 0 - 非推奨。代わりに 'close' イベントをリッスンしてください。

リクエストが中断されたときに発生します。

イベント: `'close'`

[履歴]

バージョン	変更
v16.0.0	リクエストが完了したときに、基礎となるソケットが閉じられたときではなく、close イベントが発生するようになりました。
v0.4.2	追加: v0.4.2

リクエストが完了したときに発生します。

`message.aborted`

追加: v10.1.0

非推奨: v17.0.0, v16.12.0 から

[安定: 0 - 非推奨]

安定: 0 安定性: 0 - 非推奨。<stream.Readable> から message.destroyed を確認してください。

<boolean>

リクエストが中断された場合、message.aborted プロパティは true になります。

`message.complete`

追加: v0.3.0

<boolean>

message.complete プロパティは、完全な HTTP メッセージが受信され、正常に解析された場合に true になります。

このプロパティは、クライアントまたはサーバーが接続を終了する前にメッセージを完全に送信したかどうかを判断する手段として特に役立ちます。

const req = http.request(
  {
    host: '127.0.0.1',
    port: 8080,
    method: 'POST',
  },
  res => {
    res.resume()
    res.on('end', () => {
      if (!res.complete) console.error('メッセージ送信中に接続が終了しました')
    })
  }
)

`message.connection`

追加: v0.1.90

非推奨: v16.0.0 以降

[安定: 0 - 非推奨]

安定: 0 安定性: 0 - 非推奨。 message.socket を使用してください。

message.socket のエイリアス。

`message.destroy([error])`

[履歴]

バージョン	変更
v14.5.0, v12.19.0	この関数は、他の Readable ストリームとの一貫性のために `this` を返します。
v0.3.0	追加: v0.3.0

error <Error>
戻り値: <this>

IncomingMessage を受信したソケットに対して destroy() を呼び出します。 error が指定された場合、ソケットで 'error' イベントが発生し、error がそのイベントのリスナーへの引数として渡されます。

`message.headers`

[履歴]

バージョン	変更
v19.5.0, v18.14.0	`http.request()` および `http.createServer()` 関数の `joinDuplicateHeaders` オプションにより、重複ヘッダーが破棄されず、RFC 9110 セクション 5.3 に従ってコンマ区切りで結合されるようになります。
v15.1.0	`message.headers` は、プロトタイプ上のアクセサープロパティを使用して遅延計算されるようになり、列挙可能ではなくなりました。
v0.1.5	追加: v0.1.5

<Object>

リクエスト/レスポンスヘッダーオブジェクト。

ヘッダー名と値のキーと値のペア。ヘッダー名は小文字に変換されます。

// 次のようなものを出力します:
//
// { 'user-agent': 'curl/7.22.0',
//   host: '127.0.0.1:8000',
//   accept: '*/*' }
console.log(request.headers)

生のヘッダーの重複は、ヘッダー名に応じて次の方法で処理されます。

age、authorization、content-length、content-type、etag、expires、from、host、if-modified-since、if-unmodified-since、last-modified、location、max-forwards、proxy-authorization、referer、retry-after、server、または user-agent の重複は破棄されます。上記のヘッダーの重複値を結合できるようにするには、http.request() および http.createServer() の joinDuplicateHeaders オプションを使用します。詳細については、RFC 9110 セクション 5.3 を参照してください。
set-cookie は常に配列です。重複は配列に追加されます。
重複した cookie ヘッダーの場合、値は ; で結合されます。
その他のすべてのヘッダーの場合、値は , で結合されます。

`message.headersDistinct`

追加: v18.3.0, v16.17.0

<Object>

message.headers と同様ですが、結合ロジックはなく、値は常に文字列の配列です。ヘッダーが一度しか受信されなかった場合でも同様です。

// 次のようなものが表示されます。
//
// { 'user-agent': ['curl/7.22.0'],
//   host: ['127.0.0.1:8000'],
//   accept: ['*/*'] }
console.log(request.headersDistinct)

`message.httpVersion`

追加: v0.1.1

<string>

サーバーリクエストの場合、クライアントによって送信された HTTP バージョン。クライアントレスポンスの場合、接続先のサーバーの HTTP バージョン。おそらく '1.1' または '1.0' です。

また、message.httpVersionMajor は最初の整数で、message.httpVersionMinor は 2 番目の整数です。

`message.method`

追加: v0.1.1

<string>

http.Server から取得したリクエストに対してのみ有効です。

文字列としてのリクエストメソッド。読み取り専用。例: 'GET', 'DELETE'。

`message.rawHeaders`

追加: v0.11.6

<string[]>

受信したとおりの生のリクエスト/レスポンスヘッダーリスト。

キーと値は同じリストにあります。タプルのリストではありません。そのため、偶数オフセットはキー値であり、奇数オフセットは関連付けられた値です。

ヘッダー名は小文字に変換されず、重複もマージされません。

// 次のようなものが表示されます。
//
// [ 'user-agent',
//   'これは一つしか存在できないため無効です',
//   'User-Agent',
//   'curl/7.22.0',
//   'Host',
//   '127.0.0.1:8000',
//   'ACCEPT',
//   '*/*' ]
console.log(request.rawHeaders)

`message.rawTrailers`

追加: v0.11.6

<string[]>

受信したとおりの生のリクエスト/レスポンストレーラーのキーと値。'end' イベントでのみ設定されます。

`message.setTimeout(msecs[, callback])`

追加: v0.5.9

msecs <number>
callback <Function>
戻り値: <http.IncomingMessage>

message.socket.setTimeout(msecs, callback) を呼び出します。

`message.socket`

追加: v0.3.0

<stream.Duplex>

接続に関連付けられた net.Socket オブジェクト。

HTTPS サポートでは、クライアントの認証詳細を取得するために request.socket.getPeerCertificate() を使用します。

このプロパティは、ユーザーが <net.Socket> 以外のソケットタイプを指定した場合、または内部的に null 化した場合を除き、<stream.Duplex> のサブクラスである <net.Socket> クラスのインスタンスであることが保証されています。

`message.statusCode`

追加: v0.1.1

<number>

http.ClientRequest から取得したレスポンスに対してのみ有効です。

3 桁の HTTP レスポンスステータスコード。例：404。

`message.statusMessage`

追加: v0.11.10

<string>

http.ClientRequest から取得したレスポンスに対してのみ有効です。

HTTP レスポンスステータスメッセージ (理由句)。例：OK または Internal Server Error。

`message.trailers`

追加: v0.3.0

<Object>

リクエスト/レスポンスのトレーラーオブジェクト。 'end' イベントでのみ設定されます。

`message.trailersDistinct`

追加: v18.3.0, v16.17.0

<Object>

message.trailers と同様ですが、結合ロジックがなく、一度だけ受信したヘッダーであっても、値は常に文字列の配列になります。 'end' イベントでのみ設定されます。

`message.url`

追加: v0.1.90

<string>

http.Server から取得したリクエストでのみ有効です。

リクエストの URL 文字列。これは、実際の HTTP リクエストに存在する URL のみを含みます。次のリクエストを例に取ります。

GET /status?name=ryan HTTP/1.1
Accept: text/plain

URL をその構成要素に解析するには：

new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`)

request.urlが'/status?name=ryan'で、process.env.HOSTが未定義の場合：

bash

$ node
> new URL(`http://${process.env.HOST ?? 'localhost'}${request.url}`);
URL {
  href: 'http://localhost/status?name=ryan',
  origin: 'http://localhost',
  protocol: 'http:',
  username: '',
  password: '',
  host: 'localhost',
  hostname: 'localhost',
  port: '',
  pathname: '/status',
  search: '?name=ryan',
  searchParams: URLSearchParams { 'name' => 'ryan' },
  hash: ''
}

process.env.HOSTをサーバーのホスト名に設定するか、この部分を完全に置き換えることを検討してください。req.headers.hostを使用する場合は、クライアントがカスタムのHostヘッダーを指定する可能性があるため、適切な検証を使用してください。

クラス: `http.OutgoingMessage`

追加: v0.1.17

拡張: <Stream>

このクラスは、http.ClientRequest および http.ServerResponse の親クラスとして機能します。これは、HTTP トランザクションの参加者の観点から見た、抽象的な送信メッセージです。

イベント: `'drain'`

追加: v0.3.6

メッセージのバッファが再び空になったときに発生します。

イベント: `'finish'`

追加: v0.1.17

送信が正常に完了したときに発生します。

イベント: `'prefinish'`

追加: v0.11.6

outgoingMessage.end()が呼び出された後に発生します。イベントが発生すると、すべてのデータが処理されていますが、必ずしも完全にフラッシュされているとは限りません。

`outgoingMessage.addTrailers(headers)`

追加: v0.3.0

headers <Object>

HTTP トレーラー（メッセージの最後にあるヘッダー）をメッセージに追加します。

トレーラーは、メッセージがチャンクエンコードされている場合のみ送信されます。そうでない場合、トレーラーは黙って破棄されます。

HTTP では、トレーラーを送信するために、Trailerヘッダーを送信する必要があります。このヘッダーの値には、ヘッダーフィールド名のリストが含まれます。例：

message.writeHead(200, { 'Content-Type': 'text/plain', Trailer: 'Content-MD5' })
message.write(fileData)
message.addTrailers({ 'Content-MD5': '7895bf4b8828b55ceaf47747b4bca667' })
message.end()

無効な文字を含むヘッダーフィールド名または値を設定しようとすると、TypeErrorがスローされます。

`outgoingMessage.appendHeader(name, value)`

追加: v18.3.0, v16.17.0

name <string> ヘッダー名
value <string> | <string[]> ヘッダー値
戻り値: <this>

単一のヘッダー値をヘッダーオブジェクトに追加します。

値が配列の場合、これはこのメソッドを複数回呼び出すことと同じです。

ヘッダーに以前の値がない場合、これはoutgoingMessage.setHeader(name, value)を呼び出すことと同じです。

クライアントリクエストまたはサーバーが作成されたときのoptions.uniqueHeadersの値に応じて、これにより、ヘッダーが複数回送信されるか、; を使用して結合された値で 1 回送信されることになります。

`outgoingMessage.connection`

追加: v0.3.0

非推奨: v15.12.0, v14.17.1 以降

[安定版: 0 - 非推奨]

安定版: 0 安定性: 0 - 非推奨: 代わりにoutgoingMessage.socketを使用してください。

outgoingMessage.socketのエイリアス。

`outgoingMessage.cork()`

追加: v13.2.0, v12.16.0

writable.cork()を参照してください。

`outgoingMessage.destroy([error])`

追加: v0.3.0

error <Error> オプション。errorイベントで発生させるエラー。
戻り値: <this>

メッセージを破棄します。ソケットがメッセージに関連付けられて接続されると、そのソケットも破棄されます。

`outgoingMessage.end(chunk[, encoding][, callback])`

[履歴]

バージョン	変更
v15.0.0	`chunk` パラメーターが `Uint8Array` になりました。
v0.11.6	`callback` 引数を追加。
v0.1.90	追加: v0.1.90

chunk <string> | <Buffer> | <Uint8Array>
encoding <string> オプション、デフォルト: utf8
callback <Function> オプション
戻り値: <this>

送信メッセージを終了します。まだ送信されていないボディの一部がある場合は、それらを基盤となるシステムにフラッシュします。メッセージがチャンク化されている場合は、終端チャンク 0\r\n\r\n を送信し、トレーラー（もしあれば）を送信します。

chunk が指定されている場合は、outgoingMessage.write(chunk, encoding) を呼び出し、その後に outgoingMessage.end(callback) を呼び出すのと同じです。

callback が提供された場合、メッセージが完了したときに呼び出されます（'finish' イベントのリスナーと同等）。

`outgoingMessage.flushHeaders()`

追加: v1.6.0

メッセージヘッダーをフラッシュします。

効率上の理由から、Node.js は通常、outgoingMessage.end()が呼び出されるか、メッセージデータの最初のチャンクが書き込まれるまでメッセージヘッダーをバッファリングします。次に、ヘッダーとデータを 1 つの TCP パケットにパックしようとします。

これは通常望ましい（TCP ラウンドトリップを節約できる）ですが、最初のデータがかなり後になるまで送信されない場合は望ましくありません。outgoingMessage.flushHeaders() は最適化をバイパスしてメッセージを起動します。

`outgoingMessage.getHeader(name)`

追加: v0.4.0

name <string> ヘッダーの名前
戻り値: <string> | <undefined>

指定された名前の HTTP ヘッダーの値を取得します。そのヘッダーが設定されていない場合、返される値は undefined になります。

`outgoingMessage.getHeaderNames()`

追加: v7.7.0

戻り値: <string[]>

現在の送信ヘッダーの一意の名前を含む配列を返します。すべての名前は小文字です。

`outgoingMessage.getHeaders()`

追加: v7.7.0

戻り値: <Object>

現在の送信ヘッダーの浅いコピーを返します。浅いコピーが使用されるため、さまざまなヘッダー関連の HTTP モジュールメソッドを別途呼び出すことなく、配列値を変更できます。返されるオブジェクトのキーはヘッダー名で、値はそれぞれのヘッダー値です。すべてのヘッダー名は小文字です。

outgoingMessage.getHeaders() メソッドによって返されるオブジェクトは、JavaScript の Object からプロトタイプ継承しません。つまり、obj.toString()、obj.hasOwnProperty()などの一般的な Object メソッドは定義されておらず、機能しません。

outgoingMessage.setHeader('Foo', 'bar')
outgoingMessage.setHeader('Set-Cookie', ['foo=bar', 'bar=baz'])

const headers = outgoingMessage.getHeaders()
// headers === { foo: 'bar', 'set-cookie': ['foo=bar', 'bar=baz'] }

`outgoingMessage.hasHeader(name)`

追加: v7.7.0

name <string>
戻り値: <boolean>

name で識別されるヘッダーが現在の送信ヘッダーに設定されている場合、true を返します。ヘッダー名は大文字と小文字を区別しません。

const hasContentType = outgoingMessage.hasHeader('content-type')

`outgoingMessage.headersSent`

追加: v0.9.3

<boolean>

読み取り専用。ヘッダーが送信された場合はtrue、それ以外の場合はfalse。

`outgoingMessage.pipe()`

追加: v9.0.0

http.OutgoingMessageの親クラスであるレガシーStreamクラスから継承されたstream.pipe()メソッドをオーバーライドします。

このメソッドを呼び出すと、outgoingMessageは書き込み専用ストリームであるため、Errorがスローされます。

`outgoingMessage.removeHeader(name)`

追加: v0.4.0

name <string> ヘッダー名

暗黙的な送信のためにキューに入れられたヘッダーを削除します。

outgoingMessage.removeHeader('Content-Encoding')

`outgoingMessage.setHeader(name, value)`

追加: v0.4.0

name <string> ヘッダー名
value <any> ヘッダー値
戻り値: <this>

単一のヘッダー値を設定します。送信される予定のヘッダーにヘッダーが既に存在する場合、その値は置き換えられます。同じ名前で複数のヘッダーを送信するには、文字列の配列を使用します。

`outgoingMessage.setHeaders(headers)`

追加: v19.6.0, v18.15.0

headers <Headers> | <Map>
戻り値: <this>

暗黙的なヘッダーに複数のヘッダー値を設定します。headersはHeadersまたはMapのインスタンスである必要があり、送信される予定のヘッダーにヘッダーが既に存在する場合、その値は置き換えられます。

const headers = new Headers({ foo: 'bar' })
outgoingMessage.setHeaders(headers)

または

const headers = new Map([['foo', 'bar']])
outgoingMessage.setHeaders(headers)

ヘッダーがoutgoingMessage.setHeaders()で設定されている場合、それらはresponse.writeHead()に渡されたヘッダーとマージされ、response.writeHead()に渡されたヘッダーが優先されます。

// content-type = text/plainを返します
const server = http.createServer((req, res) => {
  const headers = new Headers({ 'Content-Type': 'text/html' })
  res.setHeaders(headers)
  res.writeHead(200, { 'Content-Type': 'text/plain' })
  res.end('ok')
})

`outgoingMessage.setTimeout(msesc[, callback])`

追加: v0.9.12

msesc <number>
callback <Function> タイムアウトが発生したときに呼び出されるオプションの関数。timeout イベントにバインドするのと同じです。
戻り値: <this>

ソケットがメッセージに関連付けられ、接続されると、socket.setTimeout() が最初のパラメーターとして msecs を使用して呼び出されます。

`outgoingMessage.socket`

追加: v0.3.0

<stream.Duplex>

基になるソケットへの参照。通常、ユーザーはこのプロパティにアクセスする必要はありません。

outgoingMessage.end() を呼び出した後、このプロパティは null になります。

`outgoingMessage.uncork()`

追加: v13.2.0, v12.16.0

writable.uncork() を参照してください。

`outgoingMessage.writableCorked`

追加: v13.2.0, v12.16.0

<number>

outgoingMessage.cork() が呼び出された回数。

`outgoingMessage.writableEnded`

追加: v12.9.0

<boolean>

outgoingMessage.end() が呼び出された場合は true です。このプロパティは、データがフラッシュされたかどうかを示すものではありません。その目的には、代わりに message.writableFinished を使用してください。

`outgoingMessage.writableFinished`

追加: v12.7.0

<boolean>

すべてのデータが基盤となるシステムにフラッシュされた場合は true です。

`outgoingMessage.writableHighWaterMark`

追加: v12.9.0

<number>

割り当てられている場合の基になるソケットの highWaterMark。それ以外の場合は、writable.write() が false を返し始めるとき (16384) のデフォルトのバッファーレベル。

`outgoingMessage.writableLength`

追加: v12.9.0

<number>

バッファリングされたバイト数。

`outgoingMessage.writableObjectMode`

追加: v12.9.0

<boolean>

常に false。

`outgoingMessage.write(chunk[, encoding][, callback])`

[履歴]

バージョン	変更点
v15.0.0	`chunk` パラメーターが `Uint8Array` になりました。
v0.11.6	`callback` 引数が追加されました。
v0.1.29	追加: v0.1.29

chunk <string> | <Buffer> | <Uint8Array>
encoding <string> デフォルト: utf8
callback <Function>
戻り値: <boolean>

ボディのチャンクを送信します。このメソッドは複数回呼び出すことができます。

encoding 引数は、chunk が文字列の場合にのみ関連します。デフォルトは 'utf8' です。

callback 引数はオプションで、このデータのチャンクがフラッシュされたときに呼び出されます。

データ全体がカーネルバッファに正常にフラッシュされた場合は true を返します。データの一部または全部がユーザーメモリにキューイングされた場合は false を返します。バッファが再び空になると、'drain' イベントが発生します。

`http.METHODS`

追加: v0.11.8

<string[]>

パーサーでサポートされている HTTP メソッドのリスト。

`http.STATUS_CODES`

追加: v0.1.22

<Object>

すべての標準 HTTP レスポンスステータスコードと、それぞれの簡単な説明のコレクション。たとえば、http.STATUS_CODES[404] === 'Not Found' です。

`http.createServer([options][, requestListener])`

[履歴]

バージョン	変更点
v20.1.0, v18.17.0	`highWaterMark` オプションがサポートされました。
v18.0.0	`requestTimeout`、`headersTimeout`、`keepAliveTimeout`、および `connectionsCheckingInterval` オプションがサポートされました。
v18.0.0	`noDelay` オプションのデフォルト値が `true` になりました。
v17.7.0, v16.15.0	`noDelay`、`keepAlive`、および `keepAliveInitialDelay` オプションがサポートされました。
v13.3.0	`maxHeaderSize` オプションがサポートされました。
v13.8.0, v12.15.0, v10.19.0	`insecureHTTPParser` オプションがサポートされました。
v9.6.0, v8.12.0	`options` 引数がサポートされました。
v0.1.13	v0.1.13 で追加されました。

options <Object>
- connectionsCheckingInterval: 不完全なリクエストにおけるリクエストとヘッダーのタイムアウトをチェックするための間隔値をミリ秒単位で設定します。デフォルト: 30000。
- headersTimeout: クライアントから完全な HTTP ヘッダーを受信するまでのタイムアウト値をミリ秒単位で設定します。詳細については、server.headersTimeout を参照してください。デフォルト: 60000。
- highWaterMark <number> オプションで、すべての socket の readableHighWaterMark および writableHighWaterMark をオーバーライドします。これは IncomingMessage と ServerResponse の両方の highWaterMark プロパティに影響します。デフォルト: stream.getDefaultHighWaterMark() を参照してください。
- insecureHTTPParser <boolean> true に設定すると、寛容フラグが有効になった HTTP パーサーを使用します。安全でないパーサーの使用は避ける必要があります。詳細については、--insecure-http-parser を参照してください。デフォルト: false。
- IncomingMessage <http.IncomingMessage> 使用する IncomingMessage クラスを指定します。オリジナルの IncomingMessage を拡張するのに便利です。デフォルト: IncomingMessage。
- joinDuplicateHeaders <boolean> true に設定すると、このオプションは、重複を破棄するのではなく、リクエスト内の複数のヘッダーのフィールド行の値をコンマ (, ) で結合することを許可します。詳細については、message.headers を参照してください。デフォルト: false。
- keepAlive <boolean> true に設定すると、新しい受信接続を受信した直後にソケットでキープアライブ機能が有効になります。これは、[socket.setKeepAlive([enable][, initialDelay])][socket.setKeepAlive(enable, initialDelay)] で行われることと同様です。デフォルト: false。
- keepAliveInitialDelay <number> 正の数値に設定すると、アイドル状態のソケットで最初のキープアライブプローブが送信されるまでの初期遅延を設定します。デフォルト: 0。
- keepAliveTimeout: 最後の応答の書き込みを完了した後、ソケットが破棄される前に、サーバーが追加の受信データを待機する必要がある非アクティブ時間のミリ秒数。詳細については、server.keepAliveTimeout を参照してください。デフォルト: 5000。
- maxHeaderSize <number> このサーバーによって受信されるリクエストの --max-http-header-size の値をオプションでオーバーライドします。つまり、リクエストヘッダーの最大長（バイト単位）。デフォルト: 16384 (16 KiB)。
- noDelay <boolean> true に設定すると、新しい受信接続を受信した直後に Nagle アルゴリズムの使用が無効になります。デフォルト: true。
- requestTimeout: クライアントからリクエスト全体を受信するまでのタイムアウト値をミリ秒単位で設定します。詳細については、server.requestTimeout を参照してください。デフォルト: 300000。
- requireHostHeader <boolean> true に設定すると、仕様で義務付けられているように、Host ヘッダーがない HTTP/1.1 リクエストメッセージに対して、サーバーが 400 (不正なリクエスト) ステータスコードで応答するように強制します。デフォルト: true。
- ServerResponse <http.ServerResponse> 使用する ServerResponse クラスを指定します。オリジナルの ServerResponse を拡張するのに便利です。デフォルト: ServerResponse。
- uniqueHeaders <Array> 一度だけ送信する必要がある応答ヘッダーのリスト。ヘッダーの値が配列の場合、項目は ; を使用して結合されます。
- rejectNonStandardBodyWrites <boolean> true に設定すると、ボディを持たない HTTP レスポンスへの書き込み時にエラーがスローされます。デフォルト: false。
requestListener <Function>
戻り値: <http.Server>

http.Server の新しいインスタンスを返します。

requestListener は、自動的に 'request' イベントに追加される関数です。

ESMCJS

import http from 'node:http'

// データを受信するローカルサーバーを作成します
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

const http = require('node:http')

// データを受信するローカルサーバーを作成します
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

ESMCJS

import http from 'node:http'

// データを受信するローカルサーバーを作成します
const server = http.createServer()

// request イベントをリッスンします
server.on('request', (request, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

const http = require('node:http')

// データを受信するローカルサーバーを作成します
const server = http.createServer()

// request イベントをリッスンします
server.on('request', (request, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

`http.get(options[, callback])`

`http.get(url[, options][, callback])`

[履歴]

バージョン	変更点
v10.9.0	`url` パラメータを個別の `options` オブジェクトとともに渡せるようになりました。
v7.5.0	`options` パラメータは WHATWG `URL` オブジェクトにすることができます。
v0.3.6	v0.3.6 で追加

url <string> | <URL>
options <Object> http.request() と同じ options を受け入れますが、デフォルトではメソッドは GET に設定されます。
callback <Function>
戻り値: <http.ClientRequest>

ほとんどのリクエストはボディのない GET リクエストであるため、Node.js はこの便利なメソッドを提供しています。このメソッドと http.request() の唯一の違いは、デフォルトでメソッドが GET に設定され、req.end() が自動的に呼び出されることです。コールバックは、http.ClientRequest セクションで述べられている理由から、レスポンスデータを消費するように注意する必要があります。

callback は、http.IncomingMessage のインスタンスである単一の引数で呼び出されます。

JSON フェッチの例:

http
  .get('http://localhost:8000/', res => {
    const { statusCode } = res
    const contentType = res.headers['content-type']

    let error
    // 2xx のステータスコードはすべて成功したレスポンスを示しますが、
    // ここでは 200 のみを確認しています。
    if (statusCode !== 200) {
      error = new Error('リクエストに失敗しました。\n' + `ステータスコード: ${statusCode}`)
    } else if (!/^application\/json/.test(contentType)) {
      error = new Error('コンテンツタイプが無効です。\n' + `期待値: application/json, 受信値: ${contentType}`)
    }
    if (error) {
      console.error(error.message)
      // メモリを解放するためにレスポンスデータを消費します
      res.resume()
      return
    }

    res.setEncoding('utf8')
    let rawData = ''
    res.on('data', chunk => {
      rawData += chunk
    })
    res.on('end', () => {
      try {
        const parsedData = JSON.parse(rawData)
        console.log(parsedData)
      } catch (e) {
        console.error(e.message)
      }
    })
  })
  .on('error', e => {
    console.error(`エラーが発生しました: ${e.message}`)
  })

// データを受信するローカルサーバーを作成します
const server = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'application/json' })
  res.end(
    JSON.stringify({
      data: 'Hello World!',
    })
  )
})

server.listen(8000)

`http.globalAgent`

[履歴]

バージョン	変更点
v19.0.0	エージェントはデフォルトで HTTP Keep-Alive と 5 秒のタイムアウトを使用するようになりました。
v0.5.9	追加: v0.5.9

<http.Agent>

すべての HTTP クライアントリクエストのデフォルトとして使用される Agent のグローバルインスタンス。デフォルトの Agent 構成とは異なり、keepAlive が有効になっており、timeout が 5 秒に設定されています。

`http.maxHeaderSize`

追加: v11.6.0, v10.15.0

<number>

HTTP ヘッダーの最大許容サイズ（バイト単位）を指定する読み取り専用プロパティ。デフォルトは 16 KiB です。--max-http-header-size CLI オプションを使用して構成できます。

これは、maxHeaderSize オプションを渡すことで、サーバーおよびクライアントリクエストに対して上書きできます。

`http.request(options[, callback])`

`http.request(url[, options][, callback])`

[履歴]

バージョン	変更点
v16.7.0, v14.18.0	`URL` オブジェクトを使用すると、解析されたユーザー名とパスワードが適切に URI デコードされるようになりました。
v15.3.0, v14.17.0	AbortSignal でリクエストを中断できるようになりました。
v13.3.0	`maxHeaderSize` オプションがサポートされるようになりました。
v13.8.0, v12.15.0, v10.19.0	`insecureHTTPParser` オプションがサポートされるようになりました。
v10.9.0	`url` パラメータを個別の `options` オブジェクトとともに渡せるようになりました。
v7.5.0	`options` パラメータは WHATWG `URL` オブジェクトにすることができます。
v0.3.6	追加: v0.3.6

url <string> | <URL>
options <Object>
- agent <http.Agent> | <boolean> Agent の動作を制御します。可能な値:
- undefined (デフォルト): このホストとポートに対して http.globalAgent を使用します。
- Agent オブジェクト: 渡された Agent を明示的に使用します。
- false: デフォルト値を持つ新しい Agent を使用させます。
- auth <string> Authorization ヘッダーを計算するための基本認証 ('user:password')。
- createConnection <Function> agent オプションが使用されていない場合にリクエストに使用するソケット/ストリームを生成する関数。これは、デフォルトの createConnection 関数をオーバーライドするためだけにカスタム Agent クラスを作成するのを避けるために使用できます。詳細については、agent.createConnection() を参照してください。任意の Duplex ストリームが有効な戻り値です。
- defaultPort <number> プロトコルのデフォルトポート。デフォルト: Agent が使用されている場合は agent.defaultPort、それ以外の場合は undefined。
- family <number> host または hostname の解決時に使用する IP アドレスファミリ。有効な値は 4 または 6 です。指定しない場合は、IP v4 と v6 の両方が使用されます。
- headers <Object> リクエストヘッダーを含むオブジェクト。
- hints <number> オプションの dns.lookup() のヒント。
- host <string> リクエストを発行するサーバーのドメイン名または IP アドレス。デフォルト: 'localhost'。
- hostname <string> host のエイリアス。url.parse() をサポートするために、host と hostname の両方が指定されている場合は hostname が使用されます。
- insecureHTTPParser <boolean> true に設定すると、寛容フラグが有効になった HTTP パーサーを使用します。安全でないパーサーの使用は避ける必要があります。詳細については、--insecure-http-parser を参照してください。デフォルト: false
- joinDuplicateHeaders <boolean> 重複を破棄する代わりに、リクエスト内の複数のヘッダーのフィールドライン値を , で結合します。詳細については、message.headers を参照してください。デフォルト: false。
- localAddress <string> ネットワーク接続をバインドするローカルインターフェイス。
- localPort <number> 接続元のローカルポート。
- lookup <Function> カスタムルックアップ関数。デフォルト: dns.lookup()。
- maxHeaderSize <number> オプションで、サーバーから受信した応答の --max-http-header-size の値（応答ヘッダーの最大長（バイト単位））を上書きします。デフォルト: 16384 (16 KiB)。
- method <string> HTTP リクエストメソッドを指定する文字列。デフォルト: 'GET'。
- path <string> リクエストパス。クエリ文字列（存在する場合）を含める必要があります。例: '/index.html?page=12'。リクエストパスに不正な文字が含まれている場合は例外がスローされます。現在、スペースのみが拒否されますが、将来変更される可能性があります。デフォルト: '/'。
- port <number> リモートサーバーのポート。デフォルト: 設定されている場合は defaultPort、それ以外の場合は 80。
- protocol <string> 使用するプロトコル。デフォルト: 'http:'。
- setDefaultHeaders <boolean>: Connection、Content-Length、Transfer-Encoding、Host などのデフォルトヘッダーを自動的に追加するかどうかを指定します。false に設定した場合、必要なすべてのヘッダーを手動で追加する必要があります。デフォルトは true です。
- setHost <boolean>: Host ヘッダーを自動的に追加するかどうかを指定します。指定した場合、これは setDefaultHeaders を上書きします。デフォルトは true です。
- signal <AbortSignal>: 進行中のリクエストを中断するために使用できる AbortSignal。
- socketPath <string> Unix ドメインソケット。host または port のいずれかが指定されている場合は使用できません。これらは TCP ソケットを指定するためです。
- timeout <number>: ソケットのタイムアウトをミリ秒単位で指定する数値。これにより、ソケットが接続される前にタイムアウトが設定されます。
- uniqueHeaders <Array> 1 回だけ送信する必要があるリクエストヘッダーのリスト。ヘッダーの値が配列の場合、アイテムは ; を使用して結合されます。
callback <Function>
戻り値: <http.ClientRequest>

socket.connect() の options もサポートされています。

Node.js は、HTTP リクエストを行うために、サーバーごとに複数の接続を維持します。この関数を使用すると、透過的にリクエストを発行できます。

url は、文字列または URL オブジェクトにすることができます。url が文字列の場合、new URL() で自動的に解析されます。URL](/ja/api/url#the-whatwg-url-api) オブジェクトの場合、自動的に通常の options オブジェクトに変換されます。

url と options の両方が指定されている場合、オブジェクトはマージされ、options プロパティが優先されます。

オプションの callback パラメータは、'response' イベントの 1 回限りのリスナーとして追加されます。

http.request() は、http.ClientRequest クラスのインスタンスを返します。ClientRequest インスタンスは、書き込み可能なストリームです。POST リクエストでファイルをアップロードする必要がある場合は、ClientRequest オブジェクトに書き込みます。

ESMCJS

import http from 'node:http'
import { Buffer } from 'node:buffer'

const postData = JSON.stringify({
  msg: 'Hello World!',
})

const options = {
  hostname: 'www.google.com',
  port: 80,
  path: '/upload',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData),
  },
}

const req = http.request(options, res => {
  console.log(`STATUS: ${res.statusCode}`)
  console.log(`HEADERS: ${JSON.stringify(res.headers)}`)
  res.setEncoding('utf8')
  res.on('data', chunk => {
    console.log(`BODY: ${chunk}`)
  })
  res.on('end', () => {
    console.log('No more data in response.')
  })
})

req.on('error', e => {
  console.error(`problem with request: ${e.message}`)
})

// Write data to request body
req.write(postData)
req.end()

const http = require('node:http')

const postData = JSON.stringify({
  msg: 'Hello World!',
})

const options = {
  hostname: 'www.google.com',
  port: 80,
  path: '/upload',
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'Content-Length': Buffer.byteLength(postData),
  },
}

const req = http.request(options, res => {
  console.log(`STATUS: ${res.statusCode}`)
  console.log(`HEADERS: ${JSON.stringify(res.headers)}`)
  res.setEncoding('utf8')
  res.on('data', chunk => {
    console.log(`BODY: ${chunk}`)
  })
  res.on('end', () => {
    console.log('No more data in response.')
  })
})

req.on('error', e => {
  console.error(`problem with request: ${e.message}`)
})

// Write data to request body
req.write(postData)
req.end()

上記の例では、req.end() が呼び出されました。http.request() では、リクエストボディに書き込まれるデータがない場合でも、リクエストの終了を示すために常に req.end() を呼び出す必要があります。

リクエスト中にエラーが発生した場合 (DNS 解決、TCP レベルのエラー、または実際の HTTP 解析エラーなど)、返されたリクエストオブジェクトで 'error' イベントが発生します。すべての 'error' イベントと同様に、リスナーが登録されていない場合はエラーがスローされます。

注意すべき特殊なヘッダーがいくつかあります。

'Connection: keep-alive' を送信すると、Node.js に、次のリクエストまでサーバーへの接続を維持する必要があることが通知されます。
'Content-Length' ヘッダーを送信すると、デフォルトのチャンクエンコーディングが無効になります。
'Expect' ヘッダーを送信すると、リクエストヘッダーがすぐに送信されます。通常、'Expect: 100-continue' を送信する場合は、タイムアウトと 'continue' イベントのリスナーの両方を設定する必要があります。詳細については、RFC 2616 セクション 8.2.3 を参照してください。
Authorization ヘッダーを送信すると、基本認証を計算するための auth オプションの使用が上書きされます。

URL を options として使用する例:

const options = new URL('http://abc:')

const req = http.request(options, res => {
  // ...
})

成功したリクエストでは、次のイベントが次の順序で発生します。

'socket'
'response'
- res オブジェクトでの 'data' (任意の回数)。(応答ボディが空の場合、たとえばほとんどのリダイレクトでは 'data' はまったく発生しません)
- res オブジェクトでの 'end'
'close'

接続エラーの場合、次のイベントが発生します。

'socket'
'error'
'close'

応答を受信する前に接続が早期に切断された場合、次のイベントが次の順序で発生します。

'socket'
'Error: socket hang up' というメッセージと 'ECONNRESET' というコードのエラーを伴う 'error'
'close'

応答を受信した後に接続が早期に切断された場合、次のイベントが次の順序で発生します。

'socket'
'response'
- res オブジェクトでの 'data' (任意の回数)
(ここで接続が閉じられます)
res オブジェクトでの 'aborted'
'close'
'Error: aborted' というメッセージと 'ECONNRESET' というコードのエラーを伴う res オブジェクトでの 'error'
res オブジェクトでの 'close'

ソケットが割り当てられる前に req.destroy() が呼び出された場合、次のイベントが次の順序で発生します。

(req.destroy() がここで呼び出されます)
'Error: socket hang up' というメッセージと 'ECONNRESET' というコードのエラー、または req.destroy() が呼び出されたエラーを伴う 'error'
'close'

接続が成功する前に req.destroy() が呼び出された場合、次のイベントが次の順序で発生します。

'socket'
(req.destroy() がここで呼び出されます)
'Error: socket hang up' というメッセージと 'ECONNRESET' というコードのエラー、または req.destroy() が呼び出されたエラーを伴う 'error'
'close'

応答を受信した後に req.destroy() が呼び出された場合、次のイベントが次の順序で発生します。

'socket'
'response'
- res オブジェクトでの 'data' (任意の回数)
(req.destroy() がここで呼び出されます)
res オブジェクトでの 'aborted'
'close'
'Error: aborted' というメッセージと 'ECONNRESET' というコードのエラー、または req.destroy() が呼び出されたエラーを伴う res オブジェクトでの 'error'
res オブジェクトでの 'close'

ソケットが割り当てられる前に req.abort() が呼び出された場合、次のイベントが次の順序で発生します。

(req.abort() がここで呼び出されます)
'abort'
'close'

接続が成功する前に req.abort() が呼び出された場合、次のイベントが次の順序で発生します。

'socket'
(req.abort() がここで呼び出されます)
'abort'
'Error: socket hang up' というメッセージと 'ECONNRESET' というコードのエラーを伴う 'error'
'close'

応答を受信した後に req.abort() が呼び出された場合、次のイベントが次の順序で発生します。

'socket'
'response'
- res オブジェクトでの 'data' (任意の回数)
(req.abort() がここで呼び出されます)
'abort'
res オブジェクトでの 'aborted'
'Error: aborted' というメッセージと 'ECONNRESET' というコードのエラーを伴う res オブジェクトでの 'error'。
'close'
res オブジェクトでの 'close'

timeout オプションを設定するか、setTimeout() 関数を使用しても、リクエストが中止されたり、'timeout' イベントが追加される以外には何も行われません。

AbortSignal を渡して、対応する AbortController で abort() を呼び出すと、リクエストで .destroy() を呼び出すのと同じように動作します。具体的には、'error' イベントが、メッセージ 'AbortError: The operation was aborted'、コード 'ABORT_ERR'、および cause (提供された場合) を持つエラーとともに発生します。

`http.validateHeaderName(name[, label])`

[履歴]

バージョン	変更
v19.5.0, v18.14.0	`label` パラメーターが追加されました。
v14.3.0	追加: v14.3.0

name <string>
label <string> エラーメッセージのラベル。デフォルト: 'Header name'。

res.setHeader(name, value) が呼び出されたときに実行される、指定された name の低レベル検証を実行します。

不正な値を name として渡すと、code: 'ERR_INVALID_HTTP_TOKEN' で識別される TypeError がスローされます。

HTTP リクエストまたはレスポンスにヘッダーを渡す前に、このメソッドを使用する必要はありません。HTTP モジュールは、そのようなヘッダーを自動的に検証します。

例：

ESMCJS

import { validateHeaderName } from 'node:http'

try {
  validateHeaderName('')
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code) // --> 'ERR_INVALID_HTTP_TOKEN'
  console.error(err.message) // --> 'Header name must be a valid HTTP token [""]'
}

const { validateHeaderName } = require('node:http')

try {
  validateHeaderName('')
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code) // --> 'ERR_INVALID_HTTP_TOKEN'
  console.error(err.message) // --> 'Header name must be a valid HTTP token [""]'
}

`http.validateHeaderValue(name, value)`

追加: v14.3.0

name <string>
value <any>

res.setHeader(name, value) が呼び出されたときに実行される、指定された value の低レベル検証を実行します。

不正な値を value として渡すと、TypeError がスローされます。

未定義の値のエラーは code: 'ERR_HTTP_INVALID_HEADER_VALUE' で識別されます。
無効な値の文字エラーは code: 'ERR_INVALID_CHAR' で識別されます。

例：

ESMCJS

import { validateHeaderValue } from 'node:http'

try {
  validateHeaderValue('x-my-header', undefined)
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code === 'ERR_HTTP_INVALID_HEADER_VALUE') // --> true
  console.error(err.message) // --> 'Invalid value "undefined" for header "x-my-header"'
}

try {
  validateHeaderValue('x-my-header', 'oʊmɪɡə')
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code === 'ERR_INVALID_CHAR') // --> true
  console.error(err.message) // --> 'Invalid character in header content ["x-my-header"]'
}

const { validateHeaderValue } = require('node:http')

try {
  validateHeaderValue('x-my-header', undefined)
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code === 'ERR_HTTP_INVALID_HEADER_VALUE') // --> true
  console.error(err.message) // --> 'Invalid value "undefined" for header "x-my-header"'
}

try {
  validateHeaderValue('x-my-header', 'oʊmɪɡə')
} catch (err) {
  console.error(err instanceof TypeError) // --> true
  console.error(err.code === 'ERR_INVALID_CHAR') // --> true
  console.error(err.message) // --> 'Invalid character in header content ["x-my-header"]'
}

`http.setMaxIdleHTTPParsers(max)`

追加: v18.8.0, v16.18.0

max <number> デフォルト: 1000.

アイドル状態の HTTP パーサーの最大数を設定します。

`WebSocket`

追加: v22.5.0

WebSocket のブラウザ互換実装。

HTTP ​

クラス: http.Agent ​

new Agent([options]) ​

agent.createConnection(options[, callback]) ​

agent.keepSocketAlive(socket) ​

agent.reuseSocket(socket, request) ​

agent.destroy() ​

agent.freeSockets ​

agent.getName([options]) ​

agent.maxFreeSockets ​

agent.maxSockets ​

agent.maxTotalSockets ​

agent.requests ​

agent.sockets ​

クラス: http.ClientRequest ​

イベント: 'abort' ​

イベント: 'close' ​

イベント: 'connect' ​

イベント: 'continue' ​

イベント: 'finish' ​

イベント: 'information' ​

イベント: 'response' ​

イベント: 'socket' ​

イベント: 'timeout' ​

イベント: 'upgrade' ​

request.abort() ​

request.aborted ​

request.connection ​

request.cork() ​

request.end([data[, encoding]][, callback]) ​

request.destroy([error]) ​

request.destroyed ​

request.finished ​

request.flushHeaders() ​

request.getHeader(name) ​

request.getHeaderNames() ​

request.getHeaders() ​

request.getRawHeaderNames() ​

request.hasHeader(name) ​

request.maxHeadersCount ​

request.path ​

request.method ​

request.host ​

request.protocol ​

request.removeHeader(name) ​

request.reusedSocket ​

request.setHeader(name, value) ​

request.setNoDelay([noDelay]) ​

request.setSocketKeepAlive([enable][, initialDelay]) ​

request.setTimeout(timeout[, callback]) ​

request.socket ​

request.uncork() ​

request.writableEnded ​

request.writableFinished ​

request.write(chunk[, encoding][, callback]) ​

クラス: http.Server ​

イベント: 'checkContinue' ​

イベント: 'checkExpectation' ​

イベント: 'clientError' ​

Event: 'close' ​

Event: 'connect' ​

Event: 'connection' ​

イベント: 'dropRequest' ​

イベント: 'request' ​

イベント: 'upgrade' ​

server.close([callback]) ​

server.closeAllConnections() ​

server.closeIdleConnections() ​

server.headersTimeout ​

server.listen() ​

server.listening ​

server.maxHeadersCount ​

server.requestTimeout ​

server.setTimeout([msecs][, callback]) ​

server.maxRequestsPerSocket ​

server.timeout ​

server.keepAliveTimeout ​

server[Symbol.asyncDispose]() ​

クラス: http.ServerResponse ​

イベント: 'close' ​

HTTP

クラス: `http.Agent`

`new Agent([options])`

`agent.createConnection(options[, callback])`

`agent.keepSocketAlive(socket)`

`agent.reuseSocket(socket, request)`

`agent.destroy()`

`agent.freeSockets`

`agent.getName([options])`

`agent.maxFreeSockets`

`agent.maxSockets`

`agent.maxTotalSockets`

`agent.requests`

`agent.sockets`

クラス: `http.ClientRequest`

イベント: `'abort'`

イベント: `'close'`

イベント: `'connect'`

イベント: `'continue'`

イベント: `'finish'`

イベント: `'information'`

イベント: `'response'`

イベント: `'socket'`

イベント: `'timeout'`

イベント: `'upgrade'`

`request.abort()`

`request.aborted`

`request.connection`

`request.cork()`

`request.end([data[, encoding]][, callback])`

`request.destroy([error])`

`request.destroyed`

`request.finished`

`request.flushHeaders()`

`request.getHeader(name)`

`request.getHeaderNames()`

`request.getHeaders()`

`request.getRawHeaderNames()`

`request.hasHeader(name)`

`request.maxHeadersCount`

`request.path`

`request.method`

`request.host`

`request.protocol`

`request.removeHeader(name)`

`request.reusedSocket`

`request.setHeader(name, value)`

`request.setNoDelay([noDelay])`

`request.setSocketKeepAlive([enable][, initialDelay])`

`request.setTimeout(timeout[, callback])`

`request.socket`

`request.uncork()`

`request.writableEnded`

`request.writableFinished`

`request.write(chunk[, encoding][, callback])`

クラス: `http.Server`

イベント: `'checkContinue'`

イベント: `'checkExpectation'`

イベント: `'clientError'`

Event: `'close'`

Event: `'connect'`

Event: `'connection'`

イベント: `'dropRequest'`

イベント: `'request'`

イベント: `'upgrade'`

`server.close([callback])`

`server.closeAllConnections()`

`server.closeIdleConnections()`

`server.headersTimeout`

`server.listen()`

`server.listening`

`server.maxHeadersCount`

`server.requestTimeout`

`server.setTimeout([msecs][, callback])`

`server.maxRequestsPerSocket`

`server.timeout`

`server.keepAliveTimeout`

`server[Symbol.asyncDispose]()`

クラス: `http.ServerResponse`

イベント: `'close'`