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

Http2Session とソケット#

すべての Http2Session インスタンスは、作成時に正確に1つの net.Socket または tls.TLSSocket に関連付けられます。Socket または Http2Session のどちらかが破棄されると、両方が破棄されます。

HTTP/2 プロトコルによって課される特定のシリアライズおよび処理要件のため、ユーザーコードが Http2Session にバインドされた Socket インスタンスからデータを読み取ったり、書き込んだりすることはお勧めしません。そうすると、HTTP/2 セッションが不確定な状態になり、セッションとソケットが使用できなくなる可能性があります。

Socket が Http2Session にバインドされると、ユーザーコードは Http2Session の API のみに依存するべきです。

イベント: 'close'#

'close' イベントは、Http2Session が破棄された後に発行されます。リスナーは引数を期待しません。

イベント: 'connect'#

• session <Http2Session>
• socket <net.Socket>

'connect' イベントは、Http2Session がリモートピアに正常に接続され、通信が開始できるようになった後に発行されます。

ユーザーコードは通常、このイベントを直接リッスンしません。

イベント: 'error'#

• error <Error>

'error' イベントは、Http2Session の処理中にエラーが発生した場合に発行されます。

イベント: 'frameError'#

• type <integer> フレームタイプ。
• code <integer> エラーコード。
• id <integer> ストリーム ID (フレームがストリームに関連付けられていない場合は 0)。

'frameError' イベントは、セッション上でフレームを送信しようとしてエラーが発生した場合に発行されます。送信できなかったフレームが特定の Http2Stream に関連付けられている場合、Http2Stream で 'frameError' イベントを発行する試みが行われます。

'frameError' イベントがストリームに関連付けられている場合、ストリームは 'frameError' イベントの直後にクローズされ、破棄されます。イベントがストリームに関連付けられていない場合、Http2Session は 'frameError' イベントの直後にシャットダウンされます。

イベント: 'goaway'#

• errorCode <number> GOAWAY フレームで指定された HTTP/2 エラーコード。
• lastStreamID <number> リモートピアが正常に処理した最後のストリームの ID (ID が指定されていない場合は 0)。
• opaqueData <Buffer> GOAWAY フレームに追加の不透明データが含まれていた場合、そのデータを含む Buffer インスタンスが渡されます。

'goaway' イベントは、GOAWAY フレームが受信されたときに発行されます。

Http2Session インスタンスは、'goaway' イベントが発行されると自動的にシャットダウンされます。

イベント: 'localSettings'#

• settings <HTTP/2 Settings Object> 受信した SETTINGS フレームのコピー。

'localSettings' イベントは、確認応答の SETTINGS フレームが受信されたときに発行されます。

新しい設定を送信するために http2session.settings() を使用する場合、変更された設定は 'localSettings' イベントが発行されるまで有効になりません。

session.settings({ enablePush: false });

session.on('localSettings', (settings) => {
  /* Use the new settings */
}); copy

イベント: 'ping'#

• payload <Buffer> PING フレームの 8 バイトのペイロード

'ping' イベントは、接続されたピアから PING フレームが受信されるたびに発行されます。

イベント: 'remoteSettings'#

• settings <HTTP/2 Settings Object> 受信した SETTINGS フレームのコピー。

'remoteSettings' イベントは、接続されたピアから新しい SETTINGS フレームが受信されたときに発行されます。

session.on('remoteSettings', (settings) => {
  /* Use the new settings */
}); copy

イベント: 'stream'#

• stream <Http2Stream> ストリームへの参照
• headers <HTTP/2 Headers Object> ヘッダーを記述するオブジェクト
• flags <number> 関連付けられた数値フラグ
• rawHeaders <HTTP/2 Raw Headers> 生のヘッダーを含む配列

'stream' イベントは、新しい Http2Stream が作成されたときに発行されます。

session.on('stream', (stream, headers, flags) => {
  const method = headers[':method'];
  const path = headers[':path'];
  // ...
  stream.respond({
    ':status': 200,
    'content-type': 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
}); copy

サーバーサイドでは、ユーザーコードは通常このイベントを直接リッスンせず、代わりにそれぞれ http2.createServer() と http2.createSecureServer() によって返される net.Server または tls.Server インスタンスによって発行される 'stream' イベントのハンドラを登録します。以下の例のようにします。

import { createServer } from 'node:http2';

// Create an unencrypted HTTP/2 server
const server = createServer();

server.on('stream', (stream, headers) => {
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.on('error', (error) => console.error(error));
  stream.end('<h1>Hello World</h1>');
});

server.listen(8000);const http2 = require('node:http2');

// Create an unencrypted HTTP/2 server
const server = http2.createServer();

server.on('stream', (stream, headers) => {
  stream.respond({
    'content-type': 'text/html; charset=utf-8',
    ':status': 200,
  });
  stream.on('error', (error) => console.error(error));
  stream.end('<h1>Hello World</h1>');
});

server.listen(8000);copy

HTTP/2 ストリームとネットワークソケットは 1:1 の対応関係にありませんが、ネットワークエラーは個々のストリームをすべて破棄するため、上記のようにストリームレベルで処理する必要があります。

イベント: 'timeout'#

http2session.setTimeout() メソッドを使用してこの Http2Session のタイムアウト期間を設定した後、設定されたミリ秒数の間 Http2Session にアクティビティがない場合に 'timeout' イベントが発行されます。そのリスナーは引数を期待しません。

session.setTimeout(2000);
session.on('timeout', () => { /* .. */ }); copy

http2session.alpnProtocol#

• 型: <string> | <undefined>

Http2Session がまだソケットに接続されていない場合は undefined、Http2Session が TLSSocket に接続されていない場合は h2c、または接続された TLSSocket 自身の alpnProtocol プロパティの値を返します。

http2session.close([callback])#

• callback <Function>

Http2Session を正常にクローズし、既存のストリームが自己完結することを許可し、新しい Http2Stream インスタンスが作成されるのを防ぎます。クローズされると、オープンな Http2Stream インスタンスがない場合、http2session.destroy() が呼び出される**可能性**があります。

指定された場合、callback 関数は 'close' イベントのハンドラとして登録されます。

http2session.closed#

• 型: <boolean>

この Http2Session インスタンスがクローズされている場合は true、それ以外の場合は false になります。

http2session.connecting#

• 型: <boolean>

この Http2Session インスタンスがまだ接続中の場合は true になり、connect イベントを発行する前や http2.connect コールバックを呼び出す前に false に設定されます。

http2session.destroy([error][, code])#

• error <Error> エラーのために Http2Session が破棄されている場合の Error オブジェクト。
• code <number> 最後の GOAWAY フレームで送信する HTTP/2 エラーコード。指定されていない場合で、error が undefined でない場合は、デフォルトは INTERNAL_ERROR、それ以外の場合は NO_ERROR になります。

Http2Session と関連する net.Socket または tls.TLSSocket を即座に終了させます。

破棄されると、Http2Session は 'close' イベントを発行します。error が undefined でない場合、'close' イベントの直前に 'error' イベントが発行されます。

Http2Session に関連付けられたオープンな Http2Streams が残っている場合、それらも破棄されます。

http2session.destroyed#

• 型: <boolean>

この Http2Session インスタンスが破棄され、もはや使用してはならない場合は true、それ以外の場合は false になります。

http2session.encrypted#

• 型: <boolean> | <undefined>

Http2Session セッションソケットがまだ接続されていない場合は undefined、Http2Session が TLSSocket で接続されている場合は true、Http2Session が他の種類のソケットやストリームに接続されている場合は false になります。

http2session.goaway([code[, lastStreamID[, opaqueData]]])#

• code <number> HTTP/2 エラーコード
• lastStreamID <number> 最後に処理された Http2Stream の数値 ID
• opaqueData <Buffer> | <TypedArray> | <DataView> GOAWAY フレーム内に含める追加データを含む TypedArray または DataView インスタンス。

接続されたピアに GOAWAY フレームを送信しますが、Http2Session はシャットダウン**しません**。

http2session.localSettings#

• 型: <HTTP/2 Settings Object>

この Http2Session の現在のローカル設定を記述するプロトタイプなしのオブジェクト。ローカル設定は、*この* Http2Session インスタンスにローカルです。

http2session.originSet#

• 型: <string[]> | <undefined>

Http2Session が TLSSocket に接続されている場合、originSet プロパティは Http2Session が権威を持つと見なされるオリジンの Array を返します。

originSet プロパティは、セキュアな TLS 接続を使用している場合にのみ利用可能です。

http2session.pendingSettingsAck#

• 型: <boolean>

Http2Session が現在、送信された SETTINGS フレームの確認応答を待っているかどうかを示します。http2session.settings() メソッドを呼び出した後は true になります。送信されたすべての SETTINGS フレームが確認されると false になります。

http2session.ping([payload, ]callback)#

• payload <Buffer> | <TypedArray> | <DataView> オプションの ping ペイロード。
• callback <Function>
• 戻り値: <boolean>

接続された HTTP/2 ピアに PING フレームを送信します。callback 関数を提供する必要があります。このメソッドは、PING が送信された場合は true、それ以外の場合は false を返します。

未処理 (未確認) の ping の最大数は、maxOutstandingPings 設定オプションによって決まります。デフォルトの最大値は 10 です。

提供された場合、payload は PING と共に送信され、ping 確認応答と共に返される 8 バイトのデータを含む Buffer、TypedArray、または DataView でなければなりません。

コールバックは3つの引数で呼び出されます: PING が正常に確認された場合は null になるエラー引数、ping が送信されてから確認応答が受信されるまでの経過時間をミリ秒単位で報告する duration 引数、そして 8 バイトの PING ペイロードを含む Buffer です。

session.ping(Buffer.from('abcdefgh'), (err, duration, payload) => {
  if (!err) {
    console.log(`Ping acknowledged in ${duration} milliseconds`);
    console.log(`With payload '${payload.toString()}'`);
  }
}); copy

payload 引数が指定されていない場合、デフォルトのペイロードは PING の持続時間の開始を示す 64 ビットのタイムスタンプ (リトルエンディアン) になります。

http2session.ref()#

この Http2Session インスタンスの基になる net.Socket 上で ref() を呼び出します。

http2session.remoteSettings#

• 型: <HTTP/2 Settings Object>

この Http2Session の現在のリモート設定を記述するプロトタイプなしのオブジェクト。リモート設定は、*接続された* HTTP/2 ピアによって設定されます。

http2session.setLocalWindowSize(windowSize)#

• windowSize <number>

ローカルエンドポイントのウィンドウサイズを設定します。windowSize は、設定する合計ウィンドウサイズであり、差分ではありません。

import { createServer } from 'node:http2';

const server = createServer();
const expectedWindowSize = 2 ** 20;
server.on('session', (session) => {

  // Set local window size to be 2 ** 20
  session.setLocalWindowSize(expectedWindowSize);
});const http2 = require('node:http2');

const server = http2.createServer();
const expectedWindowSize = 2 ** 20;
server.on('session', (session) => {

  // Set local window size to be 2 ** 20
  session.setLocalWindowSize(expectedWindowSize);
});copy

http2 クライアントの場合、適切なイベントは 'connect' または 'remoteSettings' のいずれかです。

http2session.setTimeout(msecs, callback)#

• msecs <number>
• callback <Function>

msecs ミリ秒後に Http2Session にアクティビティがない場合に呼び出されるコールバック関数を設定するために使用されます。指定された callback は 'timeout' イベントのリスナーとして登録されます。

http2session.socket#

• 型: <net.Socket> | <tls.TLSSocket>

net.Socket (または tls.TLSSocket) として機能する Proxy オブジェクトを返しますが、利用可能なメソッドを HTTP/2 で安全に使用できるものに制限します。

destroy、emit、end、pause、read、resume、および write は、ERR_HTTP2_NO_SOCKET_MANIPULATION コードのエラーをスローします。詳細については、Http2Session とソケットを参照してください。

setTimeout メソッドはこの Http2Session で呼び出されます。

その他すべての相互作用はソケットに直接ルーティングされます。

http2session.state#

Http2Session の現在の状態に関するその他の情報を提供します。

• 型: <Object>
  • effectiveLocalWindowSize <number> Http2Session の現在のローカル (受信) フロー制御ウィンドウサイズ。
  • effectiveRecvDataLength <number> 最後のフロー制御 WINDOW_UPDATE 以降に受信された現在のバイト数。
  • nextStreamID <number> この Http2Session によって次に新しい Http2Stream が作成されるときに使用される数値識別子。
  • localWindowSize <number> リモートピアが WINDOW_UPDATE を受信せずに送信できるバイト数。
  • lastProcStreamID <number> HEADERS または DATA フレームが最後に受信された Http2Stream の数値 ID。
  • remoteWindowSize <number> この Http2Session が WINDOW_UPDATE を受信せずに送信できるバイト数。
  • outboundQueueSize <number> この Http2Session の送信キュー内の現在のフレーム数。
  • deflateDynamicTableSize <number> 送信ヘッダー圧縮状態テーブルの現在のサイズ (バイト単位)。
  • inflateDynamicTableSize <number> 受信ヘッダー圧縮状態テーブルの現在のサイズ (バイト単位)。

この Http2Session の現在の状態を記述するオブジェクト。

http2session.settings([settings][, callback])#

• settings <HTTP/2 Settings Object>
• callback <Function> セッションが接続された後、またはセッションが既に接続されている場合はすぐに呼び出されるコールバック。
  • err <Error> | <null>
  • settings <HTTP/2 Settings Object> 更新された settings オブジェクト。
  • duration <integer>

この Http2Session の現在のローカル設定を更新し、接続された HTTP/2 ピアに新しい SETTINGS フレームを送信します。

一度呼び出されると、セッションがリモートピアからの新しい設定の確認応答を待っている間、http2session.pendingSettingsAck プロパティは true になります。

新しい設定は、SETTINGS 確認応答が受信され、'localSettings' イベントが発行されるまで有効になりません。確認応答がまだ保留中の間に複数の SETTINGS フレームを送信することが可能です。

http2session.type#

• 型: <number>

この Http2Session インスタンスがサーバーの場合は http2session.type は http2.constants.NGHTTP2_SESSION_SERVER と等しくなり、インスタンスがクライアントの場合は http2.constants.NGHTTP2_SESSION_CLIENT と等しくなります。

http2session.unref()#

この Http2Session インスタンスの基になる net.Socket 上で unref() を呼び出します。

serverhttp2session.altsvc(alt, originOrStream)#

• alt <string> RFC 7838 で定義されている代替サービス設定の説明。
• originOrStream <number> | <string> | <URL> | <Object> オリジンを指定する URL 文字列 (または origin プロパティを持つ Object)、あるいは http2stream.id プロパティによって与えられるアクティブな Http2Stream の数値識別子。

接続されたクライアントに ALTSVC フレーム (RFC 7838 で定義) を送信します。

import { createServer } from 'node:http2';

const server = createServer();
server.on('session', (session) => {
  // Set altsvc for origin https://example.org:80
  session.altsvc('h2=":8000"', 'https://example.org:80');
});

server.on('stream', (stream) => {
  // Set altsvc for a specific stream
  stream.session.altsvc('h2=":8000"', stream.id);
});const http2 = require('node:http2');

const server = http2.createServer();
server.on('session', (session) => {
  // Set altsvc for origin https://example.org:80
  session.altsvc('h2=":8000"', 'https://example.org:80');
});

server.on('stream', (stream) => {
  // Set altsvc for a specific stream
  stream.session.altsvc('h2=":8000"', stream.id);
});copy

特定のストリーム ID で ALTSVC フレームを送信すると、代替サービスが指定された Http2Stream のオリジンに関連付けられていることを示します。

alt とオリジン文字列は ASCII バイトのみを含まなければならず、厳密に ASCII バイトのシーケンスとして解釈されます。特別な値 'clear' を渡すと、特定のドメインに対して以前に設定された代替サービスをクリアできます。

originOrStream 引数に文字列が渡された場合、それは URL として解析され、オリジンが導出されます。たとえば、HTTP URL 'https://example.org/foo/bar' のオリジンは ASCII 文字列 'https://example.org' です。指定された文字列が URL として解析できないか、有効なオリジンが導出できない場合はエラーがスローされます。

URL オブジェクト、または origin プロパティを持つ任意のオブジェクトは originOrStream として渡すことができ、その場合 origin プロパティの値が使用されます。origin プロパティの値は、適切にシリアライズされた ASCII オリジンでなければなりません。

代替サービスの指定#

alt パラメータの形式は RFC 7838 によって、特定のホストとポートに関連付けられた「代替」プロトコルのカンマ区切りリストを含む ASCII 文字列として厳密に定義されています。

たとえば、値 'h2="example.org:81"' は、HTTP/2 プロトコルがホスト 'example.org' の TCP/IP ポート 81 で利用可能であることを示します。ホストとポートは引用符 (") 文字で囲む必要があります。

複数の代替を指定することもできます。例: 'h2="example.org:81", h2=":82"'。

プロトコル識別子 (例の 'h2') は、有効な ALPN プロトコル ID であれば何でも構いません。

これらの値の構文は Node.js の実装では検証されず、ユーザーから提供された、またはピアから受信したまま渡されます。

serverhttp2session.origin(...origins)#

• origins <string> | <URL> | <Object> 個別の引数として渡される1つ以上の URL 文字列。

サーバーが権威ある応答を提供できるオリジンのセットを広告するために、接続されたクライアントに ORIGIN フレーム (RFC 8336 で定義) を送信します。

import { createSecureServer } from 'node:http2';
const options = getSecureOptionsSomehow();
const server = createSecureServer(options);
server.on('stream', (stream) => {
  stream.respond();
  stream.end('ok');
});
server.on('session', (session) => {
  session.origin('https://example.com', 'https://example.org');
});const http2 = require('node:http2');
const options = getSecureOptionsSomehow();
const server = http2.createSecureServer(options);
server.on('stream', (stream) => {
  stream.respond();
  stream.end('ok');
});
server.on('session', (session) => {
  session.origin('https://example.com', 'https://example.org');
});copy

origin として文字列が渡された場合、それは URL として解析され、オリジンが導出されます。たとえば、HTTP URL 'https://example.org/foo/bar' のオリジンは ASCII 文字列 'https://example.org' です。指定された文字列が URL として解析できないか、有効なオリジンが導出できない場合はエラーがスローされます。

URL オブジェクト、または origin プロパティを持つ任意のオブジェクトは origin として渡すことができ、その場合 origin プロパティの値が使用されます。origin プロパティの値は、適切にシリアライズされた ASCII オリジンでなければなりません。

あるいは、http2.createSecureServer() メソッドを使用して新しい HTTP/2 サーバーを作成するときに origins オプションを使用することもできます。

import { createSecureServer } from 'node:http2';
const options = getSecureOptionsSomehow();
options.origins = ['https://example.com', 'https://example.org'];
const server = createSecureServer(options);
server.on('stream', (stream) => {
  stream.respond();
  stream.end('ok');
});const http2 = require('node:http2');
const options = getSecureOptionsSomehow();
options.origins = ['https://example.com', 'https://example.org'];
const server = http2.createSecureServer(options);
server.on('stream', (stream) => {
  stream.respond();
  stream.end('ok');
});copy

イベント: 'altsvc'#

• alt <string>
• origin <string>
• streamId <number>

'altsvc' イベントは、クライアントが ALTSVC フレームを受信するたびに発行されます。イベントは ALTSVC の値、オリジン、ストリーム ID と共に発行されます。ALTSVC フレームに origin が提供されていない場合、origin は空文字列になります。

import { connect } from 'node:http2';
const client = connect('https://example.org');

client.on('altsvc', (alt, origin, streamId) => {
  console.log(alt);
  console.log(origin);
  console.log(streamId);
});const http2 = require('node:http2');
const client = http2.connect('https://example.org');

client.on('altsvc', (alt, origin, streamId) => {
  console.log(alt);
  console.log(origin);
  console.log(streamId);
});copy

イベント: 'origin'#

• origins <string[]>

'origin' イベントは、クライアントが ORIGIN フレームを受信するたびに発行されます。イベントは origin 文字列の配列と共に発行されます。http2session.originSet は、受信したオリジンを含むように更新されます。

import { connect } from 'node:http2';
const client = connect('https://example.org');

client.on('origin', (origins) => {
  for (let n = 0; n < origins.length; n++)
    console.log(origins[n]);
});const http2 = require('node:http2');
const client = http2.connect('https://example.org');

client.on('origin', (origins) => {
  for (let n = 0; n < origins.length; n++)
    console.log(origins[n]);
});copy

'origin' イベントは、セキュアな TLS 接続を使用している場合にのみ発行されます。

clienthttp2session.request(headers[, options])#

• headers <HTTP/2 Headers Object> | <HTTP/2 Raw Headers>

• options <Object>

  • endStream <boolean> ペイロードボディを期待しない GET リクエストを送信する場合など、Http2Stream の*書き込み可能*側を最初にクローズする必要がある場合は true。
  • exclusive <boolean> true であり、parent が親ストリームを識別する場合、作成されたストリームは親の唯一の直接の依存関係となり、他のすべての既存の依存関係は新しく作成されたストリームの依存関係になります。デフォルト: false。
  • parent <number> 新しく作成されたストリームが依存するストリームの数値識別子を指定します。
  • waitForTrailers <boolean> true の場合、Http2Stream は最後の DATA フレームが送信された後に 'wantTrailers' イベントを発行します。
  • signal <AbortSignal> 進行中のリクエストを中止するために使用できる AbortSignal。

• 戻り値: <ClientHttp2Stream>

HTTP/2 クライアントの Http2Session インスタンスの場合のみ、http2session.request() は、接続されたサーバーに HTTP/2 リクエストを送信するために使用できる Http2Stream インスタンスを作成して返します。

ClientHttp2Session が最初に作成されたとき、ソケットはまだ接続されていない場合があります。この間に clienthttp2session.request() が呼び出されると、実際のリクエストはソケットの準備が整うまで遅延されます。実際のリクエストが実行される前に session がクローズされた場合、ERR_HTTP2_GOAWAY_SESSION がスローされます。

このメソッドは、http2session.type が http2.constants.NGHTTP2_SESSION_CLIENT と等しい場合にのみ利用可能です。

import { connect, constants } from 'node:http2';
const clientSession = connect('https://:1234');
const {
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
} = constants;

const req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });
req.on('response', (headers) => {
  console.log(headers[HTTP2_HEADER_STATUS]);
  req.on('data', (chunk) => { /* .. */ });
  req.on('end', () => { /* .. */ });
});const http2 = require('node:http2');
const clientSession = http2.connect('https://:1234');
const {
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
} = http2.constants;

const req = clientSession.request({ [HTTP2_HEADER_PATH]: '/' });
req.on('response', (headers) => {
  console.log(headers[HTTP2_HEADER_STATUS]);
  req.on('data', (chunk) => { /* .. */ });
  req.on('end', () => { /* .. */ });
});copy

options.waitForTrailers オプションが設定されている場合、送信するペイロードデータの最後のチャンクがキューに入れられた直後に 'wantTrailers' イベントが発行されます。その後、http2stream.sendTrailers() メソッドを呼び出して、トレーラーヘッダーをピアに送信できます。

options.waitForTrailers が設定されている場合、最後の DATA フレームが送信されても Http2Stream は自動的にクローズされません。ユーザーコードは http2stream.sendTrailers() または http2stream.close() のいずれかを呼び出して Http2Stream をクローズする必要があります。

options.signal が AbortSignal で設定され、対応する AbortController で abort が呼び出されると、リクエストは AbortError エラーと共に 'error' イベントを発行します。

:method と :path 擬似ヘッダーは headers 内で指定されていません。それぞれデフォルトで以下のようになります。

• :method = 'GET'
• :path = /

stream.respond({
  'content-type': 'text/html; charset=utf-8',
  ':status': 200,
}); copy

Http2Stream のライフサイクル#

イベント: 'aborted'#

'aborted' イベントは、Http2Stream インスタンスが通信の途中で異常に中止された場合に発行されます。そのリスナーは引数を期待しません。

'aborted' イベントは、Http2Stream の書き込み可能側が終了していない場合にのみ発行されます。

イベント: 'close'#

'close' イベントは、Http2Stream が破棄されたときに発行されます。このイベントが発行されると、Http2Stream インスタンスは使用できなくなります。

ストリームをクローズする際に使用された HTTP/2 エラーコードは、http2stream.rstCode プロパティを使用して取得できます。コードが NGHTTP2_NO_ERROR (0) 以外の値である場合、'error' イベントも発行されています。

イベント: 'error'#

• error <Error>

'error' イベントは、Http2Stream の処理中にエラーが発生した場合に発行されます。

イベント: 'frameError'#

• type <integer> フレームタイプ。
• code <integer> エラーコード。
• id <integer> ストリーム ID (フレームがストリームに関連付けられていない場合は 0)。

'frameError' イベントは、フレームを送信しようとしてエラーが発生した場合に発行されます。呼び出されると、ハンドラ関数はフレームタイプを識別する整数引数と、エラーコードを識別する整数引数を受け取ります。Http2Stream インスタンスは、'frameError' イベントが発行された直後に破棄されます。

イベント: 'ready'#

'ready' イベントは、Http2Stream が開かれ、id が割り当てられ、使用できるようになったときに発行されます。リスナーは引数を期待しません。

イベント: 'timeout'#

'timeout' イベントは、http2stream.setTimeout() を使用して設定されたミリ秒数の間、この Http2Stream でアクティビティが受信されない場合に発行されます。そのリスナーは引数を期待しません。

イベント: 'trailers'#

• headers <HTTP/2 Headers Object> ヘッダーを記述するオブジェクト
• flags <number> 関連付けられた数値フラグ

'trailers' イベントは、トレーラーヘッダーフィールドに関連付けられたヘッダーのブロックが受信されたときに発行されます。リスナーコールバックには、HTTP/2 ヘッダーオブジェクトとヘッダーに関連付けられたフラグが渡されます。

このイベントは、トレーラーが受信される前に http2stream.end() が呼び出され、受信データが読み取られたりリッスンされたりしていない場合には発行されないことがあります。

stream.on('trailers', (headers, flags) => {
  console.log(headers);
}); copy

イベント: 'wantTrailers'#

'wantTrailers' イベントは、Http2Stream がフレームで送信する最後の DATA フレームをキューに入れ、Http2Stream がトレーラーヘッダーを送信する準備ができたときに発行されます。リクエストまたはレスポンスを開始する際、このイベントを発行するためには waitForTrailers オプションを設定する必要があります。

http2stream.aborted#

• 型: <boolean>

Http2Stream インスタンスが異常に中止された場合は true に設定されます。設定されると、'aborted' イベントが発行されています。

http2stream.bufferSize#

• 型: <number>

このプロパティは、現在書き込みのためにバッファリングされている文字数を示します。詳細は net.Socket.bufferSize を参照してください。

http2stream.close(code[, callback])#

• code <number> エラーコードを識別する符号なし 32 ビット整数。デフォルト: http2.constants.NGHTTP2_NO_ERROR (0x00)。
• callback <Function> 'close' イベントをリッスンするために登録されるオプションの関数。

接続された HTTP/2 ピアに RST_STREAM フレームを送信することで、Http2Stream インスタンスをクローズします。

http2stream.closed#

• 型: <boolean>

Http2Stream インスタンスがクローズされている場合は true に設定されます。

http2stream.destroyed#

• 型: <boolean>

Http2Stream インスタンスが破棄され、使用できなくなった場合は true に設定されます。

http2stream.endAfterHeaders#

• 型: <boolean>

受信したリクエストまたはレスポンスの HEADERS フレームで END_STREAM フラグが設定されていた場合は true に設定されます。これは、追加のデータを受信すべきではなく、Http2Stream の読み取り可能側がクローズされることを示します。

http2stream.id#

• 型: <number> | <undefined>

この Http2Stream インスタンスの数値ストリーム識別子。ストリーム識別子がまだ割り当てられていない場合は undefined に設定されます。

http2stream.pending#

• 型: <boolean>

Http2Stream インスタンスにまだ数値ストリーム識別子が割り当てられていない場合は true に設定されます。

http2stream.priority(options)#

空のメソッドであり、一部の後方互換性を維持するためにのみ存在します。

http2stream.rstCode#

• 型: <number>

接続されたピアから RST_STREAM フレームを受信した後、http2stream.close() または http2stream.destroy() を呼び出した後に Http2Stream が破棄されたときに報告される RST_STREAM エラーコードに設定されます。Http2Stream がクローズされていない場合は undefined になります。

http2stream.sentHeaders#

• 型: <HTTP/2 Headers Object>

この Http2Stream に対して送信された送信ヘッダーを含むオブジェクト。

http2stream.sentInfoHeaders#

• 型: <HTTP/2 Headers Object[]>

この Http2Stream に対して送信された送信情報 (追加) ヘッダーを含むオブジェクトの配列。

http2stream.sentTrailers#

• 型: <HTTP/2 Headers Object>

この HttpStream に対して送信された送信トレーラーを含むオブジェクト。

http2stream.session#

• 型: <Http2Session>

この Http2Stream を所有する Http2Session インスタンスへの参照。Http2Stream インスタンスが破棄された後は undefined になります。

http2stream.setTimeout(msecs, callback)#

• msecs <number>
• callback <Function>

import { connect, constants } from 'node:http2';
const client = connect('http://example.org:8000');
const { NGHTTP2_CANCEL } = constants;
const req = client.request({ ':path': '/' });

// Cancel the stream if there's no activity after 5 seconds
req.setTimeout(5000, () => req.close(NGHTTP2_CANCEL));const http2 = require('node:http2');
const client = http2.connect('http://example.org:8000');
const { NGHTTP2_CANCEL } = http2.constants;
const req = client.request({ ':path': '/' });

// Cancel the stream if there's no activity after 5 seconds
req.setTimeout(5000, () => req.close(NGHTTP2_CANCEL));copy

http2stream.state#

Http2Stream の現在の状態に関するその他の情報を提供します。

• 型: <Object>
  • localWindowSize <number> 接続されたピアが WINDOW_UPDATE を受信せずにこの Http2Stream に対して送信できるバイト数。
  • state <number> nghttp2 によって決定される Http2Stream の低レベルの現在の状態を示すフラグ。
  • localClose <number> この Http2Stream がローカルでクローズされた場合は 1。
  • remoteClose <number> この Http2Stream がリモートでクローズされた場合は 1。
  • sumDependencyWeight <number> レガシープロパティ、常に 0 に設定されます。
  • weight <number> レガシープロパティ、常に 16 に設定されます。

この Http2Stream の現在の状態。

http2stream.sendTrailers(headers)#

• headers <HTTP/2 Headers Object>

接続された HTTP/2 ピアにトレーラー HEADERS フレームを送信します。このメソッドは Http2Stream を即座にクローズさせるため、'wantTrailers' イベントが発行された後にのみ呼び出す必要があります。リクエストを送信するかレスポンスを送信する際、トレーラーを送信できるように最後の DATA フレームの後に Http2Stream を開いたままにするためには、options.waitForTrailers オプションを設定する必要があります。

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respond(undefined, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ xyz: 'abc' });
  });
  stream.end('Hello World');
});const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respond(undefined, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ xyz: 'abc' });
  });
  stream.end('Hello World');
});copy

HTTP/1 仕様では、トレーラーに HTTP/2 擬似ヘッダーフィールド (例: ':method', ':path' など) を含めることを禁止しています。

イベント: 'continue'#

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

イベント: 'headers'#

• headers <HTTP/2 Headers Object>
• flags <number>
• rawHeaders <HTTP/2 Raw Headers>

'headers' イベントは、ストリームに対して追加のヘッダーブロックが受信されたときに発行されます。例えば、1xx 情報ヘッダーのブロックが受信されたときなどです。リスナーコールバックには、HTTP/2 ヘッダーオブジェクト、ヘッダーに関連付けられたフラグ、および生の形式のヘッダーが渡されます (参照: HTTP/2 Raw Headers)。

stream.on('headers', (headers, flags) => {
  console.log(headers);
}); copy

イベント: 'push'#

• headers <HTTP/2 Headers Object>
• flags <number>

'push' イベントは、サーバープッシュストリームのレスポンスヘッダーが受信されたときに発行されます。リスナーコールバックには、HTTP/2 ヘッダーオブジェクトとヘッダーに関連付けられたフラグが渡されます。

stream.on('push', (headers, flags) => {
  console.log(headers);
}); copy

イベント: 'response'#

• headers <HTTP/2 Headers Object>
• flags <number>
• rawHeaders <HTTP/2 Raw Headers>

'response' イベントは、このストリームに対して接続された HTTP/2 サーバーからレスポンス HEADERS フレームが受信されたときに発行されます。リスナーは3つの引数で呼び出されます: 受信した HTTP/2 ヘッダーオブジェクトを含む Object、ヘッダーに関連付けられたフラグ、および生の形式のヘッダーです (参照: HTTP/2 Raw Headers)。

import { connect } from 'node:http2';
const client = connect('https://');
const req = client.request({ ':path': '/' });
req.on('response', (headers, flags) => {
  console.log(headers[':status']);
});const http2 = require('node:http2');
const client = http2.connect('https://');
const req = client.request({ ':path': '/' });
req.on('response', (headers, flags) => {
  console.log(headers[':status']);
});copy

http2stream.additionalHeaders(headers)#

• headers <HTTP/2 Headers Object>

接続された HTTP/2 ピアに追加の情報 HEADERS フレームを送信します。

http2stream.headersSent#

• 型: <boolean>

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

http2stream.pushAllowed#

• 型: <boolean>

リモートクライアントの最新の SETTINGS フレームの SETTINGS_ENABLE_PUSH フラグにマップされた読み取り専用プロパティ。リモートピアがプッシュストリームを受け入れる場合は true、それ以外は false になります。設定は同じ Http2Session 内のすべての Http2Stream で同じです。

http2stream.pushStream(headers[, options], callback)#

• headers <HTTP/2 Headers Object>
• options <Object>
  • exclusive <boolean> true であり、parent が親ストリームを識別する場合、作成されたストリームは親の唯一の直接の依存関係となり、他のすべての既存の依存関係は新しく作成されたストリームの依存関係になります。デフォルト: false。
  • parent <number> 新しく作成されたストリームが依存するストリームの数値識別子を指定します。
• callback <Function> プッシュストリームが開始された後に呼び出されるコールバック。
  • `err` <Error>
  • pushStream <ServerHttp2Stream> 返された pushStream オブジェクト。
  • headers <HTTP/2 Headers Object> pushStream が開始されたときのヘッダーオブジェクト。

プッシュストリームを開始します。コールバックは、プッシュストリーム用に作成された新しい Http2Stream インスタンスを第2引数として、または Error を第1引数として渡されて呼び出されます。

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 });
  stream.pushStream({ ':path': '/' }, (err, pushStream, headers) => {
    if (err) throw err;
    pushStream.respond({ ':status': 200 });
    pushStream.end('some pushed data');
  });
  stream.end('some data');
});const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 });
  stream.pushStream({ ':path': '/' }, (err, pushStream, headers) => {
    if (err) throw err;
    pushStream.respond({ ':status': 200 });
    pushStream.end('some pushed data');
  });
  stream.end('some data');
});copy

プッシュストリームの重みを HEADERS フレームで設定することは許可されていません。同時ストリーム間のサーバーサイドの帯域幅バランスを有効にするには、http2stream.priority に weight 値を渡し、silent オプションを true に設定します。

プッシュされたストリーム内から http2stream.pushStream() を呼び出すことは許可されておらず、エラーがスローされます。

http2stream.respond([headers[, options]])#

• headers <HTTP/2 Headers Object> | <HTTP/2 Raw Headers>
• options <Object>
  • endStream <boolean> レスポンスにペイロードデータが含まれないことを示すには true に設定します。
  • waitForTrailers <boolean> true の場合、Http2Stream は最後の DATA フレームが送信された後に 'wantTrailers' イベントを発行します。

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 });
  stream.end('some data');
});const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 });
  stream.end('some data');
});copy

レスポンスを開始します。options.waitForTrailers オプションが設定されている場合、送信するペイロードデータの最後のチャンクがキューに入れられた直後に 'wantTrailers' イベントが発行されます。その後、http2stream.sendTrailers() メソッドを使用して、トレーラーヘッダーフィールドをピアに送信できます。

options.waitForTrailers が設定されている場合、最後の DATA フレームが送信されても Http2Stream は自動的にクローズされません。ユーザーコードは http2stream.sendTrailers() または http2stream.close() のいずれかを呼び出して Http2Stream をクローズする必要があります。

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 }, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });
  stream.end('some data');
});const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respond({ ':status': 200 }, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });
  stream.end('some data');
});copy

http2stream.respondWithFD(fd[, headers[, options]])#

• fd <number> | <FileHandle> 読み取り可能なファイル記述子。
• headers <HTTP/2 Headers Object>
• options <Object>
  • statCheck <Function>
  • waitForTrailers <boolean> true の場合、Http2Stream は最後の DATA フレームが送信された後に 'wantTrailers' イベントを発行します。
  • offset <number> 読み取りを開始するオフセット位置。
  • length <number> fd から送信するデータの量。

指定されたファイル記述子からデータが読み取られるレスポンスを開始します。指定されたファイル記述子に対して検証は行われません。ファイル記述子を使用してデータを読み取ろうとしてエラーが発生した場合、Http2Stream は標準の INTERNAL_ERROR コードを使用して RST_STREAM フレームでクローズされます。

使用すると、Http2Stream オブジェクトの Duplex インターフェースは自動的にクローズされます。

import { createServer } from 'node:http2';
import { openSync, fstatSync, closeSync } from 'node:fs';

const server = createServer();
server.on('stream', (stream) => {
  const fd = openSync('/some/file', 'r');

  const stat = fstatSync(fd);
  const headers = {
    'content-length': stat.size,
    'last-modified': stat.mtime.toUTCString(),
    'content-type': 'text/plain; charset=utf-8',
  };
  stream.respondWithFD(fd, headers);
  stream.on('close', () => closeSync(fd));
});const http2 = require('node:http2');
const fs = require('node:fs');

const server = http2.createServer();
server.on('stream', (stream) => {
  const fd = fs.openSync('/some/file', 'r');

  const stat = fs.fstatSync(fd);
  const headers = {
    'content-length': stat.size,
    'last-modified': stat.mtime.toUTCString(),
    'content-type': 'text/plain; charset=utf-8',
  };
  stream.respondWithFD(fd, headers);
  stream.on('close', () => fs.closeSync(fd));
});copy

オプションの options.statCheck 関数を指定して、ユーザーコードが指定された fd の fs.Stat の詳細に基づいて追加のコンテンツヘッダーを設定する機会を与えることができます。statCheck 関数が提供されている場合、http2stream.respondWithFD() メソッドは fs.fstat() 呼び出しを実行して、提供されたファイル記述子の詳細を収集します。

offset および length オプションを使用して、レスポンスを特定の範囲のサブセットに制限できます。これは、たとえば HTTP Range リクエストをサポートするために使用できます。

ファイル記述子または FileHandle はストリームがクローズされても閉じられないため、不要になったら手動で閉じる必要があります。複数のストリームで同じファイル記述子を同時に使用することはサポートされておらず、データが失われる可能性があります。ストリームが終了した後にファイル記述子を再利用することはサポートされています。

options.waitForTrailers オプションが設定されている場合、送信するペイロードデータの最後のチャンクがキューに入れられた直後に 'wantTrailers' イベントが発行されます。その後、http2stream.sendTrailers() メソッドを使用して、トレーラーヘッダーフィールドをピアに送信できます。

options.waitForTrailers が設定されている場合、最後の DATA フレームが送信されても Http2Stream は自動的にクローズされません。ユーザーコードは、Http2Stream をクローズするために http2stream.sendTrailers() または http2stream.close() のいずれかを呼び出す**必要があります**。

import { createServer } from 'node:http2';
import { openSync, fstatSync, closeSync } from 'node:fs';

const server = createServer();
server.on('stream', (stream) => {
  const fd = openSync('/some/file', 'r');

  const stat = fstatSync(fd);
  const headers = {
    'content-length': stat.size,
    'last-modified': stat.mtime.toUTCString(),
    'content-type': 'text/plain; charset=utf-8',
  };
  stream.respondWithFD(fd, headers, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });

  stream.on('close', () => closeSync(fd));
});const http2 = require('node:http2');
const fs = require('node:fs');

const server = http2.createServer();
server.on('stream', (stream) => {
  const fd = fs.openSync('/some/file', 'r');

  const stat = fs.fstatSync(fd);
  const headers = {
    'content-length': stat.size,
    'last-modified': stat.mtime.toUTCString(),
    'content-type': 'text/plain; charset=utf-8',
  };
  stream.respondWithFD(fd, headers, { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });

  stream.on('close', () => fs.closeSync(fd));
});copy

http2stream.respondWithFile(path[, headers[, options]])#

• path <string> | <Buffer> | <URL>
• headers <HTTP/2 Headers Object>
• options <Object>
  • statCheck <Function>
  • onError <Function> 送信前にエラーが発生した場合に呼び出されるコールバック関数。
  • waitForTrailers <boolean> true の場合、Http2Stream は最後の DATA フレームが送信された後に 'wantTrailers' イベントを発行します。
  • offset <number> 読み取りを開始するオフセット位置。
  • length <number> fd から送信するデータの量。

通常のファイルをレスポンスとして送信します。path は通常のファイルを指定する必要があり、そうでない場合は Http2Stream オブジェクトで 'error' イベントが発行されます。

使用すると、Http2Stream オブジェクトの Duplex インターフェースは自動的にクローズされます。

オプションの options.statCheck 関数を指定して、ユーザーコードが指定されたファイルの fs.Stat の詳細に基づいて追加のコンテンツヘッダーを設定する機会を与えることができます。

ファイルデータを読み取ろうとしてエラーが発生した場合、Http2Stream は標準の INTERNAL_ERROR コードを使用して RST_STREAM フレームでクローズされます。onError コールバックが定義されている場合は、それが呼び出されます。それ以外の場合、ストリームは破棄されます。

ファイルパスを使用した例

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  function statCheck(stat, headers) {
    headers['last-modified'] = stat.mtime.toUTCString();
  }

  function onError(err) {
    // stream.respond() can throw if the stream has been destroyed by
    // the other side.
    try {
      if (err.code === 'ENOENT') {
        stream.respond({ ':status': 404 });
      } else {
        stream.respond({ ':status': 500 });
      }
    } catch (err) {
      // Perform actual error handling.
      console.error(err);
    }
    stream.end();
  }

  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { statCheck, onError });
});const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  function statCheck(stat, headers) {
    headers['last-modified'] = stat.mtime.toUTCString();
  }

  function onError(err) {
    // stream.respond() can throw if the stream has been destroyed by
    // the other side.
    try {
      if (err.code === 'ENOENT') {
        stream.respond({ ':status': 404 });
      } else {
        stream.respond({ ':status': 500 });
      }
    } catch (err) {
      // Perform actual error handling.
      console.error(err);
    }
    stream.end();
  }

  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { statCheck, onError });
});copy

options.statCheck 関数は、false を返すことで送信操作をキャンセルするためにも使用できます。たとえば、条件付きリクエストは、stat の結果をチェックしてファイルが変更されているかどうかを判断し、適切な 304 レスポンスを返すことができます。

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  function statCheck(stat, headers) {
    // Check the stat here...
    stream.respond({ ':status': 304 });
    return false; // Cancel the send operation
  }
  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { statCheck });
});const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  function statCheck(stat, headers) {
    // Check the stat here...
    stream.respond({ ':status': 304 });
    return false; // Cancel the send operation
  }
  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { statCheck });
});copy

content-length ヘッダーフィールドは自動的に設定されます。

offset および length オプションを使用して、レスポンスを特定の範囲のサブセットに制限できます。これは、たとえば HTTP Range リクエストをサポートするために使用できます。

options.onError 関数は、ファイルの配信が開始される前に発生する可能性のあるすべてのエラーを処理するためにも使用できます。デフォルトの動作はストリームを破棄することです。

options.waitForTrailers オプションが設定されている場合、送信するペイロードデータの最後のチャンクがキューに入れられた直後に 'wantTrailers' イベントが発行されます。その後、http2stream.sendTrailers() メソッドを使用して、トレーラーヘッダーフィールドをピアに送信できます。

options.waitForTrailers が設定されている場合、最後の DATA フレームが送信されても Http2Stream は自動的にクローズされません。ユーザーコードは http2stream.sendTrailers() または http2stream.close() のいずれかを呼び出して Http2Stream をクローズする必要があります。

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream) => {
  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });
});const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream) => {
  stream.respondWithFile('/some/file',
                         { 'content-type': 'text/plain; charset=utf-8' },
                         { waitForTrailers: true });
  stream.on('wantTrailers', () => {
    stream.sendTrailers({ ABC: 'some value to send' });
  });
});copy

イベント: 'checkContinue'#

• request <http2.Http2ServerRequest>
• response <http2.Http2ServerResponse>

'request' リスナーが登録されているか、http2.createServer() にコールバック関数が提供されている場合、HTTP Expect: 100-continue を含むリクエストが受信されるたびに 'checkContinue' イベントが発行されます。このイベントがリッスンされていない場合、サーバーは適切にステータス 100 Continue で自動的に応答します。

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

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

イベント: 'connection'#

• socket <stream.Duplex>

このイベントは、新しい TCP ストリームが確立されたときに発行されます。socket は通常、net.Socket 型のオブジェクトです。通常、ユーザーはこのイベントにアクセスする必要はありません。

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

イベント: 'request'#

• request <http2.Http2ServerRequest>
• response <http2.Http2ServerResponse>

リクエストがあるたびに発行されます。セッションごとに複数のリクエストがある場合があります。互換性 API を参照してください。

イベント: 'session'#

• session <ServerHttp2Session>

'session' イベントは、Http2Server によって新しい Http2Session が作成されたときに発行されます。

イベント: 'sessionError'#

• error <Error>
• session <ServerHttp2Session>

'sessionError' イベントは、Http2Server に関連付けられた Http2Session オブジェクトによって 'error' イベントが発行されたときに発行されます。

イベント: 'stream'#

• stream <Http2Stream> ストリームへの参照
• headers <HTTP/2 Headers Object> ヘッダーを記述するオブジェクト
• flags <number> 関連付けられた数値フラグ
• rawHeaders <HTTP/2 Raw Headers> 生のヘッダーを含む配列

'stream' イベントは、サーバーに関連付けられた Http2Session によって 'stream' イベントが発行されたときに発行されます。

Http2Session の 'stream' イベントも参照してください。

import { createServer, constants } from 'node:http2';
const {
  HTTP2_HEADER_METHOD,
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
  HTTP2_HEADER_CONTENT_TYPE,
} = constants;

const server = createServer();
server.on('stream', (stream, headers, flags) => {
  const method = headers[HTTP2_HEADER_METHOD];
  const path = headers[HTTP2_HEADER_PATH];
  // ...
  stream.respond({
    [HTTP2_HEADER_STATUS]: 200,
    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
});const http2 = require('node:http2');
const {
  HTTP2_HEADER_METHOD,
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
  HTTP2_HEADER_CONTENT_TYPE,
} = http2.constants;

const server = http2.createServer();
server.on('stream', (stream, headers, flags) => {
  const method = headers[HTTP2_HEADER_METHOD];
  const path = headers[HTTP2_HEADER_PATH];
  // ...
  stream.respond({
    [HTTP2_HEADER_STATUS]: 200,
    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
});copy

イベント: 'timeout'#

'timeout' イベントは、http2server.setTimeout() を使用して設定されたミリ秒数の間、サーバーにアクティビティがない場合に発行されます。デフォルト: 0 (タイムアウトなし)

server.close([callback])#

• callback <Function>

サーバーが新しいセッションを確立するのを停止します。これは、HTTP/2 セッションの持続的な性質のため、新しいリクエストストリームが作成されるのを妨げません。サーバーを正常にシャットダウンするには、すべてのアクティブなセッションで http2session.close() を呼び出します。

callback が指定された場合、サーバーはすでに新しいセッションの許可を停止していますが、すべてのアクティブなセッションが閉じられるまで呼び出されません。詳細については net.Server.close() を参照してください。

server[Symbol.asyncDispose]()#

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

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

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

http2 サーバーリクエストのタイムアウト値を設定するために使用され、msecs ミリ秒後に Http2Server 上でアクティビティがない場合に呼び出されるコールバック関数を設定します。

指定されたコールバックは、'timeout' イベントのリスナーとして登録されます。

callback が関数でない場合、新しい ERR_INVALID_ARG_TYPE エラーがスローされます。

server.timeout#

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

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

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

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

server.updateSettings([settings])#

• settings <HTTP/2 Settings Object>

指定された設定でサーバーを更新するために使用されます。

無効な settings 値に対して ERR_HTTP2_INVALID_SETTING_VALUE をスローします。

無効な settings 引数に対して ERR_INVALID_ARG_TYPE をスローします。

イベント: 'checkContinue'#

• request <http2.Http2ServerRequest>
• response <http2.Http2ServerResponse>

'request' リスナーが登録されている場合、または http2.createSecureServer() にコールバック関数が指定されている場合、HTTP Expect: 100-continue を含むリクエストを受信するたびに 'checkContinue' イベントが発生します。このイベントがリッスンされていない場合、サーバーは適切にステータス 100 Continue で自動的に応答します。

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

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

イベント: 'connection'#

• socket <stream.Duplex>

このイベントは、新しいTCPストリームが確立されたとき、TLSハンドシェイクが開始される前に発生します。socket は通常 net.Socket 型のオブジェクトです。通常、ユーザーはこのイベントにアクセスする必要はありません。

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

イベント: 'request'#

• request <http2.Http2ServerRequest>
• response <http2.Http2ServerResponse>

リクエストがあるたびに発行されます。セッションごとに複数のリクエストがある場合があります。互換性 API を参照してください。

イベント: 'session'#

• session <ServerHttp2Session>

'session' イベントは、Http2SecureServer によって新しい Http2Session が作成されたときに発生します。

イベント: 'sessionError'#

• error <Error>
• session <ServerHttp2Session>

'sessionError' イベントは、Http2SecureServer に関連付けられた Http2Session オブジェクトによって 'error' イベントが発生したときに発生します。

イベント: 'stream'#

• stream <Http2Stream> ストリームへの参照
• headers <HTTP/2 Headers Object> ヘッダーを記述するオブジェクト
• flags <number> 関連付けられた数値フラグ
• rawHeaders <HTTP/2 Raw Headers> 生のヘッダーを含む配列

'stream' イベントは、サーバーに関連付けられた Http2Session によって 'stream' イベントが発行されたときに発行されます。

Http2Session の 'stream' イベントも参照してください。

import { createSecureServer, constants } from 'node:http2';
const {
  HTTP2_HEADER_METHOD,
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
  HTTP2_HEADER_CONTENT_TYPE,
} = constants;

const options = getOptionsSomehow();

const server = createSecureServer(options);
server.on('stream', (stream, headers, flags) => {
  const method = headers[HTTP2_HEADER_METHOD];
  const path = headers[HTTP2_HEADER_PATH];
  // ...
  stream.respond({
    [HTTP2_HEADER_STATUS]: 200,
    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
});const http2 = require('node:http2');
const {
  HTTP2_HEADER_METHOD,
  HTTP2_HEADER_PATH,
  HTTP2_HEADER_STATUS,
  HTTP2_HEADER_CONTENT_TYPE,
} = http2.constants;

const options = getOptionsSomehow();

const server = http2.createSecureServer(options);
server.on('stream', (stream, headers, flags) => {
  const method = headers[HTTP2_HEADER_METHOD];
  const path = headers[HTTP2_HEADER_PATH];
  // ...
  stream.respond({
    [HTTP2_HEADER_STATUS]: 200,
    [HTTP2_HEADER_CONTENT_TYPE]: 'text/plain; charset=utf-8',
  });
  stream.write('hello ');
  stream.end('world');
});copy

イベント: 'timeout'#

'timeout' イベントは、http2secureServer.setTimeout() を使用して設定されたミリ秒数だけサーバー上でアクティビティがない場合に発生します。デフォルト: 2分。

イベント: 'unknownProtocol'#

• socket <stream.Duplex>

'unknownProtocol' イベントは、接続中のクライアントが許可されたプロトコル (つまり HTTP/2 または HTTP/1.1) のネゴシエーションに失敗した場合に発生します。イベントハンドラは処理のためにソケットを受け取ります。このイベントにリスナーが登録されていない場合、接続は終了します。タイムアウトは、http2.createSecureServer() に渡される 'unknownProtocolTimeout' オプションを使用して指定できます。

以前のバージョンの Node.js では、allowHTTP1 が false であり、TLS ハンドシェイク中にクライアントが ALPN 拡張を送信しないか、HTTP/2 (h2) を含まない ALPN 拡張を送信した場合にこのイベントが発生していました。新しいバージョンの Node.js は、allowHTTP1 が false であり、クライアントが ALPN 拡張を送信しない場合にのみこのイベントを発生させます。クライアントが HTTP/2 (または allowHTTP1 が true の場合は HTTP/1.1) を含まない ALPN 拡張を送信した場合、TLS ハンドシェイクは失敗し、セキュアな接続は確立されません。

互換性 API を参照してください。

server.close([callback])#

• callback <Function>

サーバーが新しいセッションを確立するのを停止します。これは、HTTP/2 セッションの持続的な性質のため、新しいリクエストストリームが作成されるのを妨げません。サーバーを正常にシャットダウンするには、すべてのアクティブなセッションで http2session.close() を呼び出します。

callback が指定された場合、サーバーはすでに新しいセッションの許可を停止していますが、すべてのアクティブなセッションが閉じられるまで呼び出されません。詳細については tls.Server.close() を参照してください。

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

• msecs <number> デフォルト: 120000 (2分)
• callback <Function>
• 戻り値: <Http2SecureServer>

http2 セキュアサーバーのリクエストのタイムアウト値を設定し、msecs ミリ秒後に Http2SecureServer 上でアクティビティがない場合に呼び出されるコールバック関数を設定するために使用されます。

指定されたコールバックは、'timeout' イベントのリスナーとして登録されます。

callback が関数でない場合、新しい ERR_INVALID_ARG_TYPE エラーがスローされます。

server.timeout#

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

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

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

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

server.updateSettings([settings])#

• settings <HTTP/2 Settings Object>

指定された設定でサーバーを更新するために使用されます。

無効な settings 値に対して ERR_HTTP2_INVALID_SETTING_VALUE をスローします。

無効な settings 引数に対して ERR_INVALID_ARG_TYPE をスローします。

RST_STREAM と GOAWAY のエラーコード#

値	名前	定数
0x00	No Error	http2.constants.NGHTTP2_NO_ERROR
0x01	Protocol Error	http2.constants.NGHTTP2_PROTOCOL_ERROR
0x02	Internal Error	http2.constants.NGHTTP2_INTERNAL_ERROR
0x03	Flow Control Error	http2.constants.NGHTTP2_FLOW_CONTROL_ERROR
0x04	Settings Timeout	http2.constants.NGHTTP2_SETTINGS_TIMEOUT
0x05	Stream Closed	http2.constants.NGHTTP2_STREAM_CLOSED
0x06	Frame Size Error	http2.constants.NGHTTP2_FRAME_SIZE_ERROR
0x07	Refused Stream	http2.constants.NGHTTP2_REFUSED_STREAM
0x08	Cancel	http2.constants.NGHTTP2_CANCEL
0x09	Compression Error	http2.constants.NGHTTP2_COMPRESSION_ERROR
0x0a	Connect Error	http2.constants.NGHTTP2_CONNECT_ERROR
0x0b	Enhance Your Calm	http2.constants.NGHTTP2_ENHANCE_YOUR_CALM
0x0c	Inadequate Security	http2.constants.NGHTTP2_INADEQUATE_SECURITY
0x0d	HTTP/1.1 Required	http2.constants.NGHTTP2_HTTP_1_1_REQUIRED

'timeout' イベントは、http2server.setTimeout() を使用して設定されたミリ秒数だけサーバー上でアクティビティがない場合に発生します。

const headers = {
  ':status': '200',
  'content-type': 'text-plain',
  'ABC': ['has', 'more', 'than', 'one', 'value'],
};

stream.respond(headers); copy

import { createServer } from 'node:http2';
const server = createServer();
server.on('stream', (stream, headers) => {
  console.log(headers[':path']);
  console.log(headers.ABC);
});const http2 = require('node:http2');
const server = http2.createServer();
server.on('stream', (stream, headers) => {
  console.log(headers[':path']);
  console.log(headers.ABC);
});copy

生ヘッダ#

一部の API では、オブジェクト形式に加えて、ヘッダを生のフラットな配列として渡したりアクセスしたりすることもできます。これにより、順序や重複キーの詳細を保持して、生の送信形式と一致させることができます。

この形式では、キーと値は同じリストに含まれます。これはタプルのリストでは*ありません*。したがって、偶数番目のオフセットはキー値であり、奇数番目のオフセットは関連する値です。重複するヘッダはマージされないため、各キーと値のペアは別々に表示されます。

これは、受信したヘッダをそのまま転送する必要があるプロキシなどの場合や、ヘッダが既に生の形式で利用可能な場合のパフォーマンス最適化として役立ちます。

const rawHeaders = [
  ':status',
  '404',
  'content-type',
  'text/plain',
];

stream.respond(rawHeaders); copy

機密ヘッダ#

HTTP2 ヘッダは機密としてマークすることができ、これは HTTP/2 ヘッダ圧縮アルゴリズムがそれらを決してインデックスしないことを意味します。これは、エントロピーが低く、攻撃者にとって価値があると考えられるヘッダ値 (例えば Cookie や Authorization) にとって意味があります。これを実現するには、ヘッダ名を [http2.sensitiveHeaders] プロパティに配列として追加します。

const headers = {
  ':status': '200',
  'content-type': 'text-plain',
  'cookie': 'some-cookie',
  'other-sensitive-header': 'very secret data',
  [http2.sensitiveHeaders]: ['cookie', 'other-sensitive-header'],
};

stream.respond(headers); copy

Authorization や短い Cookie ヘッダなど、一部のヘッダでは、このフラグは自動的に設定されます。

このプロパティは受信ヘッダにも設定されます。これには、自動的にそのようにマークされたものを含む、機密としてマークされたすべてのヘッダの名前が含まれます。

生のヘッダの場合、これは配列自体の別のキーと値のペアとしてではなく、rawHeadersArray[http2.sensitiveHeaders] = ['cookie'] のように配列のプロパティとして設定する必要があります。

イベント: 'aborted'#

'aborted' イベントは、Http2ServerRequest インスタンスが通信の途中で異常に中止された場合に常に発生します。

'aborted' イベントは、Http2ServerRequest の書き込み側が終了していない場合にのみ発生します。

イベント: 'close'#

基盤となる Http2Stream が閉じられたことを示します。'end' と同様に、このイベントはレスポンスごとに一度だけ発生します。

request.aborted#

• 型: <boolean>

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

request.authority#

• 型: <string>

リクエストの authority 疑似ヘッダフィールドです。HTTP/2 はリクエストが :authority または host のいずれかを設定することを許可するため、この値は存在する場合 req.headers[':authority'] から派生します。それ以外の場合は、req.headers['host'] から派生します。

request.complete#

• 型: <boolean>

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

request.connection#

• 型: <net.Socket> | <tls.TLSSocket>

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

request.destroy([error])#

• error <Error>

Http2ServerRequest を受信した Http2Stream で destroy() を呼び出します。error が指定されている場合、'error' イベントが発生し、error はイベントのリスナーに引数として渡されます。

ストリームがすでに破棄されている場合は何もしません。

request.headers#

• 型: <Object>

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

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

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

HTTP/2 ヘッダオブジェクト を参照してください。

HTTP/2 では、リクエストパス、ホスト名、プロトコル、およびメソッドは、: 文字 (例: ':path') が先頭に付いた特別なヘッダとして表されます。これらの特別なヘッダは request.headers オブジェクトに含まれます。これらの特別なヘッダを誤って変更しないように注意しないと、エラーが発生する可能性があります。例えば、リクエストからすべてのヘッダを削除するとエラーが発生します。

removeAllHeaders(request.headers);
assert(request.url);   // Fails because the :path header has been removed copy

request.httpVersion#

• 型: <string>

サーバーリクエストの場合、クライアントから送信された HTTP バージョン。クライアントレスポンスの場合、接続先のサーバーの HTTP バージョン。'2.0' を返します。

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

request.method#

• 型: <string>

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

request.rawHeaders#

• 型: <HTTP/2 Raw Headers>

受信したままの生のリクエスト/レスポンスヘッダリスト。

// 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

request.rawTrailers#

• 型: <string[]>

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

request.scheme#

• 型: <string>

ターゲット URL のスキーム部分を示すリクエストスキーム疑似ヘッダフィールド。

request.setTimeout(msecs, callback)#

• msecs <number>
• callback <Function>
• 戻り値: <http2.Http2ServerRequest>

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

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

request.socket#

• 型: <net.Socket> | <tls.TLSSocket>

net.Socket (または tls.TLSSocket) として機能するが、HTTP/2 ロジックに基づいてゲッター、セッター、およびメソッドを適用する Proxy オブジェクトを返します。

destroyed, readable, および writable プロパティは request.stream から取得され、設定されます。

destroy, emit, end, on および once メソッドは request.stream で呼び出されます。

setTimeout メソッドは request.stream.session で呼び出されます。

pause, read, resume, および write は、コード ERR_HTTP2_NO_SOCKET_MANIPULATION のエラーをスローします。詳細については Http2Session とソケット を参照してください。

他のすべての相互作用はソケットに直接ルーティングされます。TLS サポートでは、request.socket.getPeerCertificate() を使用してクライアントの認証詳細を取得します。

request.stream#

• 型: <Http2Stream>

リクエストをバックアップする Http2Stream オブジェクト。

request.trailers#

• 型: <Object>

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

request.url#

• 型: <string>

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

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

の場合、request.url は次のようになります。

'/status?name=ryan' copy

URL をその部分に解析するには、new URL() を使用できます。

$ node
> new URL('/status?name=ryan', 'http://example.com')
URL {
  href: 'http://example.com/status?name=ryan',
  origin: 'http://example.com',
  protocol: 'http:',
  username: '',
  password: '',
  host: 'example.com',
  hostname: 'example.com',
  port: '',
  pathname: '/status',
  search: '?name=ryan',
  searchParams: URLSearchParams { 'name' => 'ryan' },
  hash: ''
} copy

イベント: 'close'#

response.end() が呼び出されるかフラッシュできる前に、基盤となる Http2Stream が終了したことを示します。

イベント: 'finish'#

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

このイベントの後、レスポンスオブジェクトでこれ以上のイベントは発生しません。

response.addTrailers(headers)#

• headers <Object>

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

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

response.appendHeader(name, value)#

• name <string>
• value <string> | <string[]>

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

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

ヘッダに以前の値がなかった場合、response.setHeader() を呼び出すことと同じです。

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

// Returns headers including "set-cookie: a" and "set-cookie: b"
const server = http2.createServer((req, res) => {
  res.setHeader('set-cookie', 'a');
  res.appendHeader('set-cookie', 'b');
  res.writeHead(200);
  res.end('ok');
}); copy

response.connection#

• 型: <net.Socket> | <tls.TLSSocket>

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

response.createPushResponse(headers, callback)#

• headers <HTTP/2 Headers Object> ヘッダーを記述するオブジェクト
• callback <Function> http2stream.pushStream() が終了したとき、またはプッシュされた Http2Stream の作成試行が失敗または拒否されたとき、または http2stream.pushStream() メソッドを呼び出す前に Http2ServerRequest の状態が閉じられたときに一度呼び出されます。
  • `err` <Error>
  • res <http2.Http2ServerResponse> 新しく作成された Http2ServerResponse オブジェクト

指定されたヘッダで http2stream.pushStream() を呼び出し、成功した場合、新しく作成された Http2ServerResponse に指定された Http2Stream をラップし、コールバックパラメータとして渡します。Http2ServerRequest が閉じられると、コールバックはエラー ERR_HTTP2_INVALID_STREAM で呼び出されます。

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>

レスポンスが完了したかどうかを示すブール値。false で始まります。response.end() が実行されると、値は true になります。

response.getHeader(name)#

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

すでにキューに入れられているがクライアントに送信されていないヘッダを読み取ります。名前は大文字と小文字を区別しません。

const contentType = response.getHeader('content-type'); 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#

• 型: <http2.Http2ServerRequest>

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

response.sendDate#

• 型: <boolean>

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

これはテスト目的でのみ無効にすべきです。HTTP はレスポンスに Date ヘッダを要求します。

response.setHeader(name, value)#

• name <string>
• value <string> | <string[]>

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

response.setHeader('Content-Type', 'text/html; charset=utf-8'); copy

または

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

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

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

// Returns content-type = text/plain
const server = http2.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html; charset=utf-8');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('ok');
}); copy

response.setTimeout(msecs[, callback])#

• msecs <number>
• callback <Function>
• 戻り値: <http2.Http2ServerResponse>

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

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

response.socket#

• 型: <net.Socket> | <tls.TLSSocket>

net.Socket (または tls.TLSSocket) として機能するが、HTTP/2 ロジックに基づいてゲッター、セッター、およびメソッドを適用する Proxy オブジェクトを返します。

destroyed, readable, および writable プロパティは response.stream から取得され、設定されます。

destroy, emit, end, on および once メソッドは response.stream で呼び出されます。

setTimeout メソッドは response.stream.session で呼び出されます。

pause, read, resume, および write は、コード ERR_HTTP2_NO_SOCKET_MANIPULATION のエラーをスローします。詳細については Http2Session とソケット を参照してください。

その他すべての相互作用はソケットに直接ルーティングされます。

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

response.statusCode#

• 型: <number>

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

response.statusCode = 404; copy

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

response.statusMessage#

• 型: <string>

ステータスメッセージは HTTP/2 (RFC 7540 8.1.2.4) でサポートされていません。空の文字列を返します。

response.stream#

• 型: <Http2Stream>

レスポンスをバックアップする Http2Stream オブジェクト。

response.writableEnded#

• 型: <boolean>

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

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

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

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

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

node:http モジュールでは、リクエストが HEAD リクエストの場合、レスポンスボディは省略されます。同様に、204 および 304 レスポンスはメッセージボディを含んではいけません。

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

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

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

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

response.writeContinue()#

ステータス 100 Continue をクライアントに送信し、リクエストボディを送信する必要があることを示します。Http2Server と Http2SecureServer の 'checkContinue' イベントを参照してください。

response.writeEarlyHints(hints)#

• hints <Object>

Link ヘッダ付きのステータス 103 Early Hints をクライアントに送信し、ユーザーエージェントがリンクされたリソースをプリロード/プリコネクトできることを示します。hints は、早期ヒントメッセージと共に送信されるヘッダの値を含むオブジェクトです。

例

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

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

• statusCode <number>
• statusMessage <string>
• headers <HTTP/2 Headers Object> | <HTTP/2 Raw Headers>
• 戻り値: <http2.Http2ServerResponse>

リクエストにレスポンスヘッダを送信します。ステータスコードは 404 のような 3 桁の HTTP ステータスコードです。最後の引数 headers はレスポンスヘッダです。

呼び出しを連鎖できるように、Http2ServerResponse への参照を返します。

HTTP/1 との互換性のために、人間が読める statusMessage を 2 番目の引数として渡すことができます。ただし、statusMessage は HTTP/2 内では意味がないため、引数は効果がなく、プロセスの警告が表示されます。

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

Content-Length は文字数ではなくバイト数で指定されます。Buffer.byteLength() API は、特定のエンコーディングでのバイト数を決定するために使用できます。送信メッセージでは、Node.js は Content-Length と送信されるボディの長さが等しいかどうかをチェックしません。ただし、メッセージを受信する場合、Node.js は Content-Length が実際のペイロードサイズと一致しない場合にメッセージを自動的に拒否します。

このメソッドは、response.end() が呼び出される前に、メッセージに対して最大 1 回呼び出すことができます。

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

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

// Returns content-type = text/plain
const server = http2.createServer((req, res) => {
  res.setHeader('Content-Type', 'text/html; charset=utf-8');
  res.setHeader('X-Foo', 'bar');
  res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
  res.end('ok');
}); copy

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