Node.js v25.0.0 ドキュメンテーション

new Agent([options])#

• 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。
  • agentKeepAliveTimeoutBuffer <number> ソケットの有効期限を決定する際に、サーバーから提供された keep-alive: timeout=... ヒントから減算するミリ秒。このバッファは、エージェントがサーバーよりわずかに早くソケットを閉じることを保証するのに役立ち、サーバーによって閉じられようとしているソケットにリクエストを送信する可能性を減らします。デフォルト: 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> ソケットのタイムアウト（ミリ秒）。これはソケットが作成されるときにタイムアウトを設定します。
  • proxyEnv <Object> | <undefined> プロキシ設定のための環境変数。詳細は組み込みプロキシサポートを参照してください。デフォルト: undefined
    • HTTP_PROXY <string> | <undefined> HTTPリクエストが使用すべきプロキシサーバーのURL。未定義の場合、HTTPリクエストにプロキシは使用されません。
    • HTTPS_PROXY <string> | <undefined> HTTPSリクエストが使用すべきプロキシサーバーのURL。未定義の場合、HTTPSリクエストにプロキシは使用されません。
    • NO_PROXY <string> | <undefined> プロキシを経由すべきでないエンドポイントを指定するパターン。
    • http_proxy <string> | <undefined> HTTP_PROXY と同じです。両方が設定されている場合、http_proxy が優先されます。
    • https_proxy <string> | <undefined> HTTPS_PROXY と同じです。両方が設定されている場合、https_proxy が優先されます。
    • no_proxy <string> | <undefined> NO_PROXY と同じです。両方が設定されている場合、no_proxy が優先されます。
  • defaultPort <number> リクエストでポートが指定されていない場合に使用するデフォルトポート。デフォルト: 80。
  • protocol <string> エージェントが使用するプロトコル。デフォルト: 'http:'。

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

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

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);copy

agent.createConnection(options[, callback])#

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

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

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

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

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

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

agent.keepSocketAlive(socket)#

• socket <stream.Duplex>

socket がリクエストから切り離され、Agent によって永続化される可能性があるときに呼び出されます。デフォルトの動作は次のとおりです。

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

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

socket 引数は <stream.Duplex> のサブクラスである <net.Socket> のインスタンスにすることができます。

agent.reuseSocket(socket, request)#

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

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

socket.ref(); copy

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

socket 引数は <stream.Duplex> のサブクラスである <net.Socket> のインスタンスにすることができます。

agent.destroy()#

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

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

agent.freeSockets#

• 型: <Object>

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

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

agent.getName([options])#

• 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#

• 型: <number>

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

agent.maxSockets#

• 型: <number>

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

agent.maxTotalSockets#

• 型: <number>

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

agent.requests#

• 型: <Object>

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

agent.sockets#

• 型: <Object>

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

イベント: 'abort'#

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

イベント: 'close'#

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

イベント: 'connect'#

• response <http.IncomingMessage>
• socket <stream.Duplex>
• head <Buffer>

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

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

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

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

// Create an HTTP tunneling proxy
const proxy = createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
proxy.on('connect', (req, clientSocket, head) => {
  // Connect to an origin server
  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);
  });
});

// Now that proxy is running
proxy.listen(1337, '127.0.0.1', () => {

  // Make a request to a tunneling proxy
  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!');

    // Make a request over an HTTP tunnel
    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');

// Create an HTTP tunneling proxy
const proxy = http.createServer((req, res) => {
  res.writeHead(200, { 'Content-Type': 'text/plain' });
  res.end('okay');
});
proxy.on('connect', (req, clientSocket, head) => {
  // Connect to an origin server
  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);
  });
});

// Now that proxy is running
proxy.listen(1337, '127.0.0.1', () => {

  // Make a request to a tunneling proxy
  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!');

    // Make a request over an HTTP tunnel
    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();
    });
  });
});copy

イベント: 'continue'#

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

イベント: 'finish'#

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

イベント: 'information'#

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

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

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}`);
});copy

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

イベント: 'response'#

• response <http.IncomingMessage>

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

イベント: 'socket'#

• socket <stream.Duplex>

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

イベント: 'timeout'#

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

参照: request.setTimeout()。

イベント: 'upgrade'#

• response <http.IncomingMessage>
• socket <stream.Duplex>
• head <Buffer>

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

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

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

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

// Create an HTTP server
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
});

// Now that server is running
server.listen(1337, '127.0.0.1', () => {

  // make a request
  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');

// Create an HTTP server
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
});

// Now that server is running
server.listen(1337, '127.0.0.1', () => {

  // make a request
  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);
  });
});copy

request.abort()#

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

request.aborted#

• 型: <boolean>

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

request.connection#

• タイプ: <stream.Duplex>

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

request.cork()#

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

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

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

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

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

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

request.finished#

• 型: <boolean>

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

request.flushHeaders()#

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

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

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

request.getHeader(name)#

• 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' is 'text/html'
const contentLength = request.getHeader('Content-Length');
// 'contentLength' is of type number
const cookie = request.getHeader('Cookie');
// 'cookie' is of type string[] copy

request.getHeaderNames()#

• 戻り値: <string[]>

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

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

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

request.getHeaders()#

• 戻り値: <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'] } copy

request.getRawHeaderNames()#

• 戻り値: <string[]>

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

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

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

request.hasHeader(name)#

• name <string>
• 戻り値: <boolean>

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

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

request.maxHeadersCount#

• タイプ: <number> デフォルト: 2000

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

request.path#

• タイプ: <string> リクエストパス。

request.method#

• タイプ: <string> リクエストメソッド。

request.host#

• タイプ: <string> リクエストホスト。

request.protocol#

• タイプ: <string> リクエストプロトコル。

request.removeHeader(name)#

• name <string>

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

request.removeHeader('Content-Type'); copy

request.reusedSocket#

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

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

import http from 'node:http';

// Server has a 5 seconds keep-alive timeout by default
http
  .createServer((req, res) => {
    res.write('hello\n');
    res.end();
  })
  .listen(3000);

setInterval(() => {
  // Adapting a keep-alive agent
  http.get('https://:3000', { agent }, (res) => {
    res.on('data', (data) => {
      // Do nothing
    });
  });
}, 5000); // Sending request on 5s interval so it's easy to hit idle timeoutconst http = require('node:http');

// Server has a 5 seconds keep-alive timeout by default
http
  .createServer((req, res) => {
    res.write('hello\n');
    res.end();
  })
  .listen(3000);

setInterval(() => {
  // Adapting a keep-alive agent
  http.get('https://:3000', { agent }, (res) => {
    res.on('data', (data) => {
      // Do nothing
    });
  });
}, 5000); // Sending request on 5s interval so it's easy to hit idle timeoutcopy

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

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

function retriableRequest() {
  const req = http
    .get('https://:3000', { agent }, (res) => {
      // ...
    })
    .on('error', (err) => {
      // Check if retry is needed
      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('https://:3000', { agent }, (res) => {
      // ...
    })
    .on('error', (err) => {
      // Check if retry is needed
      if (req.reusedSocket && err.code === 'ECONNRESET') {
        retriableRequest();
      }
    });
}

retriableRequest();copy

request.setHeader(name, value)#

• name <string>
• value <any>

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

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

または

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

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

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

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

request.setNoDelay([noDelay])#

• noDelay <boolean>

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

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

• enable <boolean>
• initialDelay <number>

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

request.setTimeout(timeout[, callback])#

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

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

request.socket#

• タイプ: <stream.Duplex>

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

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

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

request.uncork()#

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

request.writableEnded#

• 型: <boolean>

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

request.writableFinished#

• 型: <boolean>

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

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

• 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 関数が空の文字列またはバッファで呼び出された場合、何もしないでさらなる入力を待ちます。

イベント: 'checkContinue'#

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

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

このイベントを処理するには、クライアントがリクエストボディの送信を続けるべき場合は response.writeContinue() を呼び出し、クライアントがリクエストボディの送信を続けるべきでない場合は適切なHTTPレスポンス（例：400 Bad Request）を生成します。

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

イベント: 'checkExpectation'#

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

HTTP Expect ヘッダーが 100-continue 以外の値で受信されるたびに発行されます。このイベントがリッスンされていない場合、サーバーは適切に 417 Expectation Failed で自動的に応答します。

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

イベント: 'clientError'#

• 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 オブジェクトです。

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);copy

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

イベント: 'close'#

サーバーが閉じるときに発行されます。

イベント: 'connect'#

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

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

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

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

イベント: 'connection'#

• 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'#

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

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

イベント: 'request'#

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

リクエストがあるたびに発行されます。1つの接続につき複数のリクエストがある場合があります（HTTP Keep-Alive接続の場合）。

イベント: 'upgrade'#

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

クライアントのHTTPアップグレードリクエストが受け入れられるたびに発行されます。デフォルトでは、すべてのHTTPアップグレードリクエストは無視されます（つまり、通常の 'request' イベントのみが発行され、通常のHTTPリクエスト/レスポンスフローに従います）。ただし、このイベントをリッスンすると、それらはすべて受け入れられます（つまり、代わりに 'upgrade' イベントが発行され、将来の通信は生のソケットを介して直接処理する必要があります）。サーバーの shouldUpgradeCallback オプションを使用することで、これをより正確に制御できます。

このイベントのリッスンはオプションであり、クライアントはプロトコルの変更を強制することはできません。

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

アップグレードが shouldUpgradeCallback によって受け入れられたが、イベントハンドラが登録されていない場合、ソケットは破棄され、クライアントの接続は即座に閉じられます。

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

server.close([callback])#

• 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);
// Close the server after 10 seconds
setTimeout(() => {
  server.close(() => {
    console.log('server on port 8000 closed successfully');
  });
}, 10000); copy

server.closeAllConnections()#

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

これはすべての接続を強制的に閉じる方法であり、注意して使用する必要があります。これを server.close と組み合わせて使用する場合は、この呼び出しと server.close の呼び出しの間に新しい接続が作成される競合状態を避けるため、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);
// Close the server after 10 seconds
setTimeout(() => {
  server.close(() => {
    console.log('server on port 8000 closed successfully');
  });
  // Closes all connections, ensuring the server closes successfully
  server.closeAllConnections();
}, 10000); copy

server.closeIdleConnections()#

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

Node.js 19.0.0以降、keep-alive 接続を回収するために server.close と組み合わせてこのメソッドを呼び出す必要はありません。使用しても害はありませんが、19.0.0より前のバージョンをサポートする必要があるライブラリやアプリケーションの後方互換性を確保するのに役立つ場合があります。これを server.close と組み合わせて使用する場合は、この呼び出しと server.close の呼び出しの間に新しい接続が作成される競合状態を避けるため、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);
// Close the server after 10 seconds
setTimeout(() => {
  server.close(() => {
    console.log('server on port 8000 closed successfully');
  });
  // Closes idle connections, such as keep-alive connections. Server will close
  // once remaining active connections are terminated
  server.closeIdleConnections();
}, 10000); copy

server.headersTimeout#

• タイプ: <number> デフォルト: server.requestTimeout または 60000 のうち小さい方。

パーサーが完全なHTTPヘッダーを受信するのを待つ時間を制限します。

タイムアウトが切れると、サーバーはリクエストをリクエストリスナーに転送せずにステータス408で応答し、その後接続を閉じます。

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

server.listen()#

HTTPサーバーの接続待受を開始します。このメソッドは net.Server の server.listen() と同じです。

server.listening#

• タイプ: <boolean> サーバーが接続を待機しているかどうかを示します。

server.maxHeadersCount#

• タイプ: <number> デフォルト: 2000

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

server.requestTimeout#

• タイプ: <number> デフォルト: 300000

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

タイムアウトが切れると、サーバーはリクエストをリクエストリスナーに転送せずにステータス408で応答し、その後接続を閉じます。

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

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

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

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

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

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

server.maxRequestsPerSocket#

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

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

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

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

server.timeout#

• タイプ: <number> タイムアウト（ミリ秒）。デフォルト: 0 (タイムアウトなし)

ソケットがタイムアウトしたと見なされるまでの非アクティブ状態のミリ秒数。

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

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

server.keepAliveTimeout#

• タイプ: <number> タイムアウト（ミリ秒）。デフォルト: 5000 (5秒)。

サーバーが最後のレスポンスを書き終えた後、ソケットが破棄されるまでに追加の着信データを待機する必要がある非アクティブ状態のミリ秒数。

このタイムアウト値は server.keepAliveTimeoutBuffer オプションと組み合わされて、実際のソケットタイムアウトを決定します。計算式は次のとおりです: socketTimeout = keepAliveTimeout + keepAliveTimeoutBuffer サーバーがキープアライブタイムアウトが発生する前に新しいデータを受信した場合、通常の非アクティブタイムアウト、つまり server.timeout をリセットします。

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

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

server.keepAliveTimeoutBuffer#

• タイプ: <number> タイムアウト（ミリ秒）。デフォルト: 1000 (1秒)。

server.keepAliveTimeout に追加される追加のバッファ時間で、内部ソケットのタイムアウトを延長します。

このバッファは、ソケットのタイムアウトを通知されたキープアライブタイムアウトよりわずかに長くすることで、接続リセット（ECONNRESET）エラーを減らすのに役立ちます。

このオプションは、新しい着信接続にのみ適用されます。

server[Symbol.asyncDispose]()#

server.close()を呼び出し、サーバーがクローズしたときに解決されるpromiseを返します。

イベント: 'close'#

レスポンスが完了したこと、またはその基盤となる接続が（レスポンス完了前に）早期に終了したことを示します。

イベント: 'finish'#

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

response.addTrailers(headers)#

• 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(); copy

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

response.connection#

• タイプ: <stream.Duplex>

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

response.cork()#

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

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

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

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

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

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

response.finished#

• 型: <boolean>

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

response.flushHeaders()#

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

response.getHeader(name)#

• name <string>
• 返り値: <number> | <string> | <string[]> | <undefined>

すでにキューに入れられているが、まだクライアントに送信されていないヘッダーを読み取ります。名前は大文字と小文字を区別しません。返り値の型は 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[] copy

response.getHeaderNames()#

• 戻り値: <string[]>

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

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

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

response.getHeaders()#

• 戻り値: <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'] } copy

response.hasHeader(name)#

• name <string>
• 戻り値: <boolean>

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

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

response.headersSent#

• 型: <boolean>

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

response.removeHeader(name)#

• name <string>

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

response.removeHeader('Content-Encoding'); copy

response.req#

• 型: <http.IncomingMessage>

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

response.sendDate#

• 型: <boolean>

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

これはテスト目的でのみ無効にすべきです。HTTPではレスポンスにDateヘッダーが必要です。

response.setHeader(name, value)#

• name <string>
• value <number> | <string> | <string[]>
• 返り値: <http.ServerResponse>

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

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

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

または

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

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

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

// Returns 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');
}); copy

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

response.setTimeout(msecs[, callback])#

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

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

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

response.socket#

• タイプ: <stream.Duplex>

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

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);copy

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

response.statusCode#

• 型: <number> デフォルト: 200

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

response.statusCode = 404; copy

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

response.statusMessage#

• 型: <string>

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

response.statusMessage = 'Not found'; copy

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

response.strictContentLength#

• 型: <boolean> デフォルト: false

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

response.uncork()#

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

response.writableEnded#

• 型: <boolean>

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

response.writableFinished#

• 型: <boolean>

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

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

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

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

response.writeContinue()#

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

response.writeEarlyHints(hints[, callback])#

• hints <Object>
• callback <Function>

クライアントにLinkヘッダー付きのHTTP/1.1 103 Early Hintsメッセージを送信し、ユーザーエージェントがリンクされたリソースをプリロード/プリコネクトできることを示します。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); copy

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

• 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); copy

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

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

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

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

// Returns 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');
}); copy

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

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

response.writeProcessing()#

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

イベント: 'aborted'#

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

イベント: 'close'#

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

message.aborted#

• 型: <boolean>

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

message.complete#

• 型: <boolean>

完全なHTTPメッセージが受信され、正常に解析された場合、message.complete プロパティは 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');
  });
}); copy

message.connection#

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

message.destroy([error])#

• error <Error>
• 戻り値: <this>

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

message.headers#

• 型: <Object>

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

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

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

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

• 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#

• 型: <Object>

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

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

message.httpVersion#

• 型: <string>

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

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

message.method#

• 型: <string>

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

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

message.rawHeaders#

• 型: <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); copy

message.rawTrailers#

• 型: <string[]>

受信したままの生の要求/応答トレーラーのキーと値。'end' イベントでのみ設定されます。

message.setTimeout(msecs[, callback])#

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

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

message.socket#

• タイプ: <stream.Duplex>

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

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

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

message.statusCode#

• 型: <number>

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

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

message.statusMessage#

• 型: <string>

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

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

message.trailers#

• 型: <Object>

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

message.trailersDistinct#

• 型: <Object>

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

message.url#

• 型: <string>

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

リクエストURL文字列。これには、実際のHTTPリクエストに存在するURLのみが含まれています。次のリクエストを考えてみましょう。

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

URLをその部分に解析するには

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

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

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

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

イベント: 'drain'#

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

イベント: 'finish'#

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

イベント: 'prefinish'#

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

outgoingMessage.addTrailers(headers)#

• 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(); copy

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

outgoingMessage.appendHeader(name, value)#

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

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

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

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

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

outgoingMessage.connection#

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

outgoingMessage.cork()#

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

outgoingMessage.destroy([error])#

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

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

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

• 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()#

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

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

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

outgoingMessage.getHeader(name)#

• name <string> ヘッダーの名前
• 返り値: <number> | <string> | <string[]> | <undefined>

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

outgoingMessage.getHeaderNames()#

• 戻り値: <string[]>

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

outgoingMessage.getHeaders()#

• 戻り値: <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'] } copy

outgoingMessage.hasHeader(name)#

• name <string>
• 戻り値: <boolean>

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

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

outgoingMessage.headersSent#

• 型: <boolean>

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

outgoingMessage.pipe()#

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

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

outgoingMessage.removeHeader(name)#

• name <string> ヘッダー名

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

outgoingMessage.removeHeader('Content-Encoding'); copy

outgoingMessage.setHeader(name, value)#

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

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

outgoingMessage.setHeaders(headers)#

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

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

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

または

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

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

// Returns 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');
}); copy

outgoingMessage.setTimeout(msecs[, callback])#

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

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

outgoingMessage.socket#

• タイプ: <stream.Duplex>

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

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

outgoingMessage.uncork()#

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

outgoingMessage.writableCorked#

• 型: <number>

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

outgoingMessage.writableEnded#

• 型: <boolean>

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

outgoingMessage.writableFinished#

• 型: <boolean>

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

outgoingMessage.writableHighWaterMark#

• 型: <number>

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

outgoingMessage.writableLength#

• 型: <number>

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

outgoingMessage.writableObjectMode#

• 型: <boolean>

常に false です。

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

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

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

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

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

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

プロキシURLフォーマット#

プロキシURLは、HTTPまたはHTTPSプロトコルのいずれかを使用できます。

• HTTPプロキシ: http://proxy.example.com:8080
• HTTPSプロキシ: https://proxy.example.com:8080
• 認証付きプロキシ: http://username:password@proxy.example.com:8080

NO_PROXY フォーマット#

NO_PROXY 環境変数はいくつかのフォーマットをサポートしています。

• * - すべてのホストに対してプロキシをバイパス
• example.com - 完全なホスト名の一致
• .example.com - ドメインサフィックスの一致（sub.example.com に一致）
• *.example.com - ワイルドカードドメインの一致
• 192.168.1.100 - 完全なIPアドレスの一致
• 192.168.1.1-192.168.1.100 - IPアドレス範囲
• example.com:8080 - 特定のポートを持つホスト名

複数のエントリはカンマで区切る必要があります。

例#

デフォルトのグローバルエージェントを通じて送信されるすべてのリクエストに対してプロキシサポートを有効にしてNode.jsプロセスを開始するには、NODE_USE_ENV_PROXY 環境変数を使用します。

NODE_USE_ENV_PROXY=1 HTTP_PROXY=http://proxy.example.com:8080 NO_PROXY=localhost,127.0.0.1 node client.js copy

または、--use-env-proxy フラグを使用します。

HTTP_PROXY=http://proxy.example.com:8080 NO_PROXY=localhost,127.0.0.1 node --use-env-proxy client.js copy

組み込みプロキシサポート付きのカスタムエージェントを作成するには

const http = require('node:http');

// Creating a custom agent with custom proxy support.
const agent = new http.Agent({ proxyEnv: { HTTP_PROXY: 'http://proxy.example.com:8080' } });

http.request({
  hostname: 'www.example.com',
  port: 80,
  path: '/',
  agent,
}, (res) => {
  // This request will be proxied through proxy.example.com:8080 using the HTTP protocol.
  console.log(`STATUS: ${res.statusCode}`);
}); copy

あるいは、以下も機能します。

const http = require('node:http');
// Use lower-cased option name.
const agent1 = new http.Agent({ proxyEnv: { http_proxy: 'http://proxy.example.com:8080' } });
// Use values inherited from the environment variables, if the process is started with
// HTTP_PROXY=http://proxy.example.com:8080 this will use the proxy server specified
// in process.env.HTTP_PROXY.
const agent2 = new http.Agent({ proxyEnv: process.env }); copy