バッファ
ソースコード: lib/buffer.js
Bufferオブジェクトは、固定長のバイトシーケンスを表すために使用されます。多くの Node.js API はBufferをサポートしています。
Bufferクラスは JavaScript のUint8Arrayクラスのサブクラスであり、追加のユースケースを網羅するメソッドで拡張されています。Node.js API は、Bufferがサポートされている場所であれば、プレーンなUint8Arrayも受け入れます。
Bufferクラスはグローバルスコープ内で使用できますが、インポートまたは require ステートメントを介して明示的に参照することをお勧めします。
import { Buffer } from 'node:buffer'
// 長さ10のゼロで埋められたBufferを作成します。
const buf1 = Buffer.alloc(10)
// 長さ10のBufferを作成し、
// すべての値が`1`であるバイトで埋めます。
const buf2 = Buffer.alloc(10, 1)
// 長さ10の初期化されていないバッファを作成します。
// これはBuffer.alloc()を呼び出すよりも高速ですが、返された
// Bufferインスタンスには古いデータが含まれている可能性があり、
// fill()、write()、またはBufferの内容を埋めるその他の関数を使用して上書きする必要があります。
const buf3 = Buffer.allocUnsafe(10)
// バイト[1, 2, 3]を含むBufferを作成します。
const buf4 = Buffer.from([1, 2, 3])
// バイト[1, 1, 1, 1]を含むBufferを作成します - エントリはすべて
// `(value & 255)`を使用して切り捨てられ、0～255の範囲に収まります。
const buf5 = Buffer.from([257, 257.5, -255, '1'])
// 文字列'tést'のUTF-8エンコードされたバイトを含むBufferを作成します。
// [0x74, 0xc3, 0xa9, 0x73, 0x74]（16進表記）
// [116, 195, 169, 115, 116]（10進表記）
const buf6 = Buffer.from('tést')
// Latin-1バイト[0x74, 0xe9, 0x73, 0x74]を含むBufferを作成します。
const buf7 = Buffer.from('tést', 'latin1')const { Buffer } = require('node:buffer')
// 長さ10のゼロで埋められたBufferを作成します。
const buf1 = Buffer.alloc(10)
// 長さ10のBufferを作成し、
// すべての値が`1`であるバイトで埋めます。
const buf2 = Buffer.alloc(10, 1)
// 長さ10の初期化されていないバッファを作成します。
// これはBuffer.alloc()を呼び出すよりも高速ですが、返された
// Bufferインスタンスには古いデータが含まれている可能性があり、
// fill()、write()、またはBufferの内容を埋めるその他の関数を使用して上書きする必要があります。
const buf3 = Buffer.allocUnsafe(10)
// バイト[1, 2, 3]を含むBufferを作成します。
const buf4 = Buffer.from([1, 2, 3])
// バイト[1, 1, 1, 1]を含むBufferを作成します - エントリはすべて
// `(value & 255)`を使用して切り捨てられ、0～255の範囲に収まります。
const buf5 = Buffer.from([257, 257.5, -255, '1'])
// 文字列'tést'のUTF-8エンコードされたバイトを含むBufferを作成します。
// [0x74, 0xc3, 0xa9, 0x73, 0x74]（16進表記）
// [116, 195, 169, 115, 116]（10進表記）
const buf6 = Buffer.from('tést')
// Latin-1バイト[0x74, 0xe9, 0x73, 0x74]を含むBufferを作成します。
const buf7 = Buffer.from('tést', 'latin1')バッファと文字エンコーディング
[履歴]
| バージョン | 変更点 |
|---|---|
| v15.7.0, v14.18.0 | base64url エンコーディングを追加 |
| v6.4.0 | latin1 を binary のエイリアスとして追加 |
| v5.0.0 | 非推奨の raw および raws エンコーディングを削除 |
Buffer と文字列間の変換では、文字エンコーディングを指定できます。文字エンコーディングを指定しない場合、UTF-8 がデフォルトで使用されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('hello world', 'utf8')
console.log(buf.toString('hex'))
// 出力: 68656c6c6f20776f726c64
console.log(buf.toString('base64'))
// 出力: aGVsbG8gd29ybGQ=
console.log(Buffer.from('fhqwhgads', 'utf8'))
// 出力: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'))
// 出力: <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>const { Buffer } = require('node:buffer')
const buf = Buffer.from('hello world', 'utf8')
console.log(buf.toString('hex'))
// 出力: 68656c6c6f20776f726c64
console.log(buf.toString('base64'))
// 出力: aGVsbG8gd29ybGQ=
console.log(Buffer.from('fhqwhgads', 'utf8'))
// 出力: <Buffer 66 68 71 77 68 67 61 64 73>
console.log(Buffer.from('fhqwhgads', 'utf16le'))
// 出力: <Buffer 66 00 68 00 71 00 77 00 68 00 67 00 61 00 64 00 73 00>Node.js のバッファは、受け取るエンコーディング文字列の大文字と小文字のあらゆるバリエーションを受け入れます。たとえば、UTF-8 は 'utf8'、'UTF8'、または 'uTf8' として指定できます。
Node.js で現在サポートされている文字エンコーディングは次のとおりです。
'utf8'(エイリアス:'utf-8'): マルチバイトエンコード Unicode 文字。多くのウェブページやその他のドキュメント形式は UTF-8 を使用しています。これはデフォルトの文字エンコーディングです。有効な UTF-8 データだけを含まないBufferを文字列にデコードする場合、Unicode 置換文字U+FFFD� がそれらのエラーを表すために使用されます。'utf16le'(エイリアス:'utf-16le'): マルチバイトエンコード Unicode 文字。'utf8'とは異なり、文字列内の各文字は 2 バイトまたは 4 バイトを使用してエンコードされます。Node.js は UTF-16 の リトルエンディアン バリアントのみをサポートしています。'latin1': Latin-1 は ISO-8859-1 を意味します。この文字エンコーディングは、U+0000からU+00FFまでの Unicode 文字のみをサポートしています。各文字は 1 バイトを使用してエンコードされます。その範囲に収まらない文字は切り捨てられ、その範囲内の文字にマッピングされます。
上記のいずれかを使用して Buffer を文字列に変換することをデコードといい、文字列を Buffer に変換することをエンコードといいます。
Node.js は次のバイナリからテキストへのエンコーディングもサポートしています。バイナリからテキストへのエンコーディングでは、命名規則が逆になります。Buffer を文字列に変換することを通常エンコードといい、文字列を Buffer に変換することをデコードといいます。
'base64': Base64 エンコーディング。文字列からBufferを作成する場合、このエンコーディングは RFC 4648、セクション 5 で指定されている「URL およびファイル名セーフアルファベット」も正しく受け入れます。base64 エンコードされた文字列に含まれるスペース、タブ、改行などの空白文字は無視されます。'base64url': RFC 4648、セクション 5 で指定されている base64url エンコーディング。文字列からBufferを作成する場合、このエンコーディングは通常の base64 エンコードされた文字列も正しく受け入れます。Bufferを文字列にエンコードする場合、このエンコーディングはパディングを省略します。'hex': 各バイトを 2 つの 16 進数文字としてエンコードします。偶数個の 16 進数文字だけで構成されていない文字列をデコードすると、データの切り捨てが発生する可能性があります。例については以下を参照してください。
次のレガシー文字エンコーディングもサポートされています。
'ascii': 7 ビット ASCII データのみ。文字列をBufferにエンコードする場合、これは'latin1'を使用することと同等です。Bufferを文字列にデコードする場合、このエンコーディングを使用すると、デコードする前に各バイトの最上位ビットが追加でリセットされます。一般的に、'utf8'（または、データが常に ASCII のみであることがわかっている場合は'latin1'）は ASCII のみテキストをエンコードまたはデコードする場合に最適な選択肢となるため、このエンコーディングを使用する理由はほとんどありません。これはレガシー互換性のためにのみ提供されています。'binary':'latin1'のエイリアス。このエンコーディングの名前は非常に誤解を招く可能性があります。ここにリストされているすべてのエンコーディングは、文字列とバイナリデータ間の変換を行います。文字列とBuffer間の変換では、通常'utf8'が適切な選択肢です。'ucs2'、'ucs-2':'utf16le'のエイリアス。UCS-2 は、コードポイントが U+FFFF より大きい文字をサポートしない UTF-16 のバリアントを指していました。Node.js では、これらのコードポイントは常にサポートされています。
import { Buffer } from 'node:buffer'
Buffer.from('1ag123', 'hex')
// 出力 <Buffer 1a>、最初の16進数以外の値('g')でデータが切り捨てられます。
Buffer.from('1a7', 'hex')
// 出力 <Buffer 1a>、データが1桁('7')で終わるとデータが切り捨てられます。
Buffer.from('1634', 'hex')
// 出力 <Buffer 16 34>、すべてのデータが表現されます。const { Buffer } = require('node:buffer')
Buffer.from('1ag123', 'hex')
// 出力 <Buffer 1a>、最初の16進数以外の値('g')でデータが切り捨てられます。
Buffer.from('1a7', 'hex')
// 出力 <Buffer 1a>、データが1桁('7')で終わるとデータが切り捨てられます。
Buffer.from('1634', 'hex')
// 出力 <Buffer 16 34>、すべてのデータが表現されます。最新の Web ブラウザは、'latin1' と 'ISO-8859-1' の両方を 'win-1252' にエイリアス化する WHATWG Encoding Standard に従っています。つまり、http.get() のようなことを行う場合、返された文字セットが WHATWG 仕様にリストされているものの 1 つである場合、サーバーが実際に 'win-1252' エンコードされたデータを返し、'latin1' エンコーディングを使用すると文字が正しくデコードされない可能性があります。
バッファと TypedArray
[履歴]
| バージョン | 変更点 |
|---|---|
| v3.0.0 | Bufferクラスは、Uint8Arrayを継承するようになりました。 |
Bufferインスタンスは、JavaScript のUint8ArrayとTypedArrayインスタンスでもあります。すべてのTypedArrayメソッドはBufferで使用できます。ただし、Buffer API とTypedArray API の間には、微妙な非互換性があります。
特に：
TypedArray.prototype.slice()はTypedArrayの一部のコピーを作成しますが、Buffer.prototype.slice()は既存のBufferに対するビューを作成し、コピーしません。この動作は驚くべきものであり、レガシーとの互換性のためにのみ存在します。TypedArray.prototype.subarray()を使用して、Bufferおよび他のTypedArrayの両方でBuffer.prototype.slice()の動作を実現でき、推奨されます。buf.toString()は、そのTypedArrayの同等物と互換性がありません。buf.indexOf()など、多くのメソッドは追加の引数をサポートします。
Bufferから新しいTypedArrayインスタンスを作成するには、2 つの方法があります。
TypedArrayコンストラクタにBufferを渡すと、Bufferの内容が整数配列として解釈され、ターゲットタイプのバイトシーケンスとして解釈されずにコピーされます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4])
const uint32array = new Uint32Array(buf)
console.log(uint32array)
// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3, 4])
const uint32array = new Uint32Array(buf)
console.log(uint32array)
// Prints: Uint32Array(4) [ 1, 2, 3, 4 ]Bufferの基礎となるArrayBufferを渡すと、Bufferとメモリを共有するTypedArrayが作成されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('hello', 'utf16le')
const uint16array = new Uint16Array(buf.buffer, buf.byteOffset, buf.length / Uint16Array.BYTES_PER_ELEMENT)
console.log(uint16array)
// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]const { Buffer } = require('node:buffer')
const buf = Buffer.from('hello', 'utf16le')
const uint16array = new Uint16Array(buf.buffer, buf.byteOffset, buf.length / Uint16Array.BYTES_PER_ELEMENT)
console.log(uint16array)
// Prints: Uint16Array(5) [ 104, 101, 108, 108, 111 ]TypedArrayオブジェクトの.bufferプロパティを同じように使用することで、TypedArrayインスタンスと同じメモリが割り当てられた新しいBufferを作成できます。Buffer.from()はこのコンテキストではnew Uint8Array()のように動作します。
import { Buffer } from 'node:buffer'
const arr = new Uint16Array(2)
arr[0] = 5000
arr[1] = 4000
// `arr`の内容をコピーします。
const buf1 = Buffer.from(arr)
// `arr`とメモリを共有します。
const buf2 = Buffer.from(arr.buffer)
console.log(buf1)
// Prints: <Buffer 88 a0>
console.log(buf2)
// Prints: <Buffer 88 13 a0 0f>
arr[1] = 6000
console.log(buf1)
// Prints: <Buffer 88 a0>
console.log(buf2)
// Prints: <Buffer 88 13 70 17>const { Buffer } = require('node:buffer')
const arr = new Uint16Array(2)
arr[0] = 5000
arr[1] = 4000
// `arr`の内容をコピーします。
const buf1 = Buffer.from(arr)
// `arr`とメモリを共有します。
const buf2 = Buffer.from(arr.buffer)
console.log(buf1)
// Prints: <Buffer 88 a0>
console.log(buf2)
// Prints: <Buffer 88 13 a0 0f>
arr[1] = 6000
console.log(buf1)
// Prints: <Buffer 88 a0>
console.log(buf2)
// Prints: <Buffer 88 13 70 17>TypedArrayの.bufferを使用してBufferを作成する際、byteOffsetとlengthパラメータを渡すことで、基礎となるArrayBufferの一部のみを使用できます。
import { Buffer } from 'node:buffer'
const arr = new Uint16Array(20)
const buf = Buffer.from(arr.buffer, 0, 16)
console.log(buf.length)
// Prints: 16const { Buffer } = require('node:buffer')
const arr = new Uint16Array(20)
const buf = Buffer.from(arr.buffer, 0, 16)
console.log(buf.length)
// Prints: 16Buffer.from()とTypedArray.from()は、シグネチャと実装が異なります。具体的には、TypedArrayの変種は、型付き配列の各要素に対して呼び出されるマッピング関数を 2 番目の引数として受け付けます。
TypedArray.from(source[, mapFn[, thisArg]])
ただし、Buffer.from()メソッドはマッピング関数の使用をサポートしていません。
Buffer.from(array)Buffer.from(buffer)Buffer.from(arrayBuffer[, byteOffset[, length]])Buffer.from(string[, encoding])
バッファとイテレーション
Bufferインスタンスはfor..of構文を使用してイテレートできます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3])
for (const b of buf) {
console.log(b)
}
// Prints:
// 1
// 2
// 3const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3])
for (const b of buf) {
console.log(b)
}
// Prints:
// 1
// 2
// 3さらに、buf.values()、buf.keys()、およびbuf.entries()メソッドを使用してイテレータを作成できます。
クラス: Blob
[履歴]
| バージョン | 変更 |
|---|---|
| v18.0.0, v16.17.0 | 実験的な段階ではなくなりました。 |
| v15.7.0, v14.18.0 | 追加: v15.7.0, v14.18.0 |
Blob は、複数のワーカースレッド間で安全に共有できる、不変の生データをカプセル化します。
new buffer.Blob([sources[, options]])
[履歴]
| バージョン | 変更 |
|---|---|
| v16.7.0 | 行末を置き換える標準のendingsオプションを追加し、非標準のencodingオプションを削除しました。 |
| v15.7.0, v14.18.0 | 追加: v15.7.0, v14.18.0 |
sources<string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]>Blob内に格納される文字列、<ArrayBuffer>、<TypedArray>、<DataView>、または<Blob>オブジェクト、あるいはこれらのオブジェクトの任意の組み合わせの配列。options<Object>
指定されたソースの連結を含む新しいBlobオブジェクトを作成します。
<ArrayBuffer>、<TypedArray>、<DataView>、および<Buffer>ソースは'Blob'にコピーされ、そのため'Blob'の作成後も安全に変更できます。
文字列ソースは UTF-8 バイトシーケンスとしてエンコードされ、Blob にコピーされます。各文字列部分内の不一致のサロゲートペアは、Unicode U+FFFD 置換文字に置き換えられます。
blob.arrayBuffer()
追加：v15.7.0, v14.18.0
- 戻り値: <Promise>
Blobデータのコピーを含む <ArrayBuffer>を満たす Promise を返します。
blob.bytes()
追加：v22.3.0, v20.16.0
blob.bytes()メソッドは、BlobオブジェクトのバイトをPromise\<Uint8Array\>として返します。
const blob = new Blob(['hello'])
blob.bytes().then(bytes => {
console.log(bytes) // 出力: Uint8Array(5) [ 104, 101, 108, 108, 111 ]
})blob.size
追加：v15.7.0, v14.18.0
バイト単位でのBlobの総サイズ。
blob.slice([start[, end[, type]]])
追加：v15.7.0, v14.18.0
このBlobオブジェクトデータのサブセットを含む新しいBlobを作成して返します。元のBlobは変更されません。
blob.stream()
追加：v16.7.0
- 戻り値: <ReadableStream>
Blobのコンテンツを読み取ることができる新しいReadableStreamを返します。
blob.text()
追加：v15.7.0, v14.18.0
- 戻り値: <Promise>
UTF-8 文字列としてデコードされたBlobの内容を満たす Promise を返します。
blob.type
追加：v15.7.0, v14.18.0
- 型: <string>
Blobのコンテンツタイプ。
Blob オブジェクトとMessageChannel
<Blob>オブジェクトが作成されると、データの転送や即時コピーを行うことなく、MessagePort を介して複数の宛先に送信できます。Blobに含まれるデータは、arrayBuffer()またはtext()メソッドが呼び出された場合にのみコピーされます。
import { Blob } from 'node:buffer'
import { setTimeout as delay } from 'node:timers/promises'
const blob = new Blob(['hello there'])
const mc1 = new MessageChannel()
const mc2 = new MessageChannel()
mc1.port1.onmessage = async ({ data }) => {
console.log(await data.arrayBuffer())
mc1.port1.close()
}
mc2.port1.onmessage = async ({ data }) => {
await delay(1000)
console.log(await data.arrayBuffer())
mc2.port1.close()
}
mc1.port2.postMessage(blob)
mc2.port2.postMessage(blob)
// The Blob is still usable after posting.
blob.text().then(console.log)const { Blob } = require('node:buffer')
const { setTimeout: delay } = require('node:timers/promises')
const blob = new Blob(['hello there'])
const mc1 = new MessageChannel()
const mc2 = new MessageChannel()
mc1.port1.onmessage = async ({ data }) => {
console.log(await data.arrayBuffer())
mc1.port1.close()
}
mc2.port1.onmessage = async ({ data }) => {
await delay(1000)
console.log(await data.arrayBuffer())
mc2.port1.close()
}
mc1.port2.postMessage(blob)
mc2.port2.postMessage(blob)
// The Blob is still usable after posting.
blob.text().then(console.log)クラス: Buffer
Bufferクラスは、バイナリデータを直接扱うためのグローバル型です。様々な方法で構築できます。
静的メソッド: Buffer.alloc(size[, fill[, encoding]])
[履歴]
| バージョン | 変更 |
|---|---|
| v20.0.0 | 無効な入力引数に対して、ERR_INVALID_ARG_VALUE ではなく ERR_INVALID_ARG_TYPE または ERR_OUT_OF_RANGE をスローします。 |
| v15.0.0 | 無効な入力引数に対して、ERR_INVALID_OPT_VALUE ではなく ERR_INVALID_ARG_VALUE をスローします。 |
| v10.0.0 | ゼロ長のバッファでゼロ以外の長さのバッファを埋める試みは、例外をスローします。 |
| v10.0.0 | fillに無効な文字列を指定すると、例外がスローされます。 |
| v8.9.3 | fillに無効な文字列を指定すると、ゼロで埋められたバッファになります。 |
| v5.10.0 | 追加: v5.10.0 |
size<整数> 新しいBufferの必要な長さ。fill<文字列> | <Buffer> | <Uint8Array> | <整数> 新しいBufferを事前に埋める値。デフォルト:0。encoding<文字列>fillが文字列の場合、そのエンコーディング。デフォルト:'utf8'。- 戻り値: <Buffer>
sizeバイトの新しいBufferを割り当てます。fillがundefinedの場合、Bufferはゼロで埋められます。
import { Buffer } from 'node:buffer'
const buf = Buffer.alloc(5)
console.log(buf)
// Prints: <Buffer 00 00 00 00 00>const { Buffer } = require('node:buffer')
const buf = Buffer.alloc(5)
console.log(buf)
// Prints: <Buffer 00 00 00 00 00>sizeがbuffer.constants.MAX_LENGTHより大きく、または 0 より小さい場合、ERR_OUT_OF_RANGEがスローされます。
fillが指定されている場合、割り当てられたBufferはbuf.fill(fill)を呼び出すことで初期化されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.alloc(5, 'a')
console.log(buf)
// Prints: <Buffer 61 61 61 61 61>const { Buffer } = require('node:buffer')
const buf = Buffer.alloc(5, 'a')
console.log(buf)
// Prints: <Buffer 61 61 61 61 61>fillとencodingの両方が指定されている場合、割り当てられたBufferはbuf.fill(fill, encoding)を呼び出すことで初期化されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64')
console.log(buf)
// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>const { Buffer } = require('node:buffer')
const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64')
console.log(buf)
// Prints: <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>Buffer.alloc()を呼び出すことは、代替のBuffer.allocUnsafe()よりも測定可能なほど遅くなる可能性がありますが、新しく作成されたBufferインスタンスの内容に、以前の割り当てからの機密データ（Buffer用に割り当てられていなかった可能性のあるデータを含む）が含まれることが決してないことを保証します。
sizeが数値でない場合、TypeErrorがスローされます。
静的メソッド: Buffer.allocUnsafe(size)
[履歴]
| バージョン | 変更 |
|---|---|
| v20.0.0 | 無効な入力引数に対して、ERR_INVALID_ARG_VALUE の代わりに ERR_INVALID_ARG_TYPE または ERR_OUT_OF_RANGE をスローします。 |
| v15.0.0 | 無効な入力引数に対して、ERR_INVALID_OPT_VALUE の代わりに ERR_INVALID_ARG_VALUE をスローします。 |
| v7.0.0 | 負のsizeを渡すと、エラーがスローされるようになりました。 |
| v5.10.0 | 追加: v5.10.0 |
sizeバイトの新しいBufferを割り当てます。sizeがbuffer.constants.MAX_LENGTHより大きく、または 0 より小さい場合、ERR_OUT_OF_RANGEがスローされます。
このようにして作成されたBufferインスタンスの基になるメモリは初期化されません。新しく作成されたBufferの内容は不明であり、機密データが含まれている可能性があります。ゼロでBufferインスタンスを初期化するには、Buffer.alloc()を使用してください。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(10)
console.log(buf)
// 出力（内容は異なる場合があります）: <Buffer a0 8b 28 3f 01 00 00 00 50 32>
buf.fill(0)
console.log(buf)
// 出力: <Buffer 00 00 00 00 00 00 00 00 00 00>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(10)
console.log(buf)
// 出力（内容は異なる場合があります）: <Buffer a0 8b 28 3f 01 00 00 00 50 32>
buf.fill(0)
console.log(buf)
// 出力: <Buffer 00 00 00 00 00 00 00 00 00 00>sizeが数値でない場合、TypeErrorがスローされます。
Bufferモジュールは、Buffer.allocUnsafe()、Buffer.from(array)、Buffer.from(string)、およびBuffer.concat()を使用して作成された新しいBufferインスタンスの高速な割り当てに使用されるプールとして、Buffer.poolSizeサイズの内部Bufferインスタンスを事前に割り当てます。ただし、これはsizeがBuffer.poolSize \>\>\> 1（Buffer.poolSizeを 2 で割った値の床）未満の場合のみです。
この事前に割り当てられた内部メモリプールの使用は、Buffer.alloc(size, fill)を呼び出すこととBuffer.allocUnsafe(size).fill(fill)を呼び出すこととの重要な違いです。具体的には、Buffer.alloc(size, fill)は内部Bufferプールを決して使用しませんが、Buffer.allocUnsafe(size).fill(fill)はsizeがBuffer.poolSizeの半分以下の場合、内部Bufferプールを使用します。この違いは微妙ですが、アプリケーションがBuffer.allocUnsafe()が提供する追加のパフォーマンスを必要とする場合に重要になる可能性があります。
静的メソッド: Buffer.allocUnsafeSlow(size)
[履歴]
| バージョン | 変更 |
|---|---|
| v20.0.0 | 無効な入力引数に対して、ERR_INVALID_ARG_VALUE ではなく ERR_INVALID_ARG_TYPE または ERR_OUT_OF_RANGE をスローするように変更。 |
| v15.0.0 | 無効な入力引数に対して、ERR_INVALID_OPT_VALUE ではなく ERR_INVALID_ARG_VALUE をスローするように変更。 |
| v5.12.0 | 追加: v5.12.0 |
sizeバイトの新しいBufferを割り当てます。sizeがbuffer.constants.MAX_LENGTHより大きい場合、または 0 より小さい場合、ERR_OUT_OF_RANGEがスローされます。sizeが 0 の場合は、長さ 0 のBufferが作成されます。
このようにして作成されたBufferインスタンスの基になるメモリは初期化されていません。新しく作成されたBufferの内容は不明であり、機密データが含まれている可能性があります。そのようなBufferインスタンスをゼロで初期化するには、buf.fill(0)を使用してください。
Buffer.allocUnsafe()を使用して新しいBufferインスタンスを割り当てる場合、Buffer.poolSize \>\>\> 1（デフォルトの poolSize を使用する場合、4KiB）未満の割り当ては、単一の事前割り当てされたBufferからスライスされます。これにより、アプリケーションは、多数の個別に割り当てられたBufferインスタンスを作成することによるガベージコレクションのオーバーヘッドを回避できます。このアプローチは、多くの個々のArrayBufferオブジェクトの追跡とクリーンアップを行う必要がなくなるため、パフォーマンスとメモリ使用量の両方を向上させます。
ただし、開発者がプールの小さなメモリチャンクを不確定な期間保持する必要がある場合、Buffer.allocUnsafeSlow()を使用してプールされていないBufferインスタンスを作成し、関連するビットをコピーアウトすることが適切な場合があります。
import { Buffer } from 'node:buffer'
// 少量のメモリチャンクを保持する必要がある。
const store = []
socket.on('readable', () => {
let data
while (null !== (data = readable.read())) {
// 保持するデータの割り当て。
const sb = Buffer.allocUnsafeSlow(10)
// 新しい割り当てにデータをコピーする。
data.copy(sb, 0, 0, 10)
store.push(sb)
}
})const { Buffer } = require('node:buffer')
// 少量のメモリチャンクを保持する必要がある。
const store = []
socket.on('readable', () => {
let data
while (null !== (data = readable.read())) {
// 保持するデータの割り当て。
const sb = Buffer.allocUnsafeSlow(10)
// 新しい割り当てにデータをコピーする。
data.copy(sb, 0, 0, 10)
store.push(sb)
}
})sizeが数値でない場合、TypeErrorがスローされます。
静的メソッド: Buffer.byteLength(string[, encoding])
[履歴]
| バージョン | 変更点 |
|---|---|
| v7.0.0 | 無効な入力を渡すとエラーがスローされるようになりました。 |
| v5.10.0 | string パラメータに、任意の TypedArray、DataView、ArrayBuffer を渡せるようになりました。 |
| v0.1.90 | 追加: v0.1.90 |
string<string> | <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <SharedArrayBuffer> 長さを計算する値。encoding<string>stringが文字列の場合、そのエンコーディングを指定します。 デフォルト:'utf8'。- 戻り値: <integer>
stringに含まれるバイト数。
encoding を使用してエンコードされた文字列のバイト長を返します。これは、使用されるエンコーディングを考慮しない String.prototype.length とは異なります。
'base64'、'base64url'、'hex' の場合、この関数は有効な入力を想定しています。base64/hex エンコードされていないデータ（例：空白）を含む文字列の場合、戻り値は、文字列から作成された Buffer の長さよりも大きくなる可能性があります。
import { Buffer } from 'node:buffer'
const str = '\u00bd + \u00bc = \u00be'
console.log(`${str}: ${str.length} characters, ` + `${Buffer.byteLength(str, 'utf8')} bytes`)
// 出力: ½ + ¼ = ¾: 9 characters, 12 bytesconst { Buffer } = require('node:buffer')
const str = '\u00bd + \u00bc = \u00be'
console.log(`${str}: ${str.length} characters, ` + `${Buffer.byteLength(str, 'utf8')} bytes`)
// 出力: ½ + ¼ = ¾: 9 characters, 12 bytesstring が Buffer/DataView/TypedArray/ArrayBuffer/SharedArrayBuffer の場合、.byteLength が報告するバイト長が返されます。
静的メソッド: Buffer.compare(buf1, buf2)
[履歴]
| バージョン | 変更点 |
|---|---|
| v8.0.0 | 引数にUint8Array を使用できるようになりました。 |
| v0.11.13 | 追加: v0.11.13 |
buf1<Buffer> | <Uint8Array>buf2<Buffer> | <Uint8Array>- 戻り値: <整数> 比較の結果に応じて
-1、0、または1のいずれかを返します。詳細はbuf.compare()を参照してください。
buf1とbuf2を比較します。通常は、Bufferインスタンスの配列をソートするために使用されます。これはbuf1.compare(buf2)を呼び出すことと同等です。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from('1234')
const buf2 = Buffer.from('0123')
const arr = [buf1, buf2]
console.log(arr.sort(Buffer.compare))
// 出力: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (この結果は [buf2, buf1] と同じです。)const { Buffer } = require('node:buffer')
const buf1 = Buffer.from('1234')
const buf2 = Buffer.from('0123')
const arr = [buf1, buf2]
console.log(arr.sort(Buffer.compare))
// 出力: [ <Buffer 30 31 32 33>, <Buffer 31 32 33 34> ]
// (この結果は [buf2, buf1] と同じです。)静的メソッド: Buffer.concat(list[, totalLength])
[履歴]
| バージョン | 変更点 |
|---|---|
| v8.0.0 | listの要素にUint8Array を使用できるようになりました。 |
| v0.7.11 | 追加: v0.7.11 |
list<Buffer[]> | <Uint8Array[]> 結合するBufferまたはUint8Arrayインスタンスのリスト。totalLength<整数> 結合したlist内のBufferインスタンスの合計長。- 戻り値: <Buffer>
list内のすべてのBufferインスタンスを連結した結果である新しいBufferを返します。
リストにアイテムがない場合、またはtotalLengthが 0 の場合、ゼロ長の新しいBufferが返されます。
totalLengthが指定されていない場合、list内のBufferインスタンスの長さを加算して計算されます。
totalLengthが指定されている場合、符号なし整数に変換されます。list内のBufferの合計長がtotalLengthを超える場合、結果はtotalLengthに切り捨てられます。list内のBufferの合計長がtotalLengthより短い場合、残りのスペースはゼロで埋められます。
import { Buffer } from 'node:buffer'
// 3つの`Buffer`インスタンスのリストから単一の`Buffer`を作成します。
const buf1 = Buffer.alloc(10)
const buf2 = Buffer.alloc(14)
const buf3 = Buffer.alloc(18)
const totalLength = buf1.length + buf2.length + buf3.length
console.log(totalLength)
// 出力: 42
const bufA = Buffer.concat([buf1, buf2, buf3], totalLength)
console.log(bufA)
// 出力: <Buffer 00 00 00 00 ...>
console.log(bufA.length)
// 出力: 42const { Buffer } = require('node:buffer')
// 3つの`Buffer`インスタンスのリストから単一の`Buffer`を作成します。
const buf1 = Buffer.alloc(10)
const buf2 = Buffer.alloc(14)
const buf3 = Buffer.alloc(18)
const totalLength = buf1.length + buf2.length + buf3.length
console.log(totalLength)
// 出力: 42
const bufA = Buffer.concat([buf1, buf2, buf3], totalLength)
console.log(bufA)
// 出力: <Buffer 00 00 00 00 ...>
console.log(bufA.length)
// 出力: 42Buffer.concat()は、Buffer.allocUnsafe()と同様に、内部のBufferプールを使用する場合もあります。
静的メソッド: Buffer.copyBytesFrom(view[, offset[, length]])
追加バージョン: v19.8.0, v18.16.0
view<TypedArray> コピーする <TypedArray>。offset<整数>view内の開始オフセット。デフォルト:0。length<整数>viewからコピーする要素数。デフォルト:view.length - offset。- 戻り値: <Buffer>
view の基礎となるメモリを新しい Buffer にコピーします。
const u16 = new Uint16Array([0, 0xffff])
const buf = Buffer.copyBytesFrom(u16, 1, 1)
u16[1] = 0
console.log(buf.length) // 2
console.log(buf[0]) // 255
console.log(buf[1]) // 255静的メソッド: Buffer.from(array)
追加バージョン: v5.10.0
0～255の範囲内のバイトのarrayを使用して、新しいBufferを割り当てます。その範囲外の配列エントリは、それに収まるように切り捨てられます。
import { Buffer } from 'node:buffer'
// 文字列 'buffer' の UTF-8 バイトを含む新しい Buffer を作成します。
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])const { Buffer } = require('node:buffer')
// 文字列 'buffer' の UTF-8 バイトを含む新しい Buffer を作成します。
const buf = Buffer.from([0x62, 0x75, 0x66, 0x66, 0x65, 0x72])array がArrayのようなオブジェクト（つまり、number型のlengthプロパティを持つオブジェクト）である場合、それがBufferまたはUint8Arrayでない限り、配列として扱われます。これは、他のすべてのTypedArrayのバリアントがArrayとして扱われることを意味します。TypedArrayを裏付けるバイトからBufferを作成するには、Buffer.copyBytesFrom()を使用します。
arrayがArrayまたはBuffer.from()のバリアントに適した他の型でない場合、TypeErrorがスローされます。
Buffer.from(array)とBuffer.from(string)は、Buffer.allocUnsafe()のように、内部Bufferプールを使用する場合もあります。
静的メソッド: Buffer.from(arrayBuffer[, byteOffset[, length]])
v5.10.0 で追加
arrayBuffer<ArrayBuffer> | <SharedArrayBuffer>ArrayBuffer、SharedArrayBuffer例えばTypedArrayの.bufferプロパティ。byteOffset<integer> 公開する最初のバイトのインデックス。デフォルト:0。length<integer> 公開するバイト数。デフォルト:arrayBuffer.byteLength - byteOffset。- 戻り値: <Buffer>
これは、基になるメモリをコピーせずに ArrayBuffer のビューを作成します。例えば、TypedArray インスタンスの .buffer プロパティへの参照が渡された場合、新しく作成された Buffer は、TypedArray の基になる ArrayBuffer と同じ割り当てられたメモリを共有します。
import { Buffer } from 'node:buffer'
const arr = new Uint16Array(2)
arr[0] = 5000
arr[1] = 4000
// `arr` とメモリを共有します。
const buf = Buffer.from(arr.buffer)
console.log(buf)
// Prints: <Buffer 88 13 a0 0f>
// 元の Uint16Array を変更すると、Buffer も変更されます。
arr[1] = 6000
console.log(buf)
// Prints: <Buffer 88 13 70 17>const { Buffer } = require('node:buffer')
const arr = new Uint16Array(2)
arr[0] = 5000
arr[1] = 4000
// `arr` とメモリを共有します。
const buf = Buffer.from(arr.buffer)
console.log(buf)
// Prints: <Buffer 88 13 a0 0f>
// 元の Uint16Array を変更すると、Buffer も変更されます。
arr[1] = 6000
console.log(buf)
// Prints: <Buffer 88 13 70 17>オプションの byteOffset 引数と length 引数は、Buffer で共有される arrayBuffer 内のメモリ範囲を指定します。
import { Buffer } from 'node:buffer'
const ab = new ArrayBuffer(10)
const buf = Buffer.from(ab, 0, 2)
console.log(buf.length)
// Prints: 2const { Buffer } = require('node:buffer')
const ab = new ArrayBuffer(10)
const buf = Buffer.from(ab, 0, 2)
console.log(buf.length)
// Prints: 2arrayBuffer が ArrayBuffer または SharedArrayBuffer または Buffer.from() バリアントに適した別の型でない場合、TypeError がスローされます。
基になる ArrayBuffer は、TypedArray ビューの境界を超えるメモリ範囲をカバーできることを覚えておくことが重要です。TypedArray の buffer プロパティを使用して作成された新しい Buffer は、TypedArray の範囲を超える可能性があります。
import { Buffer } from 'node:buffer'
const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]) // 4 elements
const arrB = new Uint8Array(arrA.buffer, 1, 2) // 2 elements
console.log(arrA.buffer === arrB.buffer) // true
const buf = Buffer.from(arrB.buffer)
console.log(buf)
// Prints: <Buffer 63 64 65 66>const { Buffer } = require('node:buffer')
const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]) // 4 elements
const arrB = new Uint8Array(arrA.buffer, 1, 2) // 2 elements
console.log(arrA.buffer === arrB.buffer) // true
const buf = Buffer.from(arrB.buffer)
console.log(buf)
// Prints: <Buffer 63 64 65 66>静的メソッド: Buffer.from(buffer)
追加: v5.10.0
buffer<Buffer> | <Uint8Array> 既存のBufferまたはデータをコピーする元のUint8Array。- 戻り値: <Buffer>
渡された buffer のデータを新しい Buffer インスタンスにコピーします。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from('buffer')
const buf2 = Buffer.from(buf1)
buf1[0] = 0x61
console.log(buf1.toString())
// Prints: auffer
console.log(buf2.toString())
// Prints: bufferconst { Buffer } = require('node:buffer')
const buf1 = Buffer.from('buffer')
const buf2 = Buffer.from(buf1)
buf1[0] = 0x61
console.log(buf1.toString())
// Prints: auffer
console.log(buf2.toString())
// Prints: bufferbuffer が Buffer でない場合、または Buffer.from() バリアントに適した別の型でない場合は TypeError がスローされます。
静的メソッド: Buffer.from(object[, offsetOrEncoding[, length]])
追加: v8.2.0
object<Object>Symbol.toPrimitiveまたはvalueOf()をサポートするオブジェクト。offsetOrEncoding<integer> | <string> バイトオフセットまたはエンコーディング。length<integer> 長さ。- 戻り値: <Buffer>
valueOf() 関数が object と厳密に等しくない値を返すオブジェクトに対しては、Buffer.from(object.valueOf(), offsetOrEncoding, length) を返します。
import { Buffer } from 'node:buffer'
const buf = Buffer.from(new String('this is a test'))
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>const { Buffer } = require('node:buffer')
const buf = Buffer.from(new String('this is a test'))
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>Symbol.toPrimitive をサポートするオブジェクトに対しては、Buffer.from(object[Symbol.toPrimitive]('string'), offsetOrEncoding) を返します。
import { Buffer } from 'node:buffer'
class Foo {
[Symbol.toPrimitive]() {
return 'this is a test'
}
}
const buf = Buffer.from(new Foo(), 'utf8')
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>const { Buffer } = require('node:buffer')
class Foo {
[Symbol.toPrimitive]() {
return 'this is a test'
}
}
const buf = Buffer.from(new Foo(), 'utf8')
// Prints: <Buffer 74 68 69 73 20 69 73 20 61 20 74 65 73 74>object が言及されたメソッドを持たない場合、または Buffer.from() バリアントに適した別の型でない場合は TypeError がスローされます。
静的メソッド: Buffer.from(string[, encoding])
追加: v5.10.0
string を含む新しい Buffer を作成します。encoding パラメーターは、string をバイトに変換するときに使用する文字エンコーディングを識別します。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from('this is a tést')
const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex')
console.log(buf1.toString())
// Prints: this is a tést
console.log(buf2.toString())
// Prints: this is a tést
console.log(buf1.toString('latin1'))
// Prints: this is a téstconst { Buffer } = require('node:buffer')
const buf1 = Buffer.from('this is a tést')
const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex')
console.log(buf1.toString())
// Prints: this is a tést
console.log(buf2.toString())
// Prints: this is a tést
console.log(buf1.toString('latin1'))
// Prints: this is a téststring が文字列でない場合、または Buffer.from() バリアントに適した別の型でない場合は、TypeError がスローされます。
Buffer.from(string) は、Buffer.allocUnsafe() と同様に、内部の Buffer プールを使用する場合があります。
静的メソッド: Buffer.isBuffer(obj)
追加: v0.1.101
obj が Buffer の場合は true、それ以外の場合は false を返します。
import { Buffer } from 'node:buffer'
Buffer.isBuffer(Buffer.alloc(10)) // true
Buffer.isBuffer(Buffer.from('foo')) // true
Buffer.isBuffer('a string') // false
Buffer.isBuffer([]) // false
Buffer.isBuffer(new Uint8Array(1024)) // falseconst { Buffer } = require('node:buffer')
Buffer.isBuffer(Buffer.alloc(10)) // true
Buffer.isBuffer(Buffer.from('foo')) // true
Buffer.isBuffer('a string') // false
Buffer.isBuffer([]) // false
Buffer.isBuffer(new Uint8Array(1024)) // false静的メソッド: Buffer.isEncoding(encoding)
追加: v0.9.1
encoding がサポートされている文字エンコーディングの名前の場合は true を、それ以外の場合は false を返します。
import { Buffer } from 'node:buffer'
console.log(Buffer.isEncoding('utf8'))
// Prints: true
console.log(Buffer.isEncoding('hex'))
// Prints: true
console.log(Buffer.isEncoding('utf/8'))
// Prints: false
console.log(Buffer.isEncoding(''))
// Prints: falseconst { Buffer } = require('node:buffer')
console.log(Buffer.isEncoding('utf8'))
// Prints: true
console.log(Buffer.isEncoding('hex'))
// Prints: true
console.log(Buffer.isEncoding('utf/8'))
// Prints: false
console.log(Buffer.isEncoding(''))
// Prints: falseクラスプロパティ: Buffer.poolSize
追加: v0.11.3
- <integer> デフォルト:
8192
これは、プーリングに使用される事前割り当て済みの内部 Buffer インスタンスのサイズ（バイト単位）です。この値は変更できます。
buf[index]
index<integer>
インデックス演算子 [index] を使用して、buf の index 位置にあるオクテットを取得および設定できます。値は個々のバイトを参照するため、有効な値の範囲は 0x00 から 0xFF (16 進数) または 0 から 255 (10 進数) の間です。
この演算子は Uint8Array から継承されているため、範囲外のアクセスに対する動作は Uint8Array と同じです。つまり、index が負の場合、または buf.length 以上の場合は、buf[index] は undefined を返し、index が負の場合、または \>= buf.length の場合は、buf[index] = value はバッファを変更しません。
import { Buffer } from 'node:buffer'
// ASCII 文字列を一度に 1 バイトずつ `Buffer` にコピーします。
// (これは ASCII のみの文字列でのみ機能します。一般的に、この変換を実行するには
// `Buffer.from()` を使用する必要があります。)
const str = 'Node.js'
const buf = Buffer.allocUnsafe(str.length)
for (let i = 0; i < str.length; i++) {
buf[i] = str.charCodeAt(i)
}
console.log(buf.toString('utf8'))
// Prints: Node.jsconst { Buffer } = require('node:buffer')
// ASCII 文字列を一度に 1 バイトずつ `Buffer` にコピーします。
// (これは ASCII のみの文字列でのみ機能します。一般的に、この変換を実行するには
// `Buffer.from()` を使用する必要があります。)
const str = 'Node.js'
const buf = Buffer.allocUnsafe(str.length)
for (let i = 0; i < str.length; i++) {
buf[i] = str.charCodeAt(i)
}
console.log(buf.toString('utf8'))
// Prints: Node.jsbuf.buffer
- <ArrayBuffer> この
Bufferオブジェクトが作成された基となるArrayBufferオブジェクト。
このArrayBufferは、元のBufferと正確に対応することが保証されていません。詳細については、buf.byteOffsetに関する注記を参照してください。
import { Buffer } from 'node:buffer'
const arrayBuffer = new ArrayBuffer(16)
const buffer = Buffer.from(arrayBuffer)
console.log(buffer.buffer === arrayBuffer)
// Prints: trueconst { Buffer } = require('node:buffer')
const arrayBuffer = new ArrayBuffer(16)
const buffer = Buffer.from(arrayBuffer)
console.log(buffer.buffer === arrayBuffer)
// Prints: truebuf.byteOffset
- <integer>
Bufferの基となるArrayBufferオブジェクトのbyteOffset。
Buffer.from(ArrayBuffer, byteOffset, length)でbyteOffsetを設定する場合、またはBufferをBuffer.poolSizeよりも小さく割り当てる場合、バッファは基となるArrayBufferのゼロオフセットから開始しないことがあります。
これにより、buf.bufferを使用して基となるArrayBufferに直接アクセスする際に問題が発生する可能性があります。ArrayBufferの他の部分がBufferオブジェクト自体とは無関係である可能性があるためです。
Bufferとメモリを共有するTypedArrayオブジェクトを作成する際の一般的な問題は、この場合、byteOffsetを正しく指定する必要があるということです。
import { Buffer } from 'node:buffer'
// `Buffer.poolSize`よりも小さいバッファを作成します。
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
// Node.js BufferをInt8Arrayにキャストする場合は、`nodeBuffer`のメモリを
// 含む`nodeBuffer.buffer`の部分のみを参照するようにbyteOffsetを使用します。
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)const { Buffer } = require('node:buffer')
// `Buffer.poolSize`よりも小さいバッファを作成します。
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
// Node.js BufferをInt8Arrayにキャストする場合は、`nodeBuffer`のメモリを
// 含む`nodeBuffer.buffer`の部分のみを参照するようにbyteOffsetを使用します。
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)buf.compare(target[, targetStart[, targetEnd[, sourceStart[, sourceEnd]]]])
[履歴]
| バージョン | 変更 |
|---|---|
| v8.0.0 | target パラメータが Uint8Array を受け付けるようになりました。 |
| v5.11.0 | オフセットを指定するための追加パラメータがサポートされるようになりました。 |
| v0.11.13 | v0.11.13 で追加されました。 |
target<Buffer> | <Uint8Array>bufと比較するBufferまたはUint8Array。targetStart<integer>target内で比較を開始するオフセット。デフォルト:0。targetEnd<integer>target内で比較を終了するオフセット (含まない)。デフォルト:target.length。sourceStart<integer>buf内で比較を開始するオフセット。デフォルト:0。sourceEnd<integer>buf内で比較を終了するオフセット (含まない)。デフォルト:buf.length。- 戻り値: <integer>
buf を target と比較し、ソート順で buf が target の前、後、または同じであるかを示す数値を返します。比較は、各 Buffer 内の実際のバイトシーケンスに基づいています。
targetがbufと同じ場合は0が返されます。- ソート時に
targetがbufの 前に 来る必要がある場合は1が返されます。 - ソート時に
targetがbufの 後に 来る必要がある場合は-1が返されます。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from('ABC')
const buf2 = Buffer.from('BCD')
const buf3 = Buffer.from('ABCD')
console.log(buf1.compare(buf1))
// Prints: 0
console.log(buf1.compare(buf2))
// Prints: -1
console.log(buf1.compare(buf3))
// Prints: -1
console.log(buf2.compare(buf1))
// Prints: 1
console.log(buf2.compare(buf3))
// Prints: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (この結果は [buf1, buf3, buf2] と同じです。)const { Buffer } = require('node:buffer')
const buf1 = Buffer.from('ABC')
const buf2 = Buffer.from('BCD')
const buf3 = Buffer.from('ABCD')
console.log(buf1.compare(buf1))
// Prints: 0
console.log(buf1.compare(buf2))
// Prints: -1
console.log(buf1.compare(buf3))
// Prints: -1
console.log(buf2.compare(buf1))
// Prints: 1
console.log(buf2.compare(buf3))
// Prints: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// Prints: [ <Buffer 41 42 43>, <Buffer 41 42 43 44>, <Buffer 42 43 44> ]
// (この結果は [buf1, buf3, buf2] と同じです。)オプションの targetStart、targetEnd、sourceStart、および sourceEnd 引数を使用して、比較をそれぞれ target および buf 内の特定の範囲に制限できます。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9])
const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4])
console.log(buf1.compare(buf2, 5, 9, 0, 4))
// Prints: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Prints: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Prints: 1const { Buffer } = require('node:buffer')
const buf1 = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8, 9])
const buf2 = Buffer.from([5, 6, 7, 8, 9, 1, 2, 3, 4])
console.log(buf1.compare(buf2, 5, 9, 0, 4))
// Prints: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// Prints: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// Prints: 1targetStart < 0、sourceStart < 0、targetEnd > target.byteLength、または sourceEnd > source.byteLength の場合、ERR_OUT_OF_RANGE がスローされます。
buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])
追加: v0.1.90
target<Buffer> | <Uint8Array> コピー先のBufferまたはUint8Array。targetStart<integer>target内で書き込みを開始するオフセット。既定値:0。sourceStart<integer>buf内でコピーを開始するオフセット。既定値:0。sourceEnd<integer>buf内でコピーを停止するオフセット（終端は含まない）。既定値:buf.length。- 戻り値: <integer> コピーされたバイト数。
target のメモリ領域が buf とオーバーラップする場合でも、buf の領域から target の領域にデータをコピーします。
TypedArray.prototype.set() は同じ操作を実行し、Node.js の Buffer を含むすべての TypedArray で利用できますが、異なる関数引数を受け取ります。
import { Buffer } from 'node:buffer'
// 2つの `Buffer` インスタンスを作成します。
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')
for (let i = 0; i < 26; i++) {
// 97 は 'a' の 10 進数 ASCII 値です。
buf1[i] = i + 97
}
// `buf1` の 16 から 19 バイトを `buf2` の 8 バイト目からコピーします。
buf1.copy(buf2, 8, 16, 20)
// これは以下と同等です:
// buf2.set(buf1.subarray(16, 20), 8);
console.log(buf2.toString('ascii', 0, 25))
// Prints: !!!!!!!!qrst!!!!!!!!!!!!!const { Buffer } = require('node:buffer')
// 2つの `Buffer` インスタンスを作成します。
const buf1 = Buffer.allocUnsafe(26)
const buf2 = Buffer.allocUnsafe(26).fill('!')
for (let i = 0; i < 26; i++) {
// 97 は 'a' の 10 進数 ASCII 値です。
buf1[i] = i + 97
}
// `buf1` の 16 から 19 バイトを `buf2` の 8 バイト目からコピーします。
buf1.copy(buf2, 8, 16, 20)
// これは以下と同等です:
// buf2.set(buf1.subarray(16, 20), 8);
console.log(buf2.toString('ascii', 0, 25))
// Prints: !!!!!!!!qrst!!!!!!!!!!!!!import { Buffer } from 'node:buffer'
// `Buffer` を作成し、同じ `Buffer` 内で、ある領域からオーバーラップした別の領域へデータをコピーします。
const buf = Buffer.allocUnsafe(26)
for (let i = 0; i < 26; i++) {
// 97 は 'a' の 10 進数 ASCII 値です。
buf[i] = i + 97
}
buf.copy(buf, 0, 4, 10)
console.log(buf.toString())
// Prints: efghijghijklmnopqrstuvwxyzconst { Buffer } = require('node:buffer')
// `Buffer` を作成し、同じ `Buffer` 内で、ある領域からオーバーラップした別の領域へデータをコピーします。
const buf = Buffer.allocUnsafe(26)
for (let i = 0; i < 26; i++) {
// 97 は 'a' の 10 進数 ASCII 値です。
buf[i] = i + 97
}
buf.copy(buf, 0, 4, 10)
console.log(buf.toString())
// Prints: efghijghijklmnopqrstuvwxyzbuf.entries()
追加: v1.1.0
- 返却値: <Iterator>
buf の内容から [index, byte] ペアの iterator を作成し、返します。
import { Buffer } from 'node:buffer'
// `Buffer` の内容全体をログ出力します。
const buf = Buffer.from('buffer')
for (const pair of buf.entries()) {
console.log(pair)
}
// Prints:
// [0, 98]
// [1, 117]
// [2, 102]
// [3, 102]
// [4, 101]
// [5, 114]const { Buffer } = require('node:buffer')
// `Buffer` の内容全体をログ出力します。
const buf = Buffer.from('buffer')
for (const pair of buf.entries()) {
console.log(pair)
}
// Prints:
// [0, 98]
// [1, 117]
// [2, 102]
// [3, 102]
// [4, 101]
// [5, 114]buf.equals(otherBuffer)
[履歴]
| バージョン | 変更点 |
|---|---|
| v8.0.0 | 引数に Uint8Array が使用できるようになりました。 |
| v0.11.13 | 追加: v0.11.13 |
otherBuffer<Buffer> | <Uint8Array>bufと比較するBufferまたはUint8Array。- 返却値: <boolean>
buf と otherBuffer の両方が完全に同じバイトを持っている場合は true を、それ以外の場合は false を返します。buf.compare(otherBuffer) === 0 と同等です。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from('ABC')
const buf2 = Buffer.from('414243', 'hex')
const buf3 = Buffer.from('ABCD')
console.log(buf1.equals(buf2))
// Prints: true
console.log(buf1.equals(buf3))
// Prints: falseconst { Buffer } = require('node:buffer')
const buf1 = Buffer.from('ABC')
const buf2 = Buffer.from('414243', 'hex')
const buf3 = Buffer.from('ABCD')
console.log(buf1.equals(buf2))
// Prints: true
console.log(buf1.equals(buf3))
// Prints: falsebuf.fill(value[, offset[, end]][, encoding])
[履歴]
| バージョン | 変更点 |
|---|---|
| v11.0.0 | ERR_INDEX_OUT_OF_RANGE の代わりに ERR_OUT_OF_RANGE をスローします。 |
| v10.0.0 | 負の end 値は ERR_INDEX_OUT_OF_RANGE エラーをスローします。 |
| v10.0.0 | 長さがゼロでないバッファーを長さがゼロのバッファーで埋めようとすると、例外がスローされます。 |
| v10.0.0 | value に無効な文字列を指定すると、例外がスローされます。 |
| v5.7.0 | encoding パラメーターがサポートされるようになりました。 |
| v0.5.0 | v0.5.0 で追加。 |
value<string> | <Buffer> | <Uint8Array> | <integer>bufを埋める値。空の値（string、Uint8Array、Buffer）は0に強制変換されます。offset<integer>bufを埋め始める前にスキップするバイト数。デフォルト:0。end<integer>bufを埋めるのを停止する位置 (含まない)。デフォルト:buf.length。encoding<string>valueが文字列の場合のvalueのエンコーディング。デフォルト:'utf8'。- 戻り値: <Buffer>
bufへの参照。
buf を指定された value で埋めます。 offset と end が指定されていない場合、buf 全体が埋められます。
import { Buffer } from 'node:buffer'
// `Buffer` を ASCII 文字 'h' で埋めます。
const b = Buffer.allocUnsafe(50).fill('h')
console.log(b.toString())
// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
// バッファーを空の文字列で埋めます
const c = Buffer.allocUnsafe(5).fill('')
console.log(c.fill(''))
// Prints: <Buffer 00 00 00 00 00>const { Buffer } = require('node:buffer')
// `Buffer` を ASCII 文字 'h' で埋めます。
const b = Buffer.allocUnsafe(50).fill('h')
console.log(b.toString())
// Prints: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
// バッファーを空の文字列で埋めます
const c = Buffer.allocUnsafe(5).fill('')
console.log(c.fill(''))
// Prints: <Buffer 00 00 00 00 00>value が文字列、Buffer、または整数でない場合は、uint32 値に強制変換されます。結果の整数が 255 (10 進数) より大きい場合、buf は value & 255 で埋められます。
fill() 操作の最後の書き込みがマルチバイト文字になる場合、buf に収まるその文字のバイトのみが書き込まれます。
import { Buffer } from 'node:buffer'
// UTF-8 で 2 バイトを占める文字で `Buffer` を埋めます。
console.log(Buffer.allocUnsafe(5).fill('\u0222'))
// Prints: <Buffer c8 a2 c8 a2 c8>const { Buffer } = require('node:buffer')
// UTF-8 で 2 バイトを占める文字で `Buffer` を埋めます。
console.log(Buffer.allocUnsafe(5).fill('\u0222'))
// Prints: <Buffer c8 a2 c8 a2 c8>value に無効な文字が含まれている場合、切り捨てられます。有効な埋め込みデータが残っていない場合は、例外がスローされます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(5)
console.log(buf.fill('a'))
// Prints: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Prints: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// 例外をスローします。const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(5)
console.log(buf.fill('a'))
// Prints: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// Prints: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// 例外をスローします。buf.includes(value[, byteOffset][, encoding])
Added in: v5.3.0
value<string> | <Buffer> | <Uint8Array> | <integer> 検索対象。byteOffset<integer>buf内の検索を開始する位置。負の値の場合、オフセットはbufの末尾から計算されます。デフォルト:0。encoding<string>valueが文字列の場合、そのエンコーディング。デフォルト:'utf8'。- 戻り値: <boolean>
valueがbuf内に見つかった場合はtrue、それ以外の場合はfalse。
buf.indexOf() !== -1 と同等。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('this is a buffer')
console.log(buf.includes('this'))
// Prints: true
console.log(buf.includes('is'))
// Prints: true
console.log(buf.includes(Buffer.from('a buffer')))
// Prints: true
console.log(buf.includes(97))
// Prints: true (97 は 'a' の 10 進数 ASCII 値)
console.log(buf.includes(Buffer.from('a buffer example')))
// Prints: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Prints: true
console.log(buf.includes('this', 4))
// Prints: falseconst { Buffer } = require('node:buffer')
const buf = Buffer.from('this is a buffer')
console.log(buf.includes('this'))
// Prints: true
console.log(buf.includes('is'))
// Prints: true
console.log(buf.includes(Buffer.from('a buffer')))
// Prints: true
console.log(buf.includes(97))
// Prints: true (97 は 'a' の 10 進数 ASCII 値)
console.log(buf.includes(Buffer.from('a buffer example')))
// Prints: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// Prints: true
console.log(buf.includes('this', 4))
// Prints: falsebuf.indexOf(value[, byteOffset][, encoding])
[履歴]
| バージョン | 変更 |
|---|---|
| v8.0.0 | value が Uint8Array になりました。 |
| v5.7.0, v4.4.0 | encoding が渡された場合、byteOffset パラメーターは必須ではなくなりました。 |
| v1.5.0 | 追加: v1.5.0 |
value<string> | <Buffer> | <Uint8Array> | <integer> 検索対象。byteOffset<integer>bufで検索を開始する位置。負の場合、オフセットはbufの末尾から計算されます。デフォルト:0。encoding<string>valueが文字列の場合、これはbufで検索される文字列のバイナリ表現を決定するために使用されるエンコーディングです。デフォルト:'utf8'。- 戻り値: <integer>
buf内のvalueの最初の出現箇所のインデックス。bufにvalueが含まれていない場合は-1。
value が次の場合：
- 文字列の場合、
valueはencodingの文字エンコーディングに従って解釈されます。 BufferまたはUint8Arrayの場合、valueは全体として使用されます。Bufferの一部を比較するには、buf.subarrayを使用します。- 数値の場合、
valueは0から255の間の符号なし 8 ビット整数値として解釈されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('this is a buffer')
console.log(buf.indexOf('this'))
// Prints: 0
console.log(buf.indexOf('is'))
// Prints: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Prints: 8
console.log(buf.indexOf(97))
// Prints: 8 (97 は 'a' の 10 進 ASCII 値)
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Prints: 8
const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')
console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// Prints: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// Prints: 6const { Buffer } = require('node:buffer')
const buf = Buffer.from('this is a buffer')
console.log(buf.indexOf('this'))
// Prints: 0
console.log(buf.indexOf('is'))
// Prints: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// Prints: 8
console.log(buf.indexOf(97))
// Prints: 8 (97 は 'a' の 10 進 ASCII 値)
console.log(buf.indexOf(Buffer.from('a buffer example')))
// Prints: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// Prints: 8
const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')
console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// Prints: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// Prints: 6value が文字列、数値、または Buffer でない場合、このメソッドは TypeError をスローします。value が数値の場合、0 から 255 の間の整数である有効なバイト値に強制変換されます。
byteOffset が数値でない場合は、数値に強制変換されます。強制変換の結果が NaN または 0 の場合、バッファー全体が検索されます。この動作は String.prototype.indexOf() と一致します。
import { Buffer } from 'node:buffer'
const b = Buffer.from('abcdef')
// 数値だが、有効なバイトではない値を渡す。
// Prints: 2, 99 または 'c' の検索に相当。
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))
// NaN または 0 に強制変換される byteOffset を渡す。
// Prints: 1, バッファー全体を検索。
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))const { Buffer } = require('node:buffer')
const b = Buffer.from('abcdef')
// 数値だが、有効なバイトではない値を渡す。
// Prints: 2, 99 または 'c' の検索に相当。
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))
// NaN または 0 に強制変換される byteOffset を渡す。
// Prints: 1, バッファー全体を検索。
console.log(b.indexOf('b', undefined))
console.log(b.indexOf('b', {}))
console.log(b.indexOf('b', null))
console.log(b.indexOf('b', []))value が空の文字列または空の Buffer であり、byteOffset が buf.length より小さい場合、byteOffset が返されます。value が空で、byteOffset が少なくとも buf.length の場合、buf.length が返されます。
buf.keys()
追加: v1.1.0
- 戻り値: <Iterator>
buf のキー（インデックス）の イテレータ を作成して返します。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('buffer')
for (const key of buf.keys()) {
console.log(key)
}
// 出力:
// 0
// 1
// 2
// 3
// 4
// 5const { Buffer } = require('node:buffer')
const buf = Buffer.from('buffer')
for (const key of buf.keys()) {
console.log(key)
}
// 出力:
// 0
// 1
// 2
// 3
// 4
// 5buf.lastIndexOf(value[, byteOffset][, encoding])
[履歴]
| バージョン | 変更点 |
|---|---|
| v8.0.0 | value が Uint8Array になれるようになりました。 |
| v6.0.0 | 追加: v6.0.0 |
value<string> | <Buffer> | <Uint8Array> | <integer> 検索対象。byteOffset<integer>buf内の検索を開始する位置。負数の場合、オフセットはbufの末尾から計算されます。既定:buf.length - 1。encoding<string>valueが文字列の場合、これはbufで検索される文字列のバイナリ表現を決定するために使用されるエンコーディングです。既定:'utf8'。- 戻り値: <integer>
buf内のvalueの最後の出現箇所のインデックス。bufがvalueを含んでいない場合は-1。
最初の出現箇所ではなく、value の最後の出現箇所が見つかることを除いて、buf.indexOf() と同じです。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('this buffer is a buffer')
console.log(buf.lastIndexOf('this'))
// 出力: 0
console.log(buf.lastIndexOf('buffer'))
// 出力: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// 出力: 17
console.log(buf.lastIndexOf(97))
// 出力: 15 (97 は 'a' の 10 進数 ASCII 値)
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// 出力: -1
console.log(buf.lastIndexOf('buffer', 5))
// 出力: 5
console.log(buf.lastIndexOf('buffer', 4))
// 出力: -1
const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')
console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'))
// 出力: 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'))
// 出力: 4const { Buffer } = require('node:buffer')
const buf = Buffer.from('this buffer is a buffer')
console.log(buf.lastIndexOf('this'))
// 出力: 0
console.log(buf.lastIndexOf('buffer'))
// 出力: 17
console.log(buf.lastIndexOf(Buffer.from('buffer')))
// 出力: 17
console.log(buf.lastIndexOf(97))
// 出力: 15 (97 は 'a' の 10 進数 ASCII 値)
console.log(buf.lastIndexOf(Buffer.from('yolo')))
// 出力: -1
console.log(buf.lastIndexOf('buffer', 5))
// 出力: 5
console.log(buf.lastIndexOf('buffer', 4))
// 出力: -1
const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')
console.log(utf16Buffer.lastIndexOf('\u03a3', undefined, 'utf16le'))
// 出力: 6
console.log(utf16Buffer.lastIndexOf('\u03a3', -5, 'utf16le'))
// 出力: 4value が文字列、数値、または Buffer でない場合、このメソッドは TypeError をスローします。value が数値の場合、有効なバイト値、つまり 0 から 255 の間の整数に強制されます。
byteOffset が数値でない場合、数値に強制されます。{} または undefined のように NaN に強制される引数は、バッファー全体を検索します。この動作は String.prototype.lastIndexOf() と一致します。
import { Buffer } from 'node:buffer'
const b = Buffer.from('abcdef')
// 数値だが有効なバイトではない値を渡す。
// 出力: 2、99 または 'c' を検索するのと同じ。
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))
// NaN に強制される byteOffset を渡す。
// 出力: 1、バッファー全体を検索する。
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))
// 0 に強制される byteOffset を渡す。
// 出力: -1、0 を渡すのと同じ。
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))const { Buffer } = require('node:buffer')
const b = Buffer.from('abcdef')
// 数値だが有効なバイトではない値を渡す。
// 出力: 2、99 または 'c' を検索するのと同じ。
console.log(b.lastIndexOf(99.9))
console.log(b.lastIndexOf(256 + 99))
// NaN に強制される byteOffset を渡す。
// 出力: 1、バッファー全体を検索する。
console.log(b.lastIndexOf('b', undefined))
console.log(b.lastIndexOf('b', {}))
// 0 に強制される byteOffset を渡す。
// 出力: -1、0 を渡すのと同じ。
console.log(b.lastIndexOf('b', null))
console.log(b.lastIndexOf('b', []))value が空の文字列または空の Buffer の場合、byteOffset が返されます。
buf.length
追加: v0.1.90
buf内のバイト数を返します。
import { Buffer } from 'node:buffer'
// `Buffer`を作成し、UTF-8を使用してより短い文字列を書き込みます。
const buf = Buffer.alloc(1234)
console.log(buf.length)
// Prints: 1234
buf.write('some string', 0, 'utf8')
console.log(buf.length)
// Prints: 1234const { Buffer } = require('node:buffer')
// `Buffer`を作成し、UTF-8を使用してより短い文字列を書き込みます。
const buf = Buffer.alloc(1234)
console.log(buf.length)
// Prints: 1234
buf.write('some string', 0, 'utf8')
console.log(buf.length)
// Prints: 1234buf.parent
非推奨: v8.0.0 以降
[安定版: 0 - 非推奨]
安定版: 0 安定度: 0 - 非推奨: 代わりにbuf.bufferを使用してください。
buf.parentプロパティは、buf.bufferの非推奨のエイリアスです。
buf.readBigInt64BE([offset])
追加: v12.0.0, v10.20.0
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。 デフォルト:0。- 戻り値: <bigint>
指定されたoffsetで、bufから符号付きのビッグエンディアン 64 ビット整数を読み取ります。
Bufferから読み取られた整数は、2 の補数符号付きの値として解釈されます。
buf.readBigInt64LE([offset])
追加: v12.0.0, v10.20.0
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。 デフォルト:0。- 戻り値: <bigint>
指定されたoffsetで、bufから符号付きのリトルエンディアン 64 ビット整数を読み取ります。
Bufferから読み取られた整数は、2 の補数符号付きの値として解釈されます。
buf.readBigUInt64BE([offset])
[History]
| バージョン | 変更 |
|---|---|
| v14.10.0, v12.19.0 | この関数は buf.readBigUint64BE() としても利用可能です。 |
| v12.0.0, v10.20.0 | 追加: v12.0.0, v10.20.0 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト:0。- 戻り値: <bigint>
指定された offset の位置から、buf から符号なしビッグエンディアン 64 ビット整数を読み込みます。
この関数は readBigUint64BE エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])
console.log(buf.readBigUInt64BE(0))
// Prints: 4294967295nconst { Buffer } = require('node:buffer')
const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])
console.log(buf.readBigUInt64BE(0))
// Prints: 4294967295nbuf.readBigUInt64LE([offset])
[History]
| バージョン | 変更 |
|---|---|
| v14.10.0, v12.19.0 | この関数は buf.readBigUint64LE() としても利用可能です。 |
| v12.0.0, v10.20.0 | 追加: v12.0.0, v10.20.0 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト:0。- 戻り値: <bigint>
指定された offset の位置から、buf から符号なしリトルエンディアン 64 ビット整数を読み込みます。
この関数は readBigUint64LE エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])
console.log(buf.readBigUInt64LE(0))
// Prints: 18446744069414584320nconst { Buffer } = require('node:buffer')
const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])
console.log(buf.readBigUInt64LE(0))
// Prints: 18446744069414584320nbuf.readDoubleBE([offset])
[履歴]
| バージョン | 変更 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型変換はなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト:0。- 戻り値: <number>
指定された offset の位置から、buf から 64 ビットのビッグエンディアンの double を読み込みます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])
console.log(buf.readDoubleBE(0))
// Prints: 8.20788039913184e-304const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])
console.log(buf.readDoubleBE(0))
// Prints: 8.20788039913184e-304buf.readDoubleLE([offset])
[履歴]
| バージョン | 変更 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型変換はなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト:0。- 戻り値: <number>
指定された offset の位置から、buf から 64 ビットのリトルエンディアンの double を読み込みます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])
console.log(buf.readDoubleLE(0))
// Prints: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Throws ERR_OUT_OF_RANGE.const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])
console.log(buf.readDoubleLE(0))
// Prints: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// Throws ERR_OUT_OF_RANGE.buf.readFloatBE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型変換がなくなりました。 |
| v0.11.15 | 追加: v0.11.15 |
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。 デフォルト:0。- 戻り値: <number>
指定された offset の位置から、buf から 32 ビットのビッグエンディアン浮動小数点数を読み取ります。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4])
console.log(buf.readFloatBE(0))
// Prints: 2.387939260590663e-38const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3, 4])
console.log(buf.readFloatBE(0))
// Prints: 2.387939260590663e-38buf.readFloatLE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型変換がなくなりました。 |
| v0.11.15 | 追加: v0.11.15 |
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。 デフォルト:0。- 戻り値: <number>
指定された offset の位置から、buf から 32 ビットのリトルエンディアン浮動小数点数を読み取ります。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4])
console.log(buf.readFloatLE(0))
// Prints: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Throws ERR_OUT_OF_RANGE.const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3, 4])
console.log(buf.readFloatLE(0))
// Prints: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// Throws ERR_OUT_OF_RANGE.buf.readInt8([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な強制型変換がなくなりました。 |
| v0.5.0 | 追加: v0.5.0 |
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 1を満たす必要があります。デフォルト:0。- 戻り値: <integer>
指定された offset の位置から、buf から符号付き 8 ビット整数を読み取ります。
Buffer から読み取られた整数は、2 の補数の符号付きの値として解釈されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([-1, 5])
console.log(buf.readInt8(0))
// Prints: -1
console.log(buf.readInt8(1))
// Prints: 5
console.log(buf.readInt8(2))
// ERR_OUT_OF_RANGE をスローします。const { Buffer } = require('node:buffer')
const buf = Buffer.from([-1, 5])
console.log(buf.readInt8(0))
// Prints: -1
console.log(buf.readInt8(1))
// Prints: 5
console.log(buf.readInt8(2))
// ERR_OUT_OF_RANGE をスローします。buf.readInt16BE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な強制型変換がなくなりました。 |
| v0.5.5 | 追加: v0.5.5 |
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト:0。- 戻り値: <integer>
指定された offset の位置から、buf から符号付きビッグエンディアン 16 ビット整数を読み取ります。
Buffer から読み取られた整数は、2 の補数の符号付きの値として解釈されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0, 5])
console.log(buf.readInt16BE(0))
// Prints: 5const { Buffer } = require('node:buffer')
const buf = Buffer.from([0, 5])
console.log(buf.readInt16BE(0))
// Prints: 5buf.readInt16LE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な強制型変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト:0。- 戻り値: <integer>
指定された offset の buf から、符号付きのリトルエンディアン 16 ビット整数を読み込みます。
Buffer から読み込まれた整数は、2 の補数符号付き値として解釈されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0, 5])
console.log(buf.readInt16LE(0))
// Prints: 1280
console.log(buf.readInt16LE(1))
// ERR_OUT_OF_RANGE がスローされます。const { Buffer } = require('node:buffer')
const buf = Buffer.from([0, 5])
console.log(buf.readInt16LE(0))
// Prints: 1280
console.log(buf.readInt16LE(1))
// ERR_OUT_OF_RANGE がスローされます。buf.readInt32BE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な強制型変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト:0。- 戻り値: <integer>
指定された offset の buf から、符号付きのビッグエンディアン 32 ビット整数を読み込みます。
Buffer から読み込まれた整数は、2 の補数符号付き値として解釈されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0, 0, 0, 5])
console.log(buf.readInt32BE(0))
// Prints: 5const { Buffer } = require('node:buffer')
const buf = Buffer.from([0, 0, 0, 5])
console.log(buf.readInt32BE(0))
// Prints: 5buf.readInt32LE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型強制がなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト:0。- 戻り値: <integer>
指定された offset の buf から、符号付き、リトルエンディアンの 32 ビット整数を読み取ります。
Buffer から読み取られた整数は、2 の補数による符号付きの値として解釈されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0, 0, 0, 5])
console.log(buf.readInt32LE(0))
// 出力: 83886080
console.log(buf.readInt32LE(1))
// ERR_OUT_OF_RANGE をスローします。const { Buffer } = require('node:buffer')
const buf = Buffer.from([0, 0, 0, 5])
console.log(buf.readInt32LE(0))
// 出力: 83886080
console.log(buf.readInt32LE(1))
// ERR_OUT_OF_RANGE をスローします。buf.readIntBE(offset, byteLength)
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットと byteLength の uint32 への暗黙的な型強制がなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLengthを満たす必要があります。byteLength<integer> 読み込むバイト数。0 < byteLength <= 6を満たす必要があります。- 戻り値: <integer>
指定された offset の buf から byteLength バイト数を読み取り、結果を最大 48 ビットの精度をサポートするビッグエンディアンの 2 の補数の符号付きの値として解釈します。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readIntBE(0, 6).toString(16))
// 出力: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// ERR_OUT_OF_RANGE をスローします。
console.log(buf.readIntBE(1, 0).toString(16))
// ERR_OUT_OF_RANGE をスローします。const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readIntBE(0, 6).toString(16))
// 出力: 1234567890ab
console.log(buf.readIntBE(1, 6).toString(16))
// ERR_OUT_OF_RANGE をスローします。
console.log(buf.readIntBE(1, 0).toString(16))
// ERR_OUT_OF_RANGE をスローします。buf.readIntLE(offset, byteLength)
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssertが削除され、offset とbyteLengthのuint32への暗黙的な型強制がなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLengthを満たす必要があります。byteLength<integer> 読み取るバイト数。0 < byteLength <= 6を満たす必要があります。- 戻り値: <integer>
指定されたoffsetにあるbufからbyteLengthバイト数を読み取り、結果をリトルエンディアンの、最大 48 ビットの精度をサポートする 2 の補数符号付きの値として解釈します。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readIntLE(0, 6).toString(16))
// Prints: -546f87a9cbeeconst { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readIntLE(0, 6).toString(16))
// Prints: -546f87a9cbeebuf.readUInt8([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数はbuf.readUint8()としても利用できます。 |
| v10.0.0 | noAssertが削除され、offset のuint32への暗黙的な型強制がなくなりました。 |
| v0.5.0 | v0.5.0 で追加されました。 |
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 1を満たす必要があります。デフォルト:0。- 戻り値: <integer>
指定されたoffsetにあるbufから符号なし 8 ビット整数を読み取ります。
この関数は、readUint8エイリアスでも利用できます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, -2])
console.log(buf.readUInt8(0))
// Prints: 1
console.log(buf.readUInt8(1))
// Prints: 254
console.log(buf.readUInt8(2))
// Throws ERR_OUT_OF_RANGE.const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, -2])
console.log(buf.readUInt8(0))
// Prints: 1
console.log(buf.readUInt8(1))
// Prints: 254
console.log(buf.readUInt8(2))
// Throws ERR_OUT_OF_RANGE.buf.readUInt16BE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.readUint16BE() としても利用できます。 |
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト:0。- 戻り値: <integer>
指定された offset で buf から符号なしのビッグエンディアン 16 ビット整数を読み取ります。
この関数は readUint16BE エイリアスでも利用できます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56])
console.log(buf.readUInt16BE(0).toString(16))
// Prints: 1234
console.log(buf.readUInt16BE(1).toString(16))
// Prints: 3456const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56])
console.log(buf.readUInt16BE(0).toString(16))
// Prints: 1234
console.log(buf.readUInt16BE(1).toString(16))
// Prints: 3456buf.readUInt16LE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.readUint16LE() としても利用できます。 |
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
offset<integer> 読み取りを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト:0。- 戻り値: <integer>
指定された offset で buf から符号なしのリトルエンディアン 16 ビット整数を読み取ります。
この関数は readUint16LE エイリアスでも利用できます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56])
console.log(buf.readUInt16LE(0).toString(16))
// Prints: 3412
console.log(buf.readUInt16LE(1).toString(16))
// Prints: 5634
console.log(buf.readUInt16LE(2).toString(16))
// Throws ERR_OUT_OF_RANGE.const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56])
console.log(buf.readUInt16LE(0).toString(16))
// Prints: 3412
console.log(buf.readUInt16LE(1).toString(16))
// Prints: 5634
console.log(buf.readUInt16LE(2).toString(16))
// Throws ERR_OUT_OF_RANGE.buf.readUInt32BE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.readUint32BE() としても利用可能です。 |
| v10.0.0 | noAssert が削除され、offset の uint32 への暗黙的な型変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。 デフォルト:0。- 戻り値: <integer>
指定された offset の buf から、符号なしのビッグエンディアン 32 ビット整数を読み込みます。
この関数は readUint32BE エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])
console.log(buf.readUInt32BE(0).toString(16))
// Prints: 12345678const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])
console.log(buf.readUInt32BE(0).toString(16))
// Prints: 12345678buf.readUInt32LE([offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.readUint32LE() としても利用可能です。 |
| v10.0.0 | noAssert が削除され、offset の uint32 への暗黙的な型変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。 デフォルト:0。- 戻り値: <integer>
指定された offset の buf から、符号なしのリトルエンディアン 32 ビット整数を読み込みます。
この関数は readUint32LE エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])
console.log(buf.readUInt32LE(0).toString(16))
// Prints: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Throws ERR_OUT_OF_RANGE.const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])
console.log(buf.readUInt32LE(0).toString(16))
// Prints: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// Throws ERR_OUT_OF_RANGE.buf.readUIntBE(offset, byteLength)
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.readUintBE() としても利用可能です。 |
| v10.0.0 | noAssert が削除され、offset と byteLength の uint32 への暗黙的な型強制もなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLengthを満たす必要があります。byteLength<integer> 読み込むバイト数。0 < byteLength <= 6を満たす必要があります。- 戻り値: <integer>
指定された offset の buf から byteLength バイト数を読み取り、結果を最大 48 ビットの精度をサポートする符号なしビッグエンディアン整数として解釈します。
この関数は readUintBE エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readUIntBE(0, 6).toString(16))
// Prints: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// ERR_OUT_OF_RANGE をスローします。const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readUIntBE(0, 6).toString(16))
// Prints: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// ERR_OUT_OF_RANGE をスローします。buf.readUIntLE(offset, byteLength)
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.readUintLE() としても利用可能です。 |
| v10.0.0 | noAssert が削除され、offset と byteLength の uint32 への暗黙的な型強制もなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
offset<integer> 読み込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLengthを満たす必要があります。byteLength<integer> 読み込むバイト数。0 < byteLength <= 6を満たす必要があります。- 戻り値: <integer>
指定された offset の buf から byteLength バイト数を読み取り、結果を最大 48 ビットの精度をサポートする符号なしリトルエンディアン整数として解釈します。
この関数は readUintLE エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readUIntLE(0, 6).toString(16))
// Prints: ab9078563412const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readUIntLE(0, 6).toString(16))
// Prints: ab9078563412buf.subarray([start[, end]])
追加: v3.0.0
start<integer> 新しいBufferが開始される位置。デフォルト:0。end<integer> 新しいBufferが終了する位置 (終端を含まない)。デフォルト:buf.length。- 戻り値: <Buffer>
元の Buffer と同じメモリを参照する新しい Buffer を返しますが、start と end インデックスによってオフセットおよび切り取られます。
end が buf.length より大きい値を指定した場合、end が buf.length と同じである場合と同じ結果が返されます。
このメソッドは TypedArray.prototype.subarray() から継承されます。
新しい Buffer スライスを変更すると、2 つのオブジェクトの割り当てられたメモリが重複しているため、元の Buffer のメモリが変更されます。
import { Buffer } from 'node:buffer'
// ASCIIアルファベットを持つ `Buffer` を作成し、スライスを取得して、元の `Buffer` から1バイトを変更します。
const buf1 = Buffer.allocUnsafe(26)
for (let i = 0; i < 26; i++) {
// 97 は 'a' の10進数ASCII値です。
buf1[i] = i + 97
}
const buf2 = buf1.subarray(0, 3)
console.log(buf2.toString('ascii', 0, buf2.length))
// 出力: abc
buf1[0] = 33
console.log(buf2.toString('ascii', 0, buf2.length))
// 出力: !bcconst { Buffer } = require('node:buffer')
// ASCIIアルファベットを持つ `Buffer` を作成し、スライスを取得して、元の `Buffer` から1バイトを変更します。
const buf1 = Buffer.allocUnsafe(26)
for (let i = 0; i < 26; i++) {
// 97 は 'a' の10進数ASCII値です。
buf1[i] = i + 97
}
const buf2 = buf1.subarray(0, 3)
console.log(buf2.toString('ascii', 0, buf2.length))
// 出力: abc
buf1[0] = 33
console.log(buf2.toString('ascii', 0, buf2.length))
// 出力: !bc負のインデックスを指定すると、スライスは先頭ではなく、buf の末尾を基準にして生成されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('buffer')
console.log(buf.subarray(-6, -1).toString())
// 出力: buffe
// (buf.subarray(0, 5) と同等。)
console.log(buf.subarray(-6, -2).toString())
// 出力: buff
// (buf.subarray(0, 4) と同等。)
console.log(buf.subarray(-5, -2).toString())
// 出力: uff
// (buf.subarray(1, 4) と同等。)const { Buffer } = require('node:buffer')
const buf = Buffer.from('buffer')
console.log(buf.subarray(-6, -1).toString())
// 出力: buffe
// (buf.subarray(0, 5) と同等。)
console.log(buf.subarray(-6, -2).toString())
// 出力: buff
// (buf.subarray(0, 4) と同等。)
console.log(buf.subarray(-5, -2).toString())
// 出力: uff
// (buf.subarray(1, 4) と同等。)buf.slice([start[, end]])
[履歴]
| バージョン | 変更点 |
|---|---|
| v17.5.0, v16.15.0 | buf.slice() メソッドは非推奨になりました。 |
| v7.0.0 | すべてのオフセットは、計算を実行する前に整数に強制変換されるようになりました。 |
| v7.1.0, v6.9.2 | オフセットを整数に強制変換する処理で、32 ビット整数範囲外の値が適切に処理されるようになりました。 |
| v0.3.0 | 追加: v0.3.0 |
start<integer> 新しいBufferが開始される位置。デフォルト:0。end<integer> 新しいBufferが終了する位置（非包括的）。デフォルト:buf.length。- 戻り値: <Buffer>
[Stable: 0 - Deprecated]
Stable: 0 安定度: 0 - 非推奨: 代わりに buf.subarray を使用してください。
元のメモリと同じメモリを参照し、start および end インデックスによってオフセットおよびトリミングされた新しい Buffer を返します。
このメソッドは、Buffer のスーパークラスである Uint8Array.prototype.slice() と互換性がありません。スライスをコピーするには、Uint8Array.prototype.slice() を使用します。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('buffer')
const copiedBuf = Uint8Array.prototype.slice.call(buf)
copiedBuf[0]++
console.log(copiedBuf.toString())
// Prints: cuffer
console.log(buf.toString())
// Prints: buffer
// buf.slice() を使用すると、元のバッファーが変更されます。
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Prints: cuffer
console.log(buf.toString())
// Also prints: cuffer (!)const { Buffer } = require('node:buffer')
const buf = Buffer.from('buffer')
const copiedBuf = Uint8Array.prototype.slice.call(buf)
copiedBuf[0]++
console.log(copiedBuf.toString())
// Prints: cuffer
console.log(buf.toString())
// Prints: buffer
// buf.slice() を使用すると、元のバッファーが変更されます。
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// Prints: cuffer
console.log(buf.toString())
// Also prints: cuffer (!)buf.swap16()
追加: v5.10.0
- 戻り値: <Buffer>
bufへの参照。
bufを符号なし 16 ビット整数の配列として解釈し、バイト順をインプレースで入れ替えます。buf.lengthが 2 の倍数でない場合、ERR_INVALID_BUFFER_SIZEをスローします。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// Prints: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap16()
console.log(buf1)
// Prints: <Buffer 02 01 04 03 06 05 08 07>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap16()
// Throws ERR_INVALID_BUFFER_SIZE.const { Buffer } = require('node:buffer')
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// Prints: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap16()
console.log(buf1)
// Prints: <Buffer 02 01 04 03 06 05 08 07>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap16()
// Throws ERR_INVALID_BUFFER_SIZE.buf.swap16()の便利な使用例の 1 つは、UTF-16 リトルエンディアンと UTF-16 ビッグエンディアン間の高速なインプレース変換を実行することです。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // ビッグエンディアンUTF-16テキストに変換します。const { Buffer } = require('node:buffer')
const buf = Buffer.from('This is little-endian UTF-16', 'utf16le')
buf.swap16() // ビッグエンディアンUTF-16テキストに変換します。buf.swap32()
追加: v5.10.0
- 戻り値: <Buffer>
bufへの参照。
bufを符号なし 32 ビット整数の配列として解釈し、バイト順をインプレースで入れ替えます。buf.lengthが 4 の倍数でない場合、ERR_INVALID_BUFFER_SIZEをスローします。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// Prints: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap32()
console.log(buf1)
// Prints: <Buffer 04 03 02 01 08 07 06 05>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap32()
// Throws ERR_INVALID_BUFFER_SIZE.const { Buffer } = require('node:buffer')
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// Prints: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap32()
console.log(buf1)
// Prints: <Buffer 04 03 02 01 08 07 06 05>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap32()
// Throws ERR_INVALID_BUFFER_SIZE.buf.swap64()
追加: v6.3.0
- 戻り値: <Buffer>
bufへの参照。
buf を 64 ビット数値の配列として解釈し、バイトオーダーをインプレースで入れ替えます。もしbuf.length が 8 の倍数でない場合は、ERR_INVALID_BUFFER_SIZE をスローします。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// Prints: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap64()
console.log(buf1)
// Prints: <Buffer 08 07 06 05 04 03 02 01>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap64()
// Throws ERR_INVALID_BUFFER_SIZE.const { Buffer } = require('node:buffer')
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// Prints: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap64()
console.log(buf1)
// Prints: <Buffer 08 07 06 05 04 03 02 01>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap64()
// Throws ERR_INVALID_BUFFER_SIZE.buf.toJSON()
追加: v0.9.2
- 戻り値: <Object>
buf の JSON 表現を返します。JSON.stringify() は、Buffer インスタンスを文字列化する際に、この関数を暗黙的に呼び出します。
Buffer.from() は、このメソッドから返される形式のオブジェクトを受け入れます。特に、Buffer.from(buf.toJSON()) は Buffer.from(buf) のように機能します。
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5])
const json = JSON.stringify(buf)
console.log(json)
// Prints: {"type":"Buffer","data":[1,2,3,4,5]}
const copy = JSON.parse(json, (key, value) => {
return value && value.type === 'Buffer' ? Buffer.from(value) : value
})
console.log(copy)
// Prints: <Buffer 01 02 03 04 05>const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5])
const json = JSON.stringify(buf)
console.log(json)
// Prints: {"type":"Buffer","data":[1,2,3,4,5]}
const copy = JSON.parse(json, (key, value) => {
return value && value.type === 'Buffer' ? Buffer.from(value) : value
})
console.log(copy)
// Prints: <Buffer 01 02 03 04 05>buf.toString([encoding[, start[, end]]])
追加: v0.1.90
encoding<string> 使用する文字エンコーディング。デフォルト:'utf8'。start<integer> デコードを開始するバイトオフセット。デフォルト:0。end<integer> デコードを停止するバイトオフセット（含まない）。デフォルト:buf.length。- 戻り値: <string>
encodingで指定された文字エンコーディングに従って、bufを文字列にデコードします。startとendを渡して、bufのサブセットのみをデコードできます。
encodingが'utf8'で、入力内のバイトシーケンスが有効な UTF-8 でない場合、無効な各バイトは置換文字U+FFFDに置き換えられます。
文字列インスタンスの最大長（UTF-16 コードユニット）は、buffer.constants.MAX_STRING_LENGTHとして利用できます。
import { Buffer } from 'node:buffer'
const buf1 = Buffer.allocUnsafe(26)
for (let i = 0; i < 26; i++) {
// 97 は 'a' の 10 進 ASCII 値です。
buf1[i] = i + 97
}
console.log(buf1.toString('utf8'))
// Prints: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// Prints: abcde
const buf2 = Buffer.from('tést')
console.log(buf2.toString('hex'))
// Prints: 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// Prints: té
console.log(buf2.toString(undefined, 0, 3))
// Prints: téconst { Buffer } = require('node:buffer')
const buf1 = Buffer.allocUnsafe(26)
for (let i = 0; i < 26; i++) {
// 97 は 'a' の 10 進 ASCII 値です。
buf1[i] = i + 97
}
console.log(buf1.toString('utf8'))
// Prints: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// Prints: abcde
const buf2 = Buffer.from('tést')
console.log(buf2.toString('hex'))
// Prints: 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// Prints: té
console.log(buf2.toString(undefined, 0, 3))
// Prints: tébuf.values()
追加: v1.1.0
- 戻り値: <Iterator>
buf の値 (バイト) のための イテレーター を作成して返します。この関数は Buffer が for..of ステートメントで使用されるときに自動的に呼び出されます。
import { Buffer } from 'node:buffer'
const buf = Buffer.from('buffer')
for (const value of buf.values()) {
console.log(value)
}
// 出力:
// 98
// 117
// 102
// 102
// 101
// 114
for (const value of buf) {
console.log(value)
}
// 出力:
// 98
// 117
// 102
// 102
// 101
// 114const { Buffer } = require('node:buffer')
const buf = Buffer.from('buffer')
for (const value of buf.values()) {
console.log(value)
}
// 出力:
// 98
// 117
// 102
// 102
// 101
// 114
for (const value of buf) {
console.log(value)
}
// 出力:
// 98
// 117
// 102
// 102
// 101
// 114buf.write(string[, offset[, length]][, encoding])
追加: v0.1.90
string<string>bufに書き込む文字列。offset<integer>stringの書き込みを開始する前にスキップするバイト数。デフォルト:0。length<integer> 書き込む最大バイト数（書き込まれるバイト数はbuf.length - offsetを超えない）。デフォルト:buf.length - offset。encoding<string>stringの文字エンコーディング。デフォルト:'utf8'。- 戻り値: <integer> 書き込まれたバイト数。
encoding の文字エンコーディングに従って、string を offset の位置から buf に書き込みます。length パラメーターは書き込むバイト数です。buf に文字列全体を格納するのに十分なスペースがない場合、string の一部のみが書き込まれます。ただし、部分的にエンコードされた文字は書き込まれません。
import { Buffer } from 'node:buffer'
const buf = Buffer.alloc(256)
const len = buf.write('\u00bd + \u00bc = \u00be', 0)
console.log(`${len} バイト: ${buf.toString('utf8', 0, len)}`)
// 出力: 12 バイト: ½ + ¼ = ¾
const buffer = Buffer.alloc(10)
const length = buffer.write('abcd', 8)
console.log(`${length} バイト: ${buffer.toString('utf8', 8, 10)}`)
// 出力: 2 バイト: abconst { Buffer } = require('node:buffer')
const buf = Buffer.alloc(256)
const len = buf.write('\u00bd + \u00bc = \u00be', 0)
console.log(`${len} バイト: ${buf.toString('utf8', 0, len)}`)
// 出力: 12 バイト: ½ + ¼ = ¾
const buffer = Buffer.alloc(10)
const length = buffer.write('abcd', 8)
console.log(`${length} バイト: ${buffer.toString('utf8', 8, 10)}`)
// 出力: 2 バイト: abbuf.writeBigInt64BE(value[, offset])
追加: v12.0.0, v10.20.0
value<bigint>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。 デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
value をビッグエンディアンとして、指定された offset の位置に buf に書き込みます。
value は 2 の補数付き符号付き整数として解釈され、書き込まれます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeBigInt64BE(0x0102030405060708n, 0)
console.log(buf)
// Prints: <Buffer 01 02 03 04 05 06 07 08>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(8)
buf.writeBigInt64BE(0x0102030405060708n, 0)
console.log(buf)
// Prints: <Buffer 01 02 03 04 05 06 07 08>buf.writeBigInt64LE(value[, offset])
追加: v12.0.0, v10.20.0
value<bigint>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。 デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
value をリトルエンディアンとして、指定された offset の位置に buf に書き込みます。
value は 2 の補数付き符号付き整数として解釈され、書き込まれます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeBigInt64LE(0x0102030405060708n, 0)
console.log(buf)
// Prints: <Buffer 08 07 06 05 04 03 02 01>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(8)
buf.writeBigInt64LE(0x0102030405060708n, 0)
console.log(buf)
// Prints: <Buffer 08 07 06 05 04 03 02 01>buf.writeBigUInt64BE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.10.0, v12.19.0 | この関数は buf.writeBigUint64BE() としても利用可能です。 |
| v12.0.0, v10.20.0 | 追加: v12.0.0, v10.20.0 |
value<bigint>bufに書き込まれる数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えた値。
value をビッグエンディアンとして、指定された offset の buf に書き込みます。
この関数は writeBigUint64BE エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeBigUInt64BE(0xdecafafecacefaden, 0)
console.log(buf)
// Prints: <Buffer de ca fa fe ca ce fa de>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(8)
buf.writeBigUInt64BE(0xdecafafecacefaden, 0)
console.log(buf)
// Prints: <Buffer de ca fa fe ca ce fa de>buf.writeBigUInt64LE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.10.0, v12.19.0 | この関数は buf.writeBigUint64LE() としても利用可能です。 |
| v12.0.0, v10.20.0 | 追加: v12.0.0, v10.20.0 |
value<bigint>bufに書き込まれる数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えた値。
value をリトルエンディアンとして、指定された offset の buf に書き込みます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeBigUInt64LE(0xdecafafecacefaden, 0)
console.log(buf)
// Prints: <Buffer de fa ce ca fe fa ca de>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(8)
buf.writeBigUInt64LE(0xdecafafecacefaden, 0)
console.log(buf)
// Prints: <Buffer de fa ce ca fe fa ca de>この関数は writeBigUint64LE エイリアスでも利用可能です。
buf.writeDoubleBE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な強制もなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
value<number>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加算したもの。
value をビッグエンディアンとして指定された offset の buf に書き込みます。value は JavaScript の数値である必要があります。value が JavaScript の数値以外の場合、動作は未定義です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeDoubleBE(123.456, 0)
console.log(buf)
// Prints: <Buffer 40 5e dd 2f 1a 9f be 77>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(8)
buf.writeDoubleBE(123.456, 0)
console.log(buf)
// Prints: <Buffer 40 5e dd 2f 1a 9f be 77>buf.writeDoubleLE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な強制もなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
value<number>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 8を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加算したもの。
value をリトルエンディアンとして指定された offset の buf に書き込みます。value は JavaScript の数値である必要があります。value が JavaScript の数値以外の場合、動作は未定義です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeDoubleLE(123.456, 0)
console.log(buf)
// Prints: <Buffer 77 be 9f 1a 2f dd 5e 40>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(8)
buf.writeDoubleLE(123.456, 0)
console.log(buf)
// Prints: <Buffer 77 be 9f 1a 2f dd 5e 40>buf.writeFloatBE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert を削除し、オフセットの uint32 への暗黙的な強制変換もなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
value<number>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加算した値。
value をビッグエンディアンとして指定された offset の位置に buf へ書き込みます。 value が JavaScript の数値以外の場合、動作は未定義です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeFloatBE(0xcafebabe, 0)
console.log(buf)
// Prints: <Buffer 4f 4a fe bb>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeFloatBE(0xcafebabe, 0)
console.log(buf)
// Prints: <Buffer 4f 4a fe bb>buf.writeFloatLE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert を削除し、オフセットの uint32 への暗黙的な強制変換もなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
value<number>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加算した値。
value をリトルエンディアンとして指定された offset の位置に buf へ書き込みます。 value が JavaScript の数値以外の場合、動作は未定義です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeFloatLE(0xcafebabe, 0)
console.log(buf)
// Prints: <Buffer bb fe 4a 4f>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeFloatLE(0xcafebabe, 0)
console.log(buf)
// Prints: <Buffer bb fe 4a 4f>buf.writeInt8(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型強制がなくなりました。 |
| v0.5.0 | 追加: v0.5.0 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 1を満たす必要があります。デフォルト:0。- 戻り値: <integer> 書き込まれたバイト数と
offsetを足した値。
指定された offset の位置に value を buf に書き込みます。value は有効な符号付き 8 ビット整数である必要があります。value が符号付き 8 ビット整数以外の値である場合の動作は未定義です。
value は 2 の補数の符号付き整数として解釈され、書き込まれます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(2)
buf.writeInt8(2, 0)
buf.writeInt8(-2, 1)
console.log(buf)
// Prints: <Buffer 02 fe>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(2)
buf.writeInt8(2, 0)
buf.writeInt8(-2, 1)
console.log(buf)
// Prints: <Buffer 02 fe>buf.writeInt16BE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型強制がなくなりました。 |
| v0.5.5 | 追加: v0.5.5 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト:0。- 戻り値: <integer> 書き込まれたバイト数と
offsetを足した値。
指定された offset の位置に value をビッグエンディアンとして buf に書き込みます。value は有効な符号付き 16 ビット整数である必要があります。value が符号付き 16 ビット整数以外の値である場合の動作は未定義です。
value は 2 の補数の符号付き整数として解釈され、書き込まれます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(2)
buf.writeInt16BE(0x0102, 0)
console.log(buf)
// Prints: <Buffer 01 02>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(2)
buf.writeInt16BE(0x0102, 0)
console.log(buf)
// Prints: <Buffer 01 02>buf.writeInt16LE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な強制変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
value をリトルエンディアンとして、指定された offset で buf に書き込みます。value は有効な符号付き 16 ビット整数でなければなりません。value が符号付き 16 ビット整数以外の値の場合、動作は未定義です。
value は 2 の補数符号付き整数として解釈され、書き込まれます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(2)
buf.writeInt16LE(0x0304, 0)
console.log(buf)
// Prints: <Buffer 04 03>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(2)
buf.writeInt16LE(0x0304, 0)
console.log(buf)
// Prints: <Buffer 04 03>buf.writeInt32BE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な強制変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
value をビッグエンディアンとして、指定された offset で buf に書き込みます。value は有効な符号付き 32 ビット整数でなければなりません。value が符号付き 32 ビット整数以外の値の場合、動作は未定義です。
value は 2 の補数符号付き整数として解釈され、書き込まれます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeInt32BE(0x01020304, 0)
console.log(buf)
// Prints: <Buffer 01 02 03 04>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeInt32BE(0x01020304, 0)
console.log(buf)
// Prints: <Buffer 01 02 03 04>buf.writeInt32LE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、offset の uint32 への暗黙的な型変換がなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
value<integer>bufに書き込まれる数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。 デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
value をリトルエンディアンとして、指定された offset の位置に buf へ書き込みます。 value は有効な符号付き 32 ビット整数でなければなりません。 value が符号付き 32 ビット整数以外の値の場合、動作は未定義です。
value は 2 の補数で符号付き整数として解釈され、書き込まれます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeInt32LE(0x05060708, 0)
console.log(buf)
// Prints: <Buffer 08 07 06 05>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeInt32LE(0x05060708, 0)
console.log(buf)
// Prints: <Buffer 08 07 06 05>buf.writeIntBE(value, offset, byteLength)
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert が削除され、offset と byteLength の uint32 への暗黙的な型変換がなくなりました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
value<integer>bufに書き込まれる数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLengthを満たす必要があります。byteLength<integer> 書き込むバイト数。0 < byteLength <= 6を満たす必要があります。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
value の byteLength バイトをビッグエンディアンとして、指定された offset の位置に buf へ書き込みます。 最大 48 ビットの精度をサポートします。 value が符号付き整数以外の値の場合、動作は未定義です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(6)
buf.writeIntBE(0x1234567890ab, 0, 6)
console.log(buf)
// Prints: <Buffer 12 34 56 78 90 ab>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(6)
buf.writeIntBE(0x1234567890ab, 0, 6)
console.log(buf)
// Prints: <Buffer 12 34 56 78 90 ab>buf.writeIntLE(value, offset, byteLength)
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | noAssert を削除し、オフセットと byteLength の uint32 への暗黙的な型強制を削除しました。 |
| v0.11.15 | v0.11.15 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLengthを満たす必要があります。byteLength<integer> 書き込むバイト数。0 < byteLength <= 6を満たす必要があります。- 戻り値: <integer>
offsetに書き込まれたバイト数を加算したもの。
value の byteLength バイトを、指定された offset の buf にリトルエンディアンとして書き込みます。最大 48 ビットの精度をサポートします。value が符号付き整数以外の場合、動作は未定義です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(6)
buf.writeIntLE(0x1234567890ab, 0, 6)
console.log(buf)
// Prints: <Buffer ab 90 78 56 34 12>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(6)
buf.writeIntLE(0x1234567890ab, 0, 6)
console.log(buf)
// Prints: <Buffer ab 90 78 56 34 12>buf.writeUInt8(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.writeUint8() としても利用可能です。 |
| v10.0.0 | noAssert を削除し、オフセットの uint32 への暗黙的な型強制を削除しました。 |
| v0.5.0 | v0.5.0 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 1を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加算したもの。
指定された offset の buf に value を書き込みます。value は有効な符号なし 8 ビット整数である必要があります。value が符号なし 8 ビット整数以外の場合、動作は未定義です。
この関数は、writeUint8 エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeUInt8(0x3, 0)
buf.writeUInt8(0x4, 1)
buf.writeUInt8(0x23, 2)
buf.writeUInt8(0x42, 3)
console.log(buf)
// Prints: <Buffer 03 04 23 42>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeUInt8(0x3, 0)
buf.writeUInt8(0x4, 1)
buf.writeUInt8(0x23, 2)
buf.writeUInt8(0x42, 3)
console.log(buf)
// Prints: <Buffer 03 04 23 42>buf.writeUInt16BE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数はbuf.writeUint16BE()としても利用可能です。 |
| v10.0.0 | noAssertが削除され、オフセットのuint32への暗黙的な強制型変換がなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
valueをビッグエンディアンとして、指定されたoffsetでbufに書き込みます。valueは有効な符号なし 16 ビット整数である必要があります。valueが符号なし 16 ビット整数以外の場合、動作は未定義です。
この関数はwriteUint16BEエイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeUInt16BE(0xdead, 0)
buf.writeUInt16BE(0xbeef, 2)
console.log(buf)
// Prints: <Buffer de ad be ef>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeUInt16BE(0xdead, 0)
buf.writeUInt16BE(0xbeef, 2)
console.log(buf)
// Prints: <Buffer de ad be ef>buf.writeUInt16LE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数はbuf.writeUint16LE()としても利用可能です。 |
| v10.0.0 | noAssertが削除され、オフセットのuint32への暗黙的な強制型変換がなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 2を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
valueをリトルエンディアンとして、指定されたoffsetでbufに書き込みます。valueは有効な符号なし 16 ビット整数である必要があります。valueが符号なし 16 ビット整数以外の場合、動作は未定義です。
この関数はwriteUint16LEエイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeUInt16LE(0xdead, 0)
buf.writeUInt16LE(0xbeef, 2)
console.log(buf)
// Prints: <Buffer ad de ef be>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeUInt16LE(0xdead, 0)
buf.writeUInt16LE(0xbeef, 2)
console.log(buf)
// Prints: <Buffer ad de ef be>buf.writeUInt32BE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.writeUint32BE() としても利用可能です。 |
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えた値。
value をビッグエンディアンとして、指定された offset の位置に buf に書き込みます。 value は有効な符号なし 32 ビット整数でなければなりません。 value が符号なし 32 ビット整数以外の場合の動作は未定義です。
この関数は writeUint32BE というエイリアスでも利用できます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeUInt32BE(0xfeedface, 0)
console.log(buf)
// Prints: <Buffer fe ed fa ce>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeUInt32BE(0xfeedface, 0)
console.log(buf)
// Prints: <Buffer fe ed fa ce>buf.writeUInt32LE(value[, offset])
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.writeUint32LE() としても利用可能です。 |
| v10.0.0 | noAssert が削除され、オフセットの uint32 への暗黙的な型変換もなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - 4を満たす必要があります。デフォルト:0。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えた値。
value をリトルエンディアンとして、指定された offset の位置に buf に書き込みます。 value は有効な符号なし 32 ビット整数でなければなりません。 value が符号なし 32 ビット整数以外の場合の動作は未定義です。
この関数は writeUint32LE というエイリアスでも利用できます。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeUInt32LE(0xfeedface, 0)
console.log(buf)
// Prints: <Buffer ce fa ed fe>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeUInt32LE(0xfeedface, 0)
console.log(buf)
// Prints: <Buffer ce fa ed fe>buf.writeUIntBE(value, offset, byteLength)
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.writeUintBE() としても利用可能です。 |
| v10.0.0 | noAssert が削除され、offset と byteLength の uint32 への暗黙的な型強制がなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLengthを満たす必要があります。byteLength<integer> 書き込むバイト数。0 < byteLength <= 6を満たす必要があります。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
指定された offset の buf に、value の byteLength バイトをビッグエンディアンで書き込みます。最大 48 ビットの精度をサポートします。value が符号なし整数以外の場合、動作は未定義です。
この関数は writeUintBE エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(6)
buf.writeUIntBE(0x1234567890ab, 0, 6)
console.log(buf)
// Prints: <Buffer 12 34 56 78 90 ab>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(6)
buf.writeUIntBE(0x1234567890ab, 0, 6)
console.log(buf)
// Prints: <Buffer 12 34 56 78 90 ab>buf.writeUIntLE(value, offset, byteLength)
[履歴]
| バージョン | 変更点 |
|---|---|
| v14.9.0, v12.19.0 | この関数は buf.writeUintLE() としても利用可能です。 |
| v10.0.0 | noAssert が削除され、offset と byteLength の uint32 への暗黙的な型強制がなくなりました。 |
| v0.5.5 | v0.5.5 で追加されました。 |
value<integer>bufに書き込む数値。offset<integer> 書き込みを開始する前にスキップするバイト数。0 <= offset <= buf.length - byteLengthを満たす必要があります。byteLength<integer> 書き込むバイト数。0 < byteLength <= 6を満たす必要があります。- 戻り値: <integer>
offsetに書き込まれたバイト数を加えたもの。
指定された offset の buf に、value の byteLength バイトをリトルエンディアンで書き込みます。最大 48 ビットの精度をサポートします。value が符号なし整数以外の場合、動作は未定義です。
この関数は writeUintLE エイリアスでも利用可能です。
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(6)
buf.writeUIntLE(0x1234567890ab, 0, 6)
console.log(buf)
// Prints: <Buffer ab 90 78 56 34 12>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(6)
buf.writeUIntLE(0x1234567890ab, 0, 6)
console.log(buf)
// Prints: <Buffer ab 90 78 56 34 12>new Buffer(array)
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | このコンストラクターをnode_modulesディレクトリ外のコードから呼び出すと、非推奨の警告が表示されます。 |
| v7.2.1 | このコンストラクターを呼び出しても、非推奨の警告が表示されなくなりました。 |
| v7.0.0 | このコンストラクターを呼び出すと、非推奨の警告が表示されるようになりました。 |
| v6.0.0 | 非推奨: v6.0.0 以降 |
[安定版: 0 - 非推奨]
安定版: 0 安定性: 0 - 非推奨: 代わりにBuffer.from(array)を使用してください。
array<integer[]> コピー元のバイトの配列。
Buffer.from(array)を参照してください。
new Buffer(arrayBuffer[, byteOffset[, length]])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | このコンストラクターをnode_modulesディレクトリ外のコードから呼び出すと、非推奨の警告が表示されます。 |
| v7.2.1 | このコンストラクターを呼び出しても、非推奨の警告が表示されなくなりました。 |
| v7.0.0 | このコンストラクターを呼び出すと、非推奨の警告が表示されるようになりました。 |
| v6.0.0 | byteOffsetおよびlengthパラメーターがサポートされるようになりました。 |
| v6.0.0 | 非推奨: v6.0.0 以降 |
| v3.0.0 | 追加: v3.0.0 |
[安定版: 0 - 非推奨]
安定版: 0 安定性: 0 - 非推奨: 代わりにBuffer.from(arrayBuffer[, byteOffset[, length]])を使用してください。
arrayBuffer<ArrayBuffer> | <SharedArrayBuffer>ArrayBuffer、SharedArrayBuffer、またはTypedArrayの.bufferプロパティ。byteOffset<integer> 公開する最初のバイトのインデックス。デフォルト:0。length<integer> 公開するバイト数。デフォルト:arrayBuffer.byteLength - byteOffset。
Buffer.from(arrayBuffer[, byteOffset[, length]])を参照してください。
new Buffer(buffer)
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | このコンストラクターをnode_modulesディレクトリ外のコードから実行すると、非推奨の警告が発生します。 |
| v7.2.1 | このコンストラクターを呼び出しても、非推奨の警告は発生しなくなりました。 |
| v7.0.0 | このコンストラクターを呼び出すと、非推奨の警告が発生するようになりました。 |
| v6.0.0 | 非推奨: v6.0.0 以降 |
[安定性: 0 - 非推奨]
安定性: 0 安定性: 0 - 非推奨: 代わりにBuffer.from(buffer)を使用してください。
buffer<Buffer> | <Uint8Array> データコピー元の既存のBufferまたはUint8Array。
Buffer.from(buffer)を参照してください。
new Buffer(size)
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | このコンストラクターをnode_modulesディレクトリ外のコードから実行すると、非推奨の警告が発生します。 |
| v8.0.0 | new Buffer(size)はデフォルトでゼロで埋められたメモリを返します。 |
| v7.2.1 | このコンストラクターを呼び出しても、非推奨の警告は発生しなくなりました。 |
| v7.0.0 | このコンストラクターを呼び出すと、非推奨の警告が発生するようになりました。 |
| v6.0.0 | 非推奨: v6.0.0 以降 |
[安定性: 0 - 非推奨]
安定性: 0 安定性: 0 - 非推奨: 代わりにBuffer.alloc()を使用してください（Buffer.allocUnsafe()も参照）。
size<integer> 新しいBufferの目的の長さ。
Buffer.alloc()とBuffer.allocUnsafe()を参照してください。 このコンストラクターのバリアントはBuffer.alloc()と同等です。
new Buffer(string[, encoding])
[履歴]
| バージョン | 変更点 |
|---|---|
| v10.0.0 | このコンストラクターを node_modules ディレクトリ外のコードから実行すると、非推奨の警告が発せられます。 |
| v7.2.1 | このコンストラクターの呼び出しで非推奨の警告が発せられなくなりました。 |
| v7.0.0 | このコンストラクターの呼び出しで非推奨の警告が発せられるようになりました。 |
| v6.0.0 | 非推奨: v6.0.0 以降 |
[安定版: 0 - 非推奨]
安定版: 0 安定度: 0 - 非推奨: 代わりにBuffer.from(string[, encoding])を使用してください。
Buffer.from(string[, encoding]) を参照してください。
クラス: File
[履歴]
| バージョン | 変更点 |
|---|---|
| v23.0.0 | File インスタンスをクローン可能にします。 |
| v20.0.0 | 実験的ではなくなりました。 |
| v19.2.0, v18.13.0 | 追加: v19.2.0, v18.13.0 |
- 拡張: <Blob>
File は、ファイルに関する情報を提供します。
new buffer.File(sources, fileName[, options])
追加: v19.2.0, v18.13.0
sources<string[]> | <ArrayBuffer[]> | <TypedArray[]> | <DataView[]> | <Blob[]> | <File[]> 文字列、<ArrayBuffer>、<TypedArray>、<DataView>、<File>、または<Blob>オブジェクト、あるいはそのようなオブジェクトの任意の組み合わせの配列。これらはFile内に保存されます。fileName<string> ファイルの名前。options<Object>
file.name
追加: v19.2.0, v18.13.0
- 型: <string>
Fileの名前。
file.lastModified
追加: v19.2.0, v18.13.0
- 型: <number>
Fileの最終変更日。
node:buffer モジュール API
Bufferオブジェクトはグローバルとして利用できますが、Buffer関連の追加 API は、require('node:buffer')を使用してアクセスするnode:bufferモジュール経由でのみ利用可能です。
buffer.atob(data)
追加: v15.13.0, v14.17.0
data<any> Base64 エンコードされた入力文字列。
Base64 エンコードされたデータの文字列をバイトにデコードし、それらのバイトを Latin-1（ISO-8859-1）を使用して文字列にエンコードします。
dataは、文字列に強制変換できる任意の JavaScript 値です。
この関数は、レガシー Web プラットフォーム API との互換性のためにのみ提供されており、新しいコードでは決して使用すべきではありません。JavaScript で型付き配列が導入される前は、バイナリデータを表現するために文字列を使用していたためです。Node.js API を使用して実行するコードの場合、base64 エンコードされた文字列とバイナリデータ間の変換は、Buffer.from(str, 'base64') および buf.toString('base64') を使用して実行する必要があります。
buffer.btoa(data)
追加: v15.13.0, v14.17.0
data<any> ASCII (Latin1) 文字列。
Latin-1 (ISO-8859) を使用して文字列をバイトにデコードし、それらのバイトを Base64 を使用して文字列にエンコードします。
dataは、文字列に強制変換できる任意の JavaScript 値です。
この関数は、レガシー Web プラットフォーム API との互換性のためにのみ提供されており、新しいコードでは決して使用すべきではありません。JavaScript で型付き配列が導入される前は、バイナリデータを表現するために文字列を使用していたためです。Node.js API を使用して実行するコードの場合、base64 エンコードされた文字列とバイナリデータ間の変換は、Buffer.from(str, 'base64') および buf.toString('base64') を使用して実行する必要があります。
buffer.isAscii(input)
追加: v19.6.0, v18.15.0
- input <Buffer> | <ArrayBuffer> | <TypedArray> 検証する入力。
- 戻り値: <boolean>
この関数は、input が空の場合も含め、input に有効な ASCII エンコードデータのみが含まれている場合に true を返します。
input がデタッチされた ArrayBuffer の場合、エラーがスローされます。
buffer.isUtf8(input)
追加: v19.4.0, v18.14.0
- input <Buffer> | <ArrayBuffer> | <TypedArray> 検証する入力。
- 戻り値: <boolean>
この関数は、input が空の場合も含め、input に有効な UTF-8 エンコードデータのみが含まれている場合に true を返します。
input がデタッチされた ArrayBuffer の場合、エラーがスローされます。
buffer.INSPECT_MAX_BYTES
追加: v0.5.4
- <integer> デフォルト:
50
buf.inspect() が呼び出されたときに返される最大バイト数を返します。これはユーザーモジュールで上書きできます。buf.inspect() の動作の詳細については、util.inspect() を参照してください。
buffer.kMaxLength
追加: v3.0.0
- <integer> 単一の
Bufferインスタンスに許可される最大のサイズ。
buffer.constants.MAX_LENGTH のエイリアス。
buffer.kStringMaxLength
追加: v3.0.0
- <integer> 単一の
stringインスタンスに許可される最大の長さ。
buffer.constants.MAX_STRING_LENGTH のエイリアス。
buffer.resolveObjectURL(id)
追加: v16.7.0
以前の URL.createObjectURL() の呼び出しを使用して登録された、関連付けられた<Blob> オブジェクトの 'blob:nodedata:...' を解決します。
buffer.transcode(source, fromEnc, toEnc)
[履歴]
| バージョン | 変更 |
|---|---|
| v8.0.0 | source パラメーターが Uint8Array になりました。 |
| v7.1.0 | 追加: v7.1.0 |
source<Buffer> | <Uint8Array>BufferまたはUint8Arrayインスタンス。fromEnc<string> 現在のエンコーディング。toEnc<string> ターゲットのエンコーディング。- 戻り値: <Buffer>
指定された Buffer または Uint8Array インスタンスを、ある文字エンコーディングから別の文字エンコーディングに再エンコードします。新しい Buffer インスタンスを返します。
fromEnc または toEnc が無効な文字エンコーディングを指定した場合、または fromEnc から toEnc への変換が許可されていない場合は、例外をスローします。
buffer.transcode() でサポートされるエンコーディングは、'ascii'、'utf8'、'utf16le'、'ucs2'、'latin1'、および 'binary' です。
トランスコード処理では、特定のバイトシーケンスをターゲットエンコーディングで適切に表現できない場合、代替文字が使用されます。例：
import { Buffer, transcode } from 'node:buffer'
const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Prints: '?'const { Buffer, transcode } = require('node:buffer')
const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// Prints: '?'ユーロ (€) 記号は US-ASCII で表現できないため、トランスコードされた Buffer では ? に置き換えられます。
クラス: SlowBuffer
非推奨: v6.0.0 以降
[安定度: 0 - 非推奨]
安定度: 0 安定度: 0 - 非推奨: 代わりに Buffer.allocUnsafeSlow() を使用してください。
Buffer.allocUnsafeSlow() を参照してください。これは、コンストラクターが常に SlowBuffer インスタンスではなく Buffer インスタンスを返していたという意味で、クラスではありませんでした。
new SlowBuffer(size)
非推奨: v6.0.0 以降
[安定度: 0 - 非推奨]
安定度: 0 安定度: 0 - 非推奨: 代わりに Buffer.allocUnsafeSlow() を使用してください。
size<整数> 新しいSlowBufferの目的の長さ。
Buffer.allocUnsafeSlow() を参照してください。
Buffer 定数
追加: v8.2.0
buffer.constants.MAX_LENGTH
[履歴]
| バージョン | 変更 |
|---|---|
| v22.0.0 | 64 ビットアーキテクチャでは値が 231 - 1 に変更されました。 |
| v15.0.0 | 64 ビットアーキテクチャでは値が 231 に変更されました。 |
| v14.0.0 | 64 ビットアーキテクチャでは値が 230 - 1 から 231 - 1 に変更されました。 |
| v8.2.0 | 追加: v8.2.0 |
- <整数> 単一の
Bufferインスタンスで許可される最大サイズ。
32 ビットアーキテクチャでは、この値は現在 230 - 1 (約 1 GiB) です。
64 ビットアーキテクチャでは、この値は現在 240 - 1 (約 8 PiB) です。
これは、内部的には v8::TypedArray::kMaxLength を反映しています。
この値は buffer.kMaxLength としても利用できます。
buffer.constants.MAX_STRING_LENGTH
追加: v8.2.0
- <整数> 単一の
stringインスタンスで許可される最大長。
UTF-16 コードユニットで数えた、string プリミティブが持つことができる最大の length を表します。
この値は、使用されている JS エンジンによって異なる場合があります。
Buffer.from(), Buffer.alloc(), および Buffer.allocUnsafe()
Node.js の 6.0.0 より前のバージョンでは、Buffer インスタンスは Buffer コンストラクタ関数を使用して作成されていました。この関数は、渡された引数に基づいて、返される Buffer を異なる方法で割り当てていました。
- 最初の引数として数値を
Buffer()に渡すと (例:new Buffer(10))、指定されたサイズの新しいBufferオブジェクトが割り当てられます。Node.js 8.0.0 より前は、このようなBufferインスタンスに割り当てられたメモリは初期化されておらず、機密データが含まれている可能性がありました。このようなBufferインスタンスは、buf.fill(0)を使用するか、Bufferからデータを読み取る前にBuffer全体に書き込むことによって、後で初期化する必要がありました。この動作はパフォーマンスを向上させるための意図的なものですが、開発経験から、高速だが初期化されていないBufferの作成と、低速だがより安全なBufferの作成との間に、より明確な区別が必要であることが示されています。Node.js 8.0.0 以降、Buffer(num)およびnew Buffer(num)は初期化されたメモリを持つBufferを返します。 - 最初の引数として文字列、配列、または
Bufferを渡すと、渡されたオブジェクトのデータがBufferにコピーされます。 ArrayBufferまたはSharedArrayBufferを渡すと、指定された配列バッファと割り当てられたメモリを共有するBufferが返されます。
new Buffer() の動作は最初の引数の型によって異なるため、引数の検証や Buffer の初期化が行われない場合、セキュリティおよび信頼性の問題が意図せずアプリケーションに導入される可能性があります。
たとえば、攻撃者が文字列が期待される場所で数値をアプリケーションに受信させることができた場合、アプリケーションは new Buffer("100") の代わりに new Buffer(100) を呼び出して、内容 "100" の 3 バイトバッファを割り当てる代わりに、100 バイトバッファを割り当てる可能性があります。これは、JSON API 呼び出しを使用すると一般的に可能です。JSON は数値型と文字列型を区別するため、入力を十分に検証しない単純に記述されたアプリケーションが常に文字列を受信することを期待している可能性のある場所に数値を注入できます。Node.js 8.0.0 より前では、100 バイトバッファに任意の既存のメモリ内データが含まれている可能性があり、メモリ内の秘密をリモートの攻撃者に公開するために使用される可能性がありました。Node.js 8.0.0 以降では、データがゼロ埋めされるため、メモリの公開は発生しません。ただし、サーバーが非常に大きなバッファを割り当てるようにして、パフォーマンスの低下やメモリ枯渇によるクラッシュを引き起こすなど、他の攻撃も可能です。
Buffer インスタンスの作成をより信頼性が高く、エラーが発生しにくくするために、new Buffer() コンストラクタのさまざまな形式は非推奨となり、個別の Buffer.from()、Buffer.alloc()、および Buffer.allocUnsafe() メソッドに置き換えられました。
開発者は、new Buffer() コンストラクタの既存の使用箇所をすべて これらの新しい API のいずれかに移行する必要があります。
Buffer.from(array)は、提供されたオクテットのコピーを含む新しいBufferを返します。Buffer.from(arrayBuffer[, byteOffset[, length]])は、指定されたArrayBufferと同じ割り当てられたメモリを共有する新しいBufferを返します。Buffer.from(buffer)は、指定されたBufferの内容のコピーを含む新しいBufferを返します。Buffer.from(string[, encoding])は、提供された文字列のコピーを含む新しいBufferを返します。Buffer.alloc(size[, fill[, encoding]])は、指定されたサイズの新しい初期化されたBufferを返します。このメソッドはBuffer.allocUnsafe(size)よりも遅いですが、新しく作成されたBufferインスタンスに、潜在的に機密性のある古いデータが絶対に含まれないことを保証します。sizeが数値でない場合、TypeErrorがスローされます。Buffer.allocUnsafe(size)およびBuffer.allocUnsafeSlow(size)は、それぞれ指定されたsizeの新しい初期化されていないBufferを返します。Bufferは初期化されていないため、割り当てられたメモリセグメントに、潜在的に機密性のある古いデータが含まれている可能性があります。
Buffer.allocUnsafe()、Buffer.from(string)、Buffer.concat()、および Buffer.from(array) によって返される Buffer インスタンスは、size が Buffer.poolSize の半分以下の場合、共有内部メモリプールから割り当てられる可能性があります。Buffer.allocUnsafeSlow() によって返されるインスタンスは、共有内部メモリプールを決して使用しません。
--zero-fill-buffers コマンドラインオプション
追加: v5.10.0
Node.js は、--zero-fill-buffers コマンドラインオプションを使用して起動できます。これにより、新しく割り当てられたすべての Buffer インスタンスが、デフォルトで作成時にゼロフィルされます。このオプションがない場合、Buffer.allocUnsafe()、Buffer.allocUnsafeSlow()、および new SlowBuffer(size) で作成されたバッファはゼロフィルされません。このフラグを使用すると、パフォーマンスに測定可能な悪影響を与える可能性があります。--zero-fill-buffers オプションは、新しく割り当てられた Buffer インスタンスに、機密性の高い可能性のある古いデータが含まれないように強制する必要がある場合にのみ使用してください。
$ node --zero-fill-buffers
> Buffer.allocUnsafe(5);
<Buffer 00 00 00 00 00>なぜ Buffer.allocUnsafe() と Buffer.allocUnsafeSlow() は「安全でない」のですか？
Buffer.allocUnsafe() と Buffer.allocUnsafeSlow() を呼び出すと、割り当てられたメモリのセグメントは初期化されていません (ゼロにされていません)。この設計によりメモリの割り当てが非常に高速になりますが、割り当てられたメモリのセグメントには、機密性の高い可能性のある古いデータが含まれている可能性があります。Buffer.allocUnsafe() で作成された Buffer を、メモリを完全に上書きせずに使用すると、Buffer メモリが読み込まれるときにこの古いデータが漏洩する可能性があります。
Buffer.allocUnsafe() を使用することには明らかなパフォーマンス上の利点がありますが、アプリケーションにセキュリティの脆弱性をもたらすことを避けるために、特別な注意を払う必要があります。