HTTP

[Stable: 2 - 安定]

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

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

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 プロセスが実行され続けないように、unref されます (socket.unref() を参照)。

未使用のソケットは OS リソースを消費するため、Agent インスタンスが不要になった場合は、destroy() することをお勧めします。

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

http.get(options, (res) => {
  // Do stuff
}).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,  // このリクエストのためだけに新しいエージェントを作成します
}, (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: keep-alive ヘッダーは、Connection ヘッダーが明示的に指定されている場合、または keepAlive および maxSockets オプションがそれぞれ false および Infinity に設定されている場合を除き、エージェントを使用する際に常に送信されます。この場合、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> ソケットタイムアウト（ミリ秒単位）。これは、ソケットが作成されたときにタイムアウトを設定します。

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

それらのいずれかを構成するには、カスタム 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 に渡すかのいずれかの方法で提供できます。

このメソッドは、<net.Socket> クラス (<stream.Duplex> のサブクラス) のインスタンスを返すことが保証されています。ただし、ユーザーが <net.Socket> 以外のソケットタイプを指定した場合を除きます。

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

`agent.keepSocketAlive(socket)`

追加: v8.1.0

socket <stream.Duplex>

socket がリクエストから切り離され、Agent によって維持できる場合に呼び出されます。デフォルトの動作は次のとおりです。

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

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

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()`

Added in: v0.11.4

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

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

`agent.freeSockets`

[履歴]

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

<Object>

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

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

`agent.getName([options])`

[履歴]

バージョン	変更
v17.7.0, v16.15.0	`options` パラメータはオプションになりました。
v0.11.4	Added in: 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`

Added in: v0.11.7

<number>

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

`agent.maxSockets`

Added in: v0.3.6

<number>

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

`agent.maxTotalSockets`

Added in: v14.5.0, v12.19.0

<number>

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

`agent.requests`

[履歴]

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

<Object>

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

`agent.sockets`

[履歴]

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

<Object>

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

Class: `http.ClientRequest`

Added in: 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' イベントは発生しません。また、データが読み取られるまで、メモリを消費し続け、最終的には「process out of memory」エラーにつながる可能性があります。

下位互換性のため、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) を使用して、ボディの長さをバイト単位で決定します。

Event: `'abort'`

Added in: v1.4.1

Deprecated since: v17.0.0, v16.12.0

[Stable: 0 - Deprecated]

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

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

Event: `'close'`

Added in: v0.5.4

リクエストが完了したか、またはその基になる接続が (レスポンスの完了前に) 途中で終了したことを示します。

Event: `'connect'`

Added in: 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

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

イベント: `'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',
};

// Make a 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',
};

// Make a request
const req = http.request(options);
req.end();

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

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

Event: `'response'`

追加: v0.1.0

response <http.IncomingMessage>

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

Event: `'socket'`

追加: v0.5.3

socket <stream.Duplex>

このイベントには、<net.Socket> クラス（<stream.Duplex> のサブクラス）のインスタンスが渡されることが保証されます。ただし、ユーザーが <net.Socket> 以外のソケットタイプを指定した場合は除きます。

Event: `'timeout'`

追加: v0.7.8

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

参照: request.setTimeout()。

Event: `'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); // echo back
});

// サーバーが実行されたので
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); // echo back
});

// サーバーが実行されたので
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()`

Added in: v0.3.8

Deprecated since: v14.1.0, v13.14.0

[Stable: 0 - Deprecated]

Stable: 0 安定性: 0 - Deprecated: 代わりにrequest.destroy()を使用してください。

リクエストを中断としてマークします。これを呼び出すと、レスポンス内の残りのデータが破棄され、ソケットが破棄されます。

`request.aborted`

[History]

Version	Changes
v17.0.0, v16.12.0	Deprecated since: v17.0.0, v16.12.0
v11.0.0	`aborted` プロパティはタイムスタンプの数値ではなくなりました。
v0.11.14	Added in: v0.11.14

[Stable: 0 - Deprecated]

Stable: 0 安定性: 0 - Deprecated. 代わりにrequest.destroyedを確認してください。

<boolean>

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

`request.connection`

Added in: v0.3.0

Deprecated since: v13.0.0

[Stable: 0 - Deprecated]

Stable: 0 安定性: 0 - Deprecated. request.socketを使用してください。

<stream.Duplex>

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

`request.cork()`

Added in: v13.2.0, v12.16.0

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

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

[History]

Version	Changes
v15.0.0	`data` パラメータは `Uint8Array` になりました。
v10.0.0	このメソッドは `ClientRequest` への参照を返すようになりました。
v0.1.90	Added in: 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	Added in: v0.3.0

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

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

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

`request.destroyed`

Added in: v14.1.0, v13.14.0

<boolean>

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

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

`request.finished`

Added in: v0.0.1

Deprecated since: v13.4.0, v12.16.0

[Stable: 0 - Deprecated]

Stable: 0 Stability: 0 - Deprecated。request.writableEnded を使用してください。

<boolean>

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

`request.flushHeaders()`

Added in: v1.6.0

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

効率上の理由から、Node.js は通常、request.end() が呼び出されるか、最初のリクエストデータのチャンクが書き込まれるまで、リクエストヘッダーをバッファリングします。次に、リクエストヘッダーとデータを 1 つの 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' は数値型
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)`

Added in: 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])`

Added in: v0.5.9

noDelay <boolean>

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

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

Added in: 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>以外のソケットタイプを指定しない限り、<net.Socket>クラス、<stream.Duplex>のサブクラスのインスタンスであることが保証されています。

`request.uncork()`

Added in: v13.2.0, v12.16.0

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

`request.writableEnded`

Added in: v12.9.0

<boolean>

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

`request.writableFinished`

Added in: v12.7.0

<boolean>

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

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

[履歴]

バージョン	変更点
v15.0.0	`chunk` パラメータが `Uint8Array` になりました。
v0.1.29	Added in: v0.1.29

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

本文のチャンクを送信します。このメソッドは複数回呼び出すことができます。Content-Length が設定されていない場合、データは自動的に HTTP チャンク転送エンコーディングでエンコードされ、サーバーはデータの終了時期を知ることができます。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');
});

イベント: `'close'`

追加: v0.1.4

サーバーが閉じるときに発生します。

イベント: `'connect'`

追加: v0.7.0

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

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

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

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

イベント: `'connection'`

追加: v0.1.0

socket <stream.Duplex>

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

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

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

イベント: `'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接続の場合）。

イベント: `'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>以外のソケットタイプを指定しない限り、このイベントには<net.Socket>クラス（<stream.Duplex>のサブクラス）のインスタンスが渡されることが保証されています。

`server.close([callback])`

[History]

Version	Changes
v19.0.0	メソッドは、戻る前にアイドル状態の接続を閉じます。
v0.1.90	Added in: 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('server on port 8000 closed successfully');
  });
}, 10000);

`server.closeAllConnections()`

Added in: 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('server on port 8000 closed successfully');
  });
  // すべての接続を閉じ、サーバーが正常に閉じるようにします
  server.closeAllConnections();
}, 10000);

`server.closeIdleConnections()`

Added in: 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('server on port 8000 closed successfully');
  });
  // keep-alive接続など、アイドル状態の接続を閉じます。 残りのアクティブな接続が終了すると、サーバーは閉じます
  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 (制限なし)

keep-alive 接続を閉じる前にソケットが処理できる最大リクエスト数。

値 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 を指定すると、HTTPサーバーはキープアライブタイムアウトがなかったNode.jsの8.0.0より前のバージョンと同様に動作します。

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

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

Added in: 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`

Added in: v0.3.0

Deprecated since: v13.0.0

[Stable: 0 - Deprecated]

Stable: 0 Stability: 0 - 非推奨。response.socketを使用してください。

<stream.Duplex>

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

`response.cork()`

Added in: v13.2.0, v12.16.0

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

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

[History]

Version	Changes
v15.0.0	`data` パラメータに `Uint8Array` が使用できるようになりました。
v10.0.0	このメソッドは `ServerResponse` への参照を返すようになりました。
v0.1.90	Added in: 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`

Added in: v0.0.2

Deprecated since: v13.4.0, v12.16.0

[Stable: 0 - Deprecated]

Stable: 0 Stability: 0 - Deprecated. response.writableEnded を使用してください。

<boolean>

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

`response.flushHeaders()`

Added in: v1.6.0

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

`response.getHeader(name)`

Added in: 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 is 'text/html'
const contentLength = response.getHeader('Content-Length');
// contentLength is of type number
const setCookie = response.getHeader('set-cookie');
// setCookie is of type string[]

`response.getHeaderNames()`

Added in: 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()`

Added in: 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)`

Added in: v7.7.0

name <string>
戻り値: <boolean>

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

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

`response.headersSent`

Added in: v0.9.3

<boolean>

Boolean (読み取り専用)。ヘッダーが送信された場合は true、そうでない場合は false。

`response.removeHeader(name)`

Added in: v0.4.0

name <string>

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

response.removeHeader('Content-Encoding');

`response.req`

Added in: 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])`

Added in: v0.9.12

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

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

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

`response.socket`

Added in: 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`

Added in: v0.4.0

<number> Default: 200

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

response.statusCode = 404;

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

`response.statusMessage`

Added in: v0.11.8

<string>

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

response.statusMessage = 'Not found';

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

`response.strictContentLength`

Added in: v18.10.0, v16.18.0

<boolean> Default: false

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

`response.uncork()`

Added in: v13.2.0, v12.16.0

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

`response.writableEnded`

Added in: v12.9.0

<boolean>

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

`response.writableFinished`

Added in: v12.7.0

<boolean>

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

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

[History]

Version	Changes
v15.0.0	`chunk`パラメータは`Uint8Array`にすることができます。
v0.1.29	Added in: v0.1.29

chunk <string> | <Buffer> | <Uint8Array>
encoding <string> Default: 'utf8'
callback <Function>
Returns: <boolean>

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

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

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

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

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

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

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

`response.writeContinue()`

Added in: v0.3.0

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

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

[履歴]

バージョン	変更点
v18.11.0	ヒントをオブジェクトとして渡せるようになりました。
v18.11.0	Added in: v18.11.0

hints <Object>
callback <Function>

リンクされたリソースをユーザーエージェントがプリロード/プリコネクトできることを示すLinkヘッダーとともに、HTTP/1.1 103 Early Hintsメッセージをクライアントに送信します。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	ヘッダーを配列として渡せるようになりました。
v11.10.0, v10.17.0	`writeHead()`から`this`を返すことで、`end()`との連鎖を可能にしました。
v5.11.0, v4.4.5	`statusCode`が`[100, 999]`の範囲の数値でない場合、`RangeError`がスローされます。
v0.1.30	Added in: 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);

このメソッドは、メッセージに対して1回だけ呼び出す必要があり、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()`

Added in: v10.0.0

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

Class: `http.IncomingMessage`

[履歴]

バージョン	変更
v15.5.0	受信データが消費されると、`destroyed` の値が `true` を返します。
v13.1.0, v12.16.0	`readableHighWaterMark` の値がソケットの値を反映します。
v0.1.17	Added in: v0.1.17

拡張: <stream.Readable>

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

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

イベント: `'aborted'`

Added in: v0.3.8

Deprecated since: v17.0.0, v16.12.0

[安定版: 0 - 非推奨]

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

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

イベント: `'close'`

[履歴]

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

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

`message.aborted`

Added in: v10.1.0

Deprecated since: v17.0.0, v16.12.0

[安定版: 0 - 非推奨]

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

<boolean>

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

`message.complete`

Added in: 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(
        'The connection was terminated while the message was still being sent');
  });
});

`message.connection`

Added in: v0.1.90

Deprecated since: v16.0.0

[Stable: 0 - Deprecated]

Stable: 0 Stability: 0 - Deprecated. message.socket を使用してください。

message.socket のエイリアスです。

`message.destroy([error])`

[History]

Version	Changes
v14.5.0, v12.19.0	その関数は、他の Readable ストリームとの整合性のために `this` を返します。
v0.3.0	Added in: v0.3.0

error <Error>
Returns: <this>

IncomingMessage を受信したソケットで destroy() を呼び出します。error が提供されている場合、'error' イベントがソケット上で発行され、error がイベントのリスナーへの引数として渡されます。

`message.headers`

[History]

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

<Object>

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

ヘッダー名と値のキーと値のペア。ヘッダー名は小文字です。

// Prints something like:
//
// { '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`

Added in: v18.3.0, v16.17.0

<Object>

message.headers と似ていますが、結合ロジックがなく、値は常に文字列の配列です。ヘッダーが1回だけ受信された場合でも同様です。

// Prints something like:
//
// { 'user-agent': ['curl/7.22.0'],
//   host: ['127.0.0.1:8000'],
//   accept: ['*/*'] }
console.log(request.headersDistinct);

`message.httpVersion`

Added in: v0.1.1

<string>

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

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

`message.method`

Added in: v0.1.1

<string>

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

リクエストメソッドを文字列として表します。読み取り専用です。例： 'GET', 'DELETE'。

`message.rawHeaders`

Added in: v0.11.6

<string[]>

生のリクエスト/レスポンスヘッダーのリストは、受信したとおりに正確に記述されています。

キーと値は同じリスト内にあります。タプルのリストではありません。したがって、偶数番号のオフセットはキーの値であり、奇数番号のオフセットは関連する値です。

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

// Prints something like:
//
// [ 'user-agent',
//   'this is invalid because there can be only one',
//   'User-Agent',
//   'curl/7.22.0',
//   'Host',
//   '127.0.0.1:8000',
//   'ACCEPT',
//   '*/*' ]
console.log(request.rawHeaders);

`message.rawTrailers`

Added in: v0.11.6

<string[]>

生のリクエスト/レスポンストレーラーのキーと値は、受信したとおりに正確に記述されています。'end' イベントでのみ入力されます。

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

Added in: v0.5.9

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

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

`message.socket`

Added in: v0.3.0

<stream.Duplex>

コネクションに関連付けられた net.Socket オブジェクト。

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

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

`message.statusCode`

Added in: v0.1.1

<number>

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

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

`message.statusMessage`

Added in: v0.11.10

<string>

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

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

`message.trailers`

Added in: v0.3.0

<Object>

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

`message.trailersDistinct`

Added in: v18.3.0, v16.17.0

<Object>

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

`message.url`

Added in: v0.1.90

<string>

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

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

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

URL をそのパーツに解析するには:

```js [ESM]
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 ヘッダーを指定する可能性があるため、適切な検証が使用されていることを確認してください。

Class: `http.OutgoingMessage`

Added in: v0.1.17

拡張: <Stream>

このクラスは、http.ClientRequest と http.ServerResponse の親クラスとして機能します。これは、HTTP トランザクションの参加者の視点から見た抽象的なアウトゴーイングメッセージです。

Event: `'drain'`

Added in: v0.3.6

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

Event: `'finish'`

Added in: v0.1.17

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

Event: `'prefinish'`

Added in: v0.11.6

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

`outgoingMessage.addTrailers(headers)`

Added in: 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)`

Added in: v18.3.0, v16.17.0

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

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

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

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

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

`outgoingMessage.connection`

Added in: v0.3.0

Deprecated since: v15.12.0, v14.17.1

[Stable: 0 - Deprecated]

Stable: 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)`

Added in: v0.4.0

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

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

`outgoingMessage.getHeaderNames()`

Added in: v7.7.0

戻り値: <string[]>

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

`outgoingMessage.getHeaders()`

Added in: 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)`

Added in: v7.7.0

name <string>
戻り値: <boolean>

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

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

`outgoingMessage.headersSent`

Added in: v0.9.3

<boolean>

読み取り専用。ヘッダーが送信された場合は true、そうでない場合は false。

`outgoingMessage.pipe()`

Added in: v9.0.0

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

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

`outgoingMessage.removeHeader(name)`

Added in: v0.4.0

name <string> ヘッダー名

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

outgoingMessage.removeHeader('Content-Encoding');

`outgoingMessage.setHeader(name, value)`

Added in: v0.4.0

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

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

`outgoingMessage.setHeaders(headers)`

Added in: 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])`

Added in: v0.9.12

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

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

`outgoingMessage.socket`

Added in: v0.3.0

<stream.Duplex>

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

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

`outgoingMessage.uncork()`

Added in: v13.2.0, v12.16.0

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

`outgoingMessage.writableCorked`

Added in: v13.2.0, v12.16.0

<number>

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

`outgoingMessage.writableEnded`

Added in: v12.9.0

<boolean>

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

`outgoingMessage.writableFinished`

Added in: v12.7.0

<boolean>

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

`outgoingMessage.writableHighWaterMark`

Added in: v12.9.0

<number>

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

`outgoingMessage.writableLength`

Added in: v12.9.0

<number>

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

`outgoingMessage.writableObjectMode`

Added in: v12.9.0

<boolean>

常に false。

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

[履歴]

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

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

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

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

callback 引数は省略可能で、このデータのチャンクがフラッシュされるときに呼び出されます。

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

`http.METHODS`

Added in: v0.11.8

<string[]>

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

`http.STATUS_CODES`

Added in: 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)]で行われるのと同様に、ソケットでkeep-alive機能が有効になります。デフォルト: false。
- keepAliveInitialDelay <number> 正の数に設定すると、アイドル状態のソケットで最初のkeepaliveプローブが送信される前に、初期遅延を設定します。デフォルト: 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（Bad Request）ステータスコードで応答するように強制します。デフォルト: true。
- ServerResponse <http.ServerResponse> 使用するServerResponseクラスを指定します。オリジナルのServerResponseを拡張するのに役立ちます。デフォルト: ServerResponse。
- uniqueHeaders <Array> 1回だけ送信する必要があるレスポンスヘッダーのリスト。ヘッダーの値が配列の場合、アイテムは; を使用して結合されます。
- 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> デフォルトで GET に設定されたメソッドで、http.request() と同じ options を受け付けます。
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('Request Failed.\n' +
                      `Status Code: ${statusCode}`);
  } else if (!/^application\/json/.test(contentType)) {
    error = new Error('Invalid content-type.\n' +
                      `Expected application/json but received ${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(`Got 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	Added in: v0.5.9

<http.Agent>

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

`http.maxHeaderSize`

Added in: 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	Added in: 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 オブジェクトの場合、自動的に通常の 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 として渡すと、TypeError がスローされ、code: 'ERR_INVALID_HTTP_TOKEN' で識別されます。

ヘッダーを 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)`

Added in: v18.8.0, v16.18.0

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

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

`WebSocket`

Added in: 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 ​

Class: http.ClientRequest ​

Event: 'abort' ​

Event: 'close' ​

Event: 'connect' ​

イベント: 'continue' ​

イベント: 'finish' ​

イベント: 'information' ​

Event: 'response' ​

Event: 'socket' ​

Event: 'timeout' ​

Event: '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' ​

イベント: 'close' ​

イベント: 'connect' ​

イベント: '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`

Class: `http.ClientRequest`

Event: `'abort'`

Event: `'close'`

Event: `'connect'`

イベント: `'continue'`

イベント: `'finish'`

イベント: `'information'`

Event: `'response'`

Event: `'socket'`

Event: `'timeout'`

Event: `'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'`

イベント: `'close'`

イベント: `'connect'`

イベント: `'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'`