Buffer
[Stable: 2 - Stable]
Stable: 2 Stability: 2 - Stable
Source Code: lib/buffer.js
Buffer 객체는 고정 길이의 바이트 시퀀스를 나타내는 데 사용됩니다. 많은 Node.js API가 Buffer를 지원합니다.
Buffer 클래스는 JavaScript의 Uint8Array 클래스의 하위 클래스이며 추가적인 사용 사례를 다루는 메서드로 확장됩니다. Node.js API는 Buffer가 지원되는 곳이라면 일반 Uint8Array도 허용합니다.
Buffer 클래스는 전역 범위 내에서 사용할 수 있지만, import 또는 require 문을 통해 명시적으로 참조하는 것이 좋습니다.
import { Buffer } from 'node:buffer'
// 길이가 10인 0으로 채워진 Buffer를 생성합니다.
const buf1 = Buffer.alloc(10)
// 길이가 10인 Buffer를 생성하고,
// 모든 바이트의 값이 `1`인 것으로 채웁니다.
const buf2 = Buffer.alloc(10, 1)
// 길이가 10인 초기화되지 않은 버퍼를 생성합니다.
// 이것은 Buffer.alloc()을 호출하는 것보다 빠르지만, 반환된
// Buffer 인스턴스에는 덮어써야 하는 이전 데이터가 포함될 수 있습니다.
// fill(), write() 또는 버퍼 내용을 채우는 다른 함수를 사용하여 덮어써야 합니다.
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인 0으로 채워진 Buffer를 생성합니다.
const buf1 = Buffer.alloc(10)
// 길이가 10인 Buffer를 생성하고,
// 모든 바이트의 값이 `1`인 것으로 채웁니다.
const buf2 = Buffer.alloc(10, 1)
// 길이가 10인 초기화되지 않은 버퍼를 생성합니다.
// 이것은 Buffer.alloc()을 호출하는 것보다 빠르지만, 반환된
// Buffer 인스턴스에는 덮어써야 하는 이전 데이터가 포함될 수 있습니다.
// fill(), write() 또는 버퍼 내용을 채우는 다른 함수를 사용하여 덮어써야 합니다.
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'): 다중 바이트로 인코딩된 유니코드 문자. 많은 웹 페이지 및 기타 문서 형식에서 UTF-8을 사용합니다. 이는 기본 문자 인코딩입니다. 유효한 UTF-8 데이터만 포함하지 않는Buffer를 문자열로 디코딩할 때 유니코드 대체 문자U+FFFD�가 해당 오류를 나타내는 데 사용됩니다.'utf16le'(별칭:'utf-16le'): 다중 바이트로 인코딩된 유니코드 문자.'utf8'과 달리 문자열의 각 문자는 2바이트 또는 4바이트를 사용하여 인코딩됩니다. Node.js는 UTF-16의 리틀 엔디언 변형만 지원합니다.'latin1': Latin-1은 ISO-8859-1을 의미합니다. 이 문자 인코딩은U+0000에서U+00FF까지의 유니코드 문자만 지원합니다. 각 문자는 단일 바이트를 사용하여 인코딩됩니다. 해당 범위에 맞지 않는 문자는 잘리고 해당 범위의 문자에 매핑됩니다.
위의 방법 중 하나를 사용하여 Buffer를 문자열로 변환하는 것을 디코딩이라고 하고, 문자열을 Buffer로 변환하는 것을 인코딩이라고 합니다.
Node.js는 다음 바이너리-텍스트 인코딩도 지원합니다. 바이너리-텍스트 인코딩의 경우 명명 규칙이 반대로 됩니다. Buffer를 문자열로 변환하는 것을 일반적으로 인코딩이라고 하고, 문자열을 Buffer로 변환하는 것을 디코딩이라고 합니다.
'base64': Base64 인코딩. 문자열에서Buffer를 생성할 때 이 인코딩은 RFC 4648, 섹션 5에 지정된 "URL 및 파일 이름 안전 알파벳"도 올바르게 허용합니다. base64로 인코딩된 문자열에 포함된 공백 문자(예: 공백, 탭, 줄 바꿈)는 무시됩니다.'base64url': RFC 4648, 섹션 5에 지정된 base64url 인코딩. 문자열에서Buffer를 생성할 때 이 인코딩은 일반 base64로 인코딩된 문자열도 올바르게 허용합니다.Buffer를 문자열로 인코딩할 때 이 인코딩은 패딩을 생략합니다.'hex': 각 바이트를 두 개의 16진수 문자로 인코딩합니다. 짝수 개의 16진수 문자로만 구성되지 않은 문자열을 디코딩할 때 데이터가 잘릴 수 있습니다. 예는 아래를 참조하십시오.
다음 레거시 문자 인코딩도 지원됩니다.
'ascii': 7비트 ASCII 데이터에만 해당합니다. 문자열을Buffer로 인코딩할 때 이는'latin1'을 사용하는 것과 같습니다.Buffer를 문자열로 디코딩할 때 이 인코딩을 사용하면'latin1'로 디코딩하기 전에 각 바이트의 최상위 비트가 추가로 해제됩니다. 일반적으로'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>, 데이터가 한 자릿수('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>, 데이터가 한 자릿수('7')로 끝날 때 데이터가 잘림.
Buffer.from('1634', 'hex')
// 출력 <Buffer 16 34>, 모든 데이터가 표현됨.최신 웹 브라우저는 'latin1'과 'ISO-8859-1'을 모두 'win-1252'로 별칭하는 WHATWG 인코딩 표준을 따릅니다. 즉, http.get()과 같은 작업을 수행할 때 반환된 문자 집합이 WHATWG 사양에 나열된 것 중 하나인 경우 서버가 실제로 '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 인스턴스를 만드는 방법은 두 가지가 있습니다.
TypedArray생성자에Buffer를 전달하면 정수 배열로 해석된Buffer의 내용이 복사되고 대상 유형의 바이트 시퀀스로 해석되지 않습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4])
const uint32array = new Uint32Array(buf)
console.log(uint32array)
// 출력: 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)
// 출력: 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)
// 출력: 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)
// 출력: 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)
// 출력: <Buffer 88 a0>
console.log(buf2)
// 출력: <Buffer 88 13 a0 0f>
arr[1] = 6000
console.log(buf1)
// 출력: <Buffer 88 a0>
console.log(buf2)
// 출력: <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)
// 출력: <Buffer 88 a0>
console.log(buf2)
// 출력: <Buffer 88 13 a0 0f>
arr[1] = 6000
console.log(buf1)
// 출력: <Buffer 88 a0>
console.log(buf2)
// 출력: <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)
// 출력: 16const { Buffer } = require('node:buffer')
const arr = new Uint16Array(20)
const buf = Buffer.from(arr.buffer, 0, 16)
console.log(buf.length)
// 출력: 16Buffer.from()과 TypedArray.from()은 서명과 구현이 다릅니다. 특히 TypedArray 변형은 형식화된 배열의 각 요소에 대해 호출되는 매핑 함수를 두 번째 인수로 허용합니다.
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)
}
// 출력:
// 1
// 2
// 3const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3])
for (const b of buf) {
console.log(b)
}
// 출력:
// 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에 복사됩니다. 각 문자열 부분 내의 일치하지 않는 서로게이트 쌍은 유니코드 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]])
[History]
| 버전 | 변경 사항 |
|---|---|
| v20.0.0 | 잘못된 입력 인수에 대해 ERR_INVALID_ARG_VALUE 대신 ERR_INVALID_ARG_TYPE 또는 ERR_OUT_OF_RANGE를 throw합니다. |
| v15.0.0 | 잘못된 입력 인수에 대해 ERR_INVALID_OPT_VALUE 대신 ERR_INVALID_ARG_VALUE를 throw합니다. |
| v10.0.0 | 0이 아닌 길이의 버퍼를 0 길이의 버퍼로 채우려고 하면 예외가 throw됩니다. |
| v10.0.0 | fill에 잘못된 문자열을 지정하면 예외가 throw됩니다. |
| v8.9.3 | fill에 잘못된 문자열을 지정하면 이제 0으로 채워진 버퍼가 생성됩니다. |
| v5.10.0 | 추가됨: v5.10.0 |
size<정수> 새Buffer의 원하는 길이입니다.fill<문자열> | <Buffer> | <Uint8Array> | <정수> 새Buffer를 미리 채울 값입니다. 기본값:0.encoding<문자열>fill이 문자열인 경우 해당 인코딩입니다. 기본값:'utf8'.- 반환값: <Buffer>
size 바이트의 새 Buffer를 할당합니다. fill이 undefined인 경우 Buffer는 0으로 채워집니다.
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가 throw됩니다.
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가 throw됩니다.
정적 메서드: Buffer.allocUnsafe(size)
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v20.0.0 | 잘못된 입력 인수에 대해 ERR_INVALID_ARG_VALUE 대신 ERR_INVALID_ARG_TYPE 또는 ERR_OUT_OF_RANGE를 throw합니다. |
| v15.0.0 | 잘못된 입력 인수에 대해 ERR_INVALID_OPT_VALUE 대신 ERR_INVALID_ARG_VALUE를 throw합니다. |
| v7.0.0 | 음수의 size를 전달하면 이제 오류가 throw됩니다. |
| v5.10.0 | 추가됨: v5.10.0 |
size 바이트의 새 Buffer를 할당합니다. size가 buffer.constants.MAX_LENGTH보다 크거나 0보다 작으면 ERR_OUT_OF_RANGE가 throw됩니다.
이러한 방식으로 생성된 Buffer 인스턴스의 기본 메모리는 초기화되지 않습니다. 새로 생성된 Buffer의 내용은 알 수 없으며 민감한 데이터를 포함할 수 있습니다. 0으로 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가 throw됩니다.
Buffer 모듈은 Buffer.allocUnsafe(), Buffer.from(array), Buffer.from(string), 및 Buffer.concat()를 사용하여 생성된 새 Buffer 인스턴스의 빠른 할당을 위한 풀로 사용되는 크기 Buffer.poolSize의 내부 Buffer 인스턴스를 미리 할당합니다. 단, size가 Buffer.poolSize \>\>\> 1 (바닥 함수를 사용한 Buffer.poolSize의 절반)보다 작을 경우에만 해당합니다.
이 미리 할당된 내부 메모리 풀의 사용은 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를 throw합니다. |
| v15.0.0 | 잘못된 입력 인수에 대해 ERR_INVALID_OPT_VALUE 대신 ERR_INVALID_ARG_VALUE를 throw합니다. |
| v5.12.0 | 추가됨: v5.12.0 |
size 바이트의 새 Buffer를 할당합니다. size가 buffer.constants.MAX_LENGTH보다 크거나 0보다 작으면 ERR_OUT_OF_RANGE가 throw됩니다. size가 0이면 길이가 0인 Buffer가 생성됩니다.
이 방법으로 생성된 Buffer 인스턴스의 기본 메모리는 초기화되지 않습니다. 새로 생성된 Buffer의 내용은 알 수 없으며 민감한 데이터를 포함할 수 있습니다. buf.fill(0)을 사용하여 이러한 Buffer 인스턴스를 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가 throw됩니다.
정적 메서드: Buffer.byteLength(string[, encoding])
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v7.0.0 | 잘못된 입력을 전달하면 이제 오류가 발생합니다. |
| v5.10.0 | string 매개변수는 이제 모든 TypedArray, DataView 또는 ArrayBuffer가 될 수 있습니다. |
| v0.1.90 | 추가됨: v0.1.90 |
string<문자열> | <Buffer> | <TypedArray> | <DataView> | <ArrayBuffer> | <SharedArrayBuffer> 길이를 계산할 값입니다.encoding<문자열>string이 문자열인 경우 인코딩입니다. 기본값:'utf8'.- 반환값: <정수>
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이면 길이가 0인 새로운 Buffer가 반환됩니다.
totalLength가 제공되지 않으면 list의 Buffer 인스턴스의 길이를 더하여 계산됩니다.
totalLength가 제공되면 부호 없는 정수로 변환됩니다. list의 Buffer의 결합된 길이가 totalLength를 초과하면 결과는 totalLength로 잘립니다. list의 Buffer의 결합된 길이가 totalLength보다 작으면 나머지 공간은 0으로 채워집니다.
import { Buffer } from 'node:buffer'
// 세 개의 `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')
// 세 개의 `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 범위의 바이트 배열을 사용하여 새 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가 throw됩니다.
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<정수> 노출할 첫 번째 바이트의 인덱스. 기본값:0.length<정수> 노출할 바이트 수. 기본값: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)
// 출력: <Buffer 88 13 a0 0f>
// 원래 Uint16Array를 변경하면 Buffer도 변경됩니다.
arr[1] = 6000
console.log(buf)
// 출력: <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)
// 출력: <Buffer 88 13 a0 0f>
// 원래 Uint16Array를 변경하면 Buffer도 변경됩니다.
arr[1] = 6000
console.log(buf)
// 출력: <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)
// 출력: 2const { Buffer } = require('node:buffer')
const ab = new ArrayBuffer(10)
const buf = Buffer.from(ab, 0, 2)
console.log(buf.length)
// 출력: 2arrayBuffer가 ArrayBuffer 또는 SharedArrayBuffer가 아니거나 Buffer.from() 변형에 적합한 다른 유형이 아닌 경우 TypeError가 throw됩니다.
백킹 ArrayBuffer는 TypedArray 뷰의 경계를 넘어서는 메모리 범위를 포함할 수 있다는 것을 기억하는 것이 중요합니다. TypedArray의 buffer 속성을 사용하여 생성된 새 Buffer는 TypedArray의 범위를 넘어 확장될 수 있습니다.
import { Buffer } from 'node:buffer'
const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]) // 4개 요소
const arrB = new Uint8Array(arrA.buffer, 1, 2) // 2개 요소
console.log(arrA.buffer === arrB.buffer) // true
const buf = Buffer.from(arrB.buffer)
console.log(buf)
// 출력: <Buffer 63 64 65 66>const { Buffer } = require('node:buffer')
const arrA = Uint8Array.from([0x63, 0x64, 0x65, 0x66]) // 4개 요소
const arrB = new Uint8Array(arrA.buffer, 1, 2) // 2개 요소
console.log(arrA.buffer === arrB.buffer) // true
const buf = Buffer.from(arrB.buffer)
console.log(buf)
// 출력: <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'))
// 출력: true
console.log(Buffer.isEncoding('hex'))
// 출력: true
console.log(Buffer.isEncoding('utf/8'))
// 출력: false
console.log(Buffer.isEncoding(''))
// 출력: falseconst { Buffer } = require('node:buffer')
console.log(Buffer.isEncoding('utf8'))
// 출력: true
console.log(Buffer.isEncoding('hex'))
// 출력: true
console.log(Buffer.isEncoding('utf/8'))
// 출력: false
console.log(Buffer.isEncoding(''))
// 출력: 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 문자열을 한 바이트씩 `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'))
// 출력: Node.jsconst { Buffer } = require('node:buffer')
// ASCII 문자열을 한 바이트씩 `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'))
// 출력: 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.poolSize보다 작은 Buffer를 할당할 때 버퍼는 기본 ArrayBuffer에서 0 오프셋부터 시작하지 않습니다.
buf.buffer를 사용하여 기본 ArrayBuffer에 직접 액세스할 때 이로 인해 문제가 발생할 수 있습니다. ArrayBuffer의 다른 부분은 Buffer 객체 자체와 관련이 없을 수 있기 때문입니다.
Buffer와 메모리를 공유하는 TypedArray 객체를 생성할 때 일반적인 문제는 이 경우 byteOffset을 올바르게 지정해야 한다는 것입니다.
import { Buffer } from 'node:buffer'
// Create a buffer smaller than `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
// When casting the Node.js Buffer to an Int8Array, use the byteOffset
// to refer only to the part of `nodeBuffer.buffer` that contains the memory
// for `nodeBuffer`.
new Int8Array(nodeBuffer.buffer, nodeBuffer.byteOffset, nodeBuffer.length)const { Buffer } = require('node:buffer')
// Create a buffer smaller than `Buffer.poolSize`.
const nodeBuffer = Buffer.from([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
// When casting the Node.js Buffer to an Int8Array, use the byteOffset
// to refer only to the part of `nodeBuffer.buffer` that contains the memory
// for `nodeBuffer`.
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<정수> 비교를 시작할target내의 오프셋. 기본값:0.targetEnd<정수> 비교를 끝낼target내의 오프셋(포함되지 않음). 기본값:target.length.sourceStart<정수> 비교를 시작할buf내의 오프셋. 기본값:0.sourceEnd<정수> 비교를 끝낼buf내의 오프셋(포함되지 않음). 기본값:buf.length.- 반환값: <정수>
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))
// 출력: 0
console.log(buf1.compare(buf2))
// 출력: -1
console.log(buf1.compare(buf3))
// 출력: -1
console.log(buf2.compare(buf1))
// 출력: 1
console.log(buf2.compare(buf3))
// 출력: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// 출력: [ <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))
// 출력: 0
console.log(buf1.compare(buf2))
// 출력: -1
console.log(buf1.compare(buf3))
// 출력: -1
console.log(buf2.compare(buf1))
// 출력: 1
console.log(buf2.compare(buf3))
// 출력: 1
console.log([buf1, buf2, buf3].sort(Buffer.compare))
// 출력: [ <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))
// 출력: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// 출력: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// 출력: 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))
// 출력: 0
console.log(buf1.compare(buf2, 0, 6, 4))
// 출력: -1
console.log(buf1.compare(buf2, 5, 6, 5))
// 출력: 1targetStart < 0, sourceStart < 0, targetEnd > target.byteLength 또는 sourceEnd > source.byteLength인 경우 ERR_OUT_OF_RANGE가 throw됩니다.
buf.copy(target[, targetStart[, sourceStart[, sourceEnd]]])
추가됨: v0.1.90
target<Buffer> | <Uint8Array> 복사할Buffer또는Uint8Array.targetStart<정수> 쓰기를 시작할target내의 오프셋. 기본값:0.sourceStart<정수> 복사를 시작할buf내의 오프셋. 기본값:0.sourceEnd<정수> 복사를 중지할buf내의 오프셋(포함하지 않음). 기본값:buf.length.- 반환값: <정수> 복사된 바이트 수.
target 메모리 영역이 buf와 겹치는 경우에도 buf의 영역에서 target의 영역으로 데이터를 복사합니다.
TypedArray.prototype.set()은 동일한 작업을 수행하며 Node.js Buffer를 포함한 모든 TypedArray에서 사용할 수 있지만, 함수 인수가 다릅니다.
import { Buffer } from 'node:buffer'
// 두 개의 `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))
// 출력: !!!!!!!!qrst!!!!!!!!!!!!!const { Buffer } = require('node:buffer')
// 두 개의 `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))
// 출력: !!!!!!!!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())
// 출력: 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())
// 출력: efghijghijklmnopqrstuvwxyzbuf.entries()
추가됨: v1.1.0
- 반환값: <Iterator>
buf의 내용에서 [index, byte] 쌍의 반복기를 생성하고 반환합니다.
import { Buffer } from 'node:buffer'
// `Buffer`의 전체 내용을 로깅합니다.
const buf = Buffer.from('buffer')
for (const pair of buf.entries()) {
console.log(pair)
}
// 출력:
// [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)
}
// 출력:
// [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))
// 출력: true
console.log(buf1.equals(buf3))
// 출력: 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))
// 출력: true
console.log(buf1.equals(buf3))
// 출력: falsebuf.fill(value[, offset[, end]][, encoding])
[이력]
| 버전 | 변경 사항 |
|---|---|
| v11.0.0 | ERR_INDEX_OUT_OF_RANGE 대신 ERR_OUT_OF_RANGE를 throw합니다. |
| v10.0.0 | 음수 end 값은 ERR_INDEX_OUT_OF_RANGE 오류를 throw합니다. |
| v10.0.0 | 0이 아닌 길이의 버퍼를 0 길이의 버퍼로 채우려고 하면 예외가 throw됩니다. |
| v10.0.0 | value에 잘못된 문자열을 지정하면 예외가 throw됩니다. |
| v5.7.0 | encoding 매개변수가 지원됩니다. |
| v0.5.0 | 추가됨: v0.5.0 |
value<string> | <Buffer> | <Uint8Array> | <integer>buf를 채울 값입니다. 빈 값(문자열, Uint8Array, Buffer)은0으로 강제 변환됩니다.offset<integer>buf채우기를 시작하기 전에 건너뛸 바이트 수입니다. 기본값:0.end<integer>buf채우기를 중지할 위치(포함되지 않음)입니다. 기본값:buf.length.encoding<string>value가 문자열인 경우value의 인코딩입니다. 기본값:'utf8'.- 반환값: <Buffer>
buf에 대한 참조입니다.
지정된 value로 buf를 채웁니다. offset 및 end가 지정되지 않으면 전체 buf가 채워집니다.
import { Buffer } from 'node:buffer'
// ASCII 문자 'h'로 `Buffer` 채우기
const b = Buffer.allocUnsafe(50).fill('h')
console.log(b.toString())
// 출력: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
// 빈 문자열로 버퍼 채우기
const c = Buffer.allocUnsafe(5).fill('')
console.log(c.fill(''))
// 출력: <Buffer 00 00 00 00 00>const { Buffer } = require('node:buffer')
// ASCII 문자 'h'로 `Buffer` 채우기
const b = Buffer.allocUnsafe(50).fill('h')
console.log(b.toString())
// 출력: hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh
// 빈 문자열로 버퍼 채우기
const c = Buffer.allocUnsafe(5).fill('')
console.log(c.fill(''))
// 출력: <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'))
// 출력: <Buffer c8 a2 c8 a2 c8>const { Buffer } = require('node:buffer')
// UTF-8에서 2바이트를 차지하는 문자로 `Buffer` 채우기
console.log(Buffer.allocUnsafe(5).fill('\u0222'))
// 출력: <Buffer c8 a2 c8 a2 c8>value에 잘못된 문자가 포함되어 있으면 잘립니다. 유효한 채우기 데이터가 남아 있지 않으면 예외가 throw됩니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(5)
console.log(buf.fill('a'))
// 출력: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// 출력: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// 예외를 throw합니다.const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(5)
console.log(buf.fill('a'))
// 출력: <Buffer 61 61 61 61 61>
console.log(buf.fill('aazz', 'hex'))
// 출력: <Buffer aa aa aa aa aa>
console.log(buf.fill('zz', 'hex'))
// 예외를 throw합니다.buf.includes(value[, byteOffset][, encoding])
추가됨: 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'))
// 출력: true
console.log(buf.includes('is'))
// 출력: true
console.log(buf.includes(Buffer.from('a buffer')))
// 출력: true
console.log(buf.includes(97))
// 출력: true (97은 'a'의 10진수 ASCII 값입니다)
console.log(buf.includes(Buffer.from('a buffer example')))
// 출력: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// 출력: true
console.log(buf.includes('this', 4))
// 출력: falseconst { Buffer } = require('node:buffer')
const buf = Buffer.from('this is a buffer')
console.log(buf.includes('this'))
// 출력: true
console.log(buf.includes('is'))
// 출력: true
console.log(buf.includes(Buffer.from('a buffer')))
// 출력: true
console.log(buf.includes(97))
// 출력: true (97은 'a'의 10진수 ASCII 값입니다)
console.log(buf.includes(Buffer.from('a buffer example')))
// 출력: false
console.log(buf.includes(Buffer.from('a buffer example').slice(0, 8)))
// 출력: true
console.log(buf.includes('this', 4))
// 출력: 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<문자열> | <Buffer> | <Uint8Array> | <정수> 검색할 대상.byteOffset<정수>buf에서 검색을 시작할 위치. 음수이면buf의 끝에서부터 오프셋이 계산됩니다. 기본값:0.encoding<문자열>value가 문자열인 경우,buf에서 검색될 문자열의 이진 표현을 결정하는 데 사용되는 인코딩입니다. 기본값:'utf8'.- 반환값: <정수>
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'))
// 출력: 0
console.log(buf.indexOf('is'))
// 출력: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// 출력: 8
console.log(buf.indexOf(97))
// 출력: 8 (97은 'a'의 10진수 ASCII 값입니다)
console.log(buf.indexOf(Buffer.from('a buffer example')))
// 출력: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// 출력: 8
const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')
console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// 출력: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// 출력: 6const { Buffer } = require('node:buffer')
const buf = Buffer.from('this is a buffer')
console.log(buf.indexOf('this'))
// 출력: 0
console.log(buf.indexOf('is'))
// 출력: 2
console.log(buf.indexOf(Buffer.from('a buffer')))
// 출력: 8
console.log(buf.indexOf(97))
// 출력: 8 (97은 'a'의 10진수 ASCII 값입니다)
console.log(buf.indexOf(Buffer.from('a buffer example')))
// 출력: -1
console.log(buf.indexOf(Buffer.from('a buffer example').slice(0, 8)))
// 출력: 8
const utf16Buffer = Buffer.from('\u039a\u0391\u03a3\u03a3\u0395', 'utf16le')
console.log(utf16Buffer.indexOf('\u03a3', 0, 'utf16le'))
// 출력: 4
console.log(utf16Buffer.indexOf('\u03a3', -4, 'utf16le'))
// 출력: 6value가 문자열, 숫자 또는 Buffer가 아니면 이 메서드는 TypeError를 throw합니다. value가 숫자이면 0과 255 사이의 정수인 유효한 바이트 값으로 강제 변환됩니다.
byteOffset이 숫자가 아니면 숫자로 강제 변환됩니다. 강제 변환 결과가 NaN 또는 0이면 전체 버퍼가 검색됩니다. 이 동작은 String.prototype.indexOf()와 일치합니다.
import { Buffer } from 'node:buffer'
const b = Buffer.from('abcdef')
// 유효한 바이트가 아닌 숫자 값을 전달합니다.
// 출력: 2, 99 또는 'c'를 검색하는 것과 같습니다.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))
// NaN 또는 0으로 강제 변환되는 byteOffset을 전달합니다.
// 출력: 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')
// 유효한 바이트가 아닌 숫자 값을 전달합니다.
// 출력: 2, 99 또는 'c'를 검색하는 것과 같습니다.
console.log(b.indexOf(99.9))
console.log(b.indexOf(256 + 99))
// NaN 또는 0으로 강제 변환되는 byteOffset을 전달합니다.
// 출력: 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<문자열> | <Buffer> | <Uint8Array> | <정수> 검색할 대상입니다.byteOffset<정수>buf에서 검색을 시작할 위치입니다. 음수이면buf의 끝에서 오프셋이 계산됩니다. 기본값:buf.length - 1.encoding<문자열>value가 문자열인 경우,buf에서 검색할 문자열의 이진 표현을 결정하는 데 사용되는 인코딩입니다. 기본값:'utf8'.- 반환값: <정수>
buf에서value의 마지막 발생 위치의 인덱스 또는buf에value가 포함되지 않은 경우-1.
buf.indexOf()와 동일하지만 첫 번째 발생 위치가 아니라 value의 마지막 발생 위치를 찾습니다.
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를 throw합니다. 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'
// UTF-8을 사용하여 더 짧은 문자열을 `Buffer`에 씁니다.
const buf = Buffer.alloc(1234)
console.log(buf.length)
// 출력: 1234
buf.write('some string', 0, 'utf8')
console.log(buf.length)
// 출력: 1234const { Buffer } = require('node:buffer')
// UTF-8을 사용하여 더 짧은 문자열을 `Buffer`에 씁니다.
const buf = Buffer.alloc(1234)
console.log(buf.length)
// 출력: 1234
buf.write('some string', 0, 'utf8')
console.log(buf.length)
// 출력: 1234buf.parent
사용 중단됨: v8.0.0
[Stable: 0 - Deprecated]
Stable: 0 Stability: 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<정수> 읽기를 시작하기 전에 건너뛸 바이트 수입니다. 다음 조건을 만족해야 합니다: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))
// 출력: 4294967295nconst { Buffer } = require('node:buffer')
const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])
console.log(buf.readBigUInt64BE(0))
// 출력: 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<정수> 읽기를 시작하기 전에 건너뛸 바이트 수입니다. 다음 조건을 만족해야 합니다: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))
// 출력: 18446744069414584320nconst { Buffer } = require('node:buffer')
const buf = Buffer.from([0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff])
console.log(buf.readBigUInt64LE(0))
// 출력: 18446744069414584320nbuf.readDoubleBE([offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적으로 강제 변환하지 않음 |
| v0.11.15 | 추가됨: v0.11.15 |
지정된 offset 위치의 buf에서 64비트, 빅 엔디언 더블을 읽습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])
console.log(buf.readDoubleBE(0))
// 출력: 8.20788039913184e-304const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])
console.log(buf.readDoubleBE(0))
// 출력: 8.20788039913184e-304buf.readDoubleLE([offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적으로 강제 변환하지 않음 |
| v0.11.15 | 추가됨: v0.11.15 |
지정된 offset 위치의 buf에서 64비트, 리틀 엔디언 더블을 읽습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4, 5, 6, 7, 8])
console.log(buf.readDoubleLE(0))
// 출력: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// 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))
// 출력: 5.447603722011605e-270
console.log(buf.readDoubleLE(1))
// ERR_OUT_OF_RANGE 오류 발생.buf.readFloatBE([offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적으로 강제 변환하지 않음 |
| v0.11.15 | 추가됨: v0.11.15 |
지정된 offset 위치의 buf에서 32비트, 빅 엔디언 부동 소수점 값을 읽습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4])
console.log(buf.readFloatBE(0))
// 출력: 2.387939260590663e-38const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3, 4])
console.log(buf.readFloatBE(0))
// 출력: 2.387939260590663e-38buf.readFloatLE([offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적으로 강제 변환하지 않음 |
| v0.11.15 | 추가됨: v0.11.15 |
지정된 offset 위치의 buf에서 32비트, 리틀 엔디언 부동 소수점 값을 읽습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, 2, 3, 4])
console.log(buf.readFloatLE(0))
// 출력: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// ERR_OUT_OF_RANGE 오류 발생const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, 2, 3, 4])
console.log(buf.readFloatLE(0))
// 출력: 1.539989614439558e-36
console.log(buf.readFloatLE(1))
// ERR_OUT_OF_RANGE 오류 발생buf.readInt8([offset])
[History]
| Version | Changes |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 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))
// 출력: -1
console.log(buf.readInt8(1))
// 출력: 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))
// 출력: -1
console.log(buf.readInt8(1))
// 출력: 5
console.log(buf.readInt8(2))
// ERR_OUT_OF_RANGE 오류 발생.buf.readInt16BE([offset])
[History]
| Version | Changes |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 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))
// 출력: 5const { Buffer } = require('node:buffer')
const buf = Buffer.from([0, 5])
console.log(buf.readInt16BE(0))
// 출력: 5buf.readInt16LE([offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적으로 강제 변환하지 않음 |
| v0.5.5 | 추가됨: v0.5.5 |
지정된 offset 위치의 buf에서 부호가 있는 리틀 엔디언 16비트 정수를 읽습니다.
Buffer에서 읽은 정수는 2의 보수 부호 있는 값으로 해석됩니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0, 5])
console.log(buf.readInt16LE(0))
// 출력: 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))
// 출력: 1280
console.log(buf.readInt16LE(1))
// ERR_OUT_OF_RANGE 오류 발생.buf.readInt32BE([offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적으로 강제 변환하지 않음 |
| v0.5.5 | 추가됨: v0.5.5 |
지정된 offset 위치의 buf에서 부호가 있는 빅 엔디언 32비트 정수를 읽습니다.
Buffer에서 읽은 정수는 2의 보수 부호 있는 값으로 해석됩니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0, 0, 0, 5])
console.log(buf.readInt32BE(0))
// 출력: 5const { Buffer } = require('node:buffer')
const buf = Buffer.from([0, 0, 0, 5])
console.log(buf.readInt32BE(0))
// 출력: 5buf.readInt32LE([offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 변환 제거 |
| v0.5.5 | 추가: v0.5.5 |
지정된 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)
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset과 byteLength의 암시적 uint32 변환 제거 |
| v0.11.15 | 추가: v0.11.15 |
offset<정수> 읽기를 시작하기 전에 건너뛸 바이트 수.0 <= offset <= buf.length - byteLength를 만족해야 합니다.byteLength<정수> 읽을 바이트 수.0 < byteLength <= 6을 만족해야 합니다.- 반환값: <정수>
지정된 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)
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset 및 byteLength의 암시적 uint32 강제 변환 제거 |
| v0.11.15 | 추가: v0.11.15 |
offset<정수> 읽기를 시작하기 전에 건너뛸 바이트 수.0 \<= offset \<= buf.length - byteLength를 만족해야 함.byteLength<정수> 읽을 바이트 수.0 \< byteLength \<= 6을 만족해야 함.- 반환값: <정수>
지정된 offset에서 buf로부터 byteLength 바이트 수를 읽고 최대 48비트 정확도를 지원하는 리틀 엔디언, 투의 보수 부호 있는 값으로 해석합니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readIntLE(0, 6).toString(16))
// 출력: -546f87a9cbeeconst { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readIntLE(0, 6).toString(16))
// 출력: -546f87a9cbeebuf.readUInt8([offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v14.9.0, v12.19.0 | 이 함수는 buf.readUint8()로도 사용 가능합니다. |
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 강제 변환 제거 |
| v0.5.0 | 추가: v0.5.0 |
지정된 offset에서 buf로부터 부호 없는 8비트 정수를 읽습니다.
이 함수는 readUint8 별칭으로도 사용할 수 있습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([1, -2])
console.log(buf.readUInt8(0))
// 출력: 1
console.log(buf.readUInt8(1))
// 출력: 254
console.log(buf.readUInt8(2))
// ERR_OUT_OF_RANGE 오류 발생.const { Buffer } = require('node:buffer')
const buf = Buffer.from([1, -2])
console.log(buf.readUInt8(0))
// 출력: 1
console.log(buf.readUInt8(1))
// 출력: 254
console.log(buf.readUInt8(2))
// ERR_OUT_OF_RANGE 오류 발생.buf.readUInt16BE([offset])
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v14.9.0, v12.19.0 | 이 함수는 buf.readUint16BE()로도 사용 가능합니다. |
| v10.0.0 | noAssert 제거 및 offset을 uint32로의 암시적 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
지정된 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 제거 및 offset을 uint32로의 암시적 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
지정된 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])
[History]
| 버전 | 변경 사항 |
|---|---|
| v14.9.0, v12.19.0 | 이 함수는 buf.readUint32BE()로도 사용 가능합니다. |
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
지정된 offset 위치의 buf에서 부호 없는 큰 엔디안 32비트 정수를 읽습니다.
이 함수는 readUint32BE 별칭으로도 사용할 수 있습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])
console.log(buf.readUInt32BE(0).toString(16))
// 출력: 12345678const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])
console.log(buf.readUInt32BE(0).toString(16))
// 출력: 12345678buf.readUInt32LE([offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v14.9.0, v12.19.0 | 이 함수는 buf.readUint32LE()로도 사용 가능합니다. |
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
지정된 offset 위치의 buf에서 부호 없는 작은 엔디안 32비트 정수를 읽습니다.
이 함수는 readUint32LE 별칭으로도 사용할 수 있습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])
console.log(buf.readUInt32LE(0).toString(16))
// 출력: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// ERR_OUT_OF_RANGE 오류 발생const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78])
console.log(buf.readUInt32LE(0).toString(16))
// 출력: 78563412
console.log(buf.readUInt32LE(1).toString(16))
// ERR_OUT_OF_RANGE 오류 발생buf.readUIntBE(offset, byteLength)
[History]
| 버전 | 변경 사항 |
|---|---|
| v14.9.0, v12.19.0 | 이 함수는 buf.readUintBE()로도 사용할 수 있습니다. |
| v10.0.0 | noAssert 제거 및 offset과 byteLength의 암시적 uint32 강제 변환 제거 |
| v0.11.15 | 추가됨: v0.11.15 |
offset<정수> 읽기를 시작하기 전에 건너뛸 바이트 수.0 <= offset <= buf.length - byteLength를 만족해야 합니다.byteLength<정수> 읽을 바이트 수.0 < byteLength <= 6을 만족해야 합니다.- 반환값: <정수>
지정된 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))
// 출력: 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))
// 출력: 1234567890ab
console.log(buf.readUIntBE(1, 6).toString(16))
// ERR_OUT_OF_RANGE 발생.buf.readUIntLE(offset, byteLength)
[History]
| 버전 | 변경 사항 |
|---|---|
| v14.9.0, v12.19.0 | 이 함수는 buf.readUintLE()로도 사용할 수 있습니다. |
| v10.0.0 | noAssert 제거 및 offset과 byteLength의 암시적 uint32 강제 변환 제거 |
| v0.11.15 | 추가됨: v0.11.15 |
offset<정수> 읽기를 시작하기 전에 건너뛸 바이트 수.0 <= offset <= buf.length - byteLength를 만족해야 합니다.byteLength<정수> 읽을 바이트 수.0 < byteLength <= 6을 만족해야 합니다.- 반환값: <정수>
지정된 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))
// 출력: ab9078563412const { Buffer } = require('node:buffer')
const buf = Buffer.from([0x12, 0x34, 0x56, 0x78, 0x90, 0xab])
console.log(buf.readUIntLE(0, 6).toString(16))
// 출력: ab9078563412buf.subarray([start[, end]])
추가됨: v3.0.0
start<integer> 새로운Buffer가 시작될 위치. 기본값:0.end<integer> 새로운Buffer가 끝나는 위치(포함되지 않음). 기본값:buf.length.- 반환값: <Buffer>
start 및 end 인덱스에 따라 오프셋되고 잘린 원본과 동일한 메모리를 참조하는 새로운 Buffer를 반환합니다.
buf.length보다 큰 end를 지정하면 end가 buf.length와 같은 결과를 반환합니다.
이 메서드는 TypedArray.prototype.subarray()에서 상속됩니다.
새로운 Buffer 슬라이스를 수정하면 두 객체의 할당된 메모리가 겹치기 때문에 원본 Buffer의 메모리가 수정됩니다.
import { Buffer } from 'node:buffer'
// ASCII 알파벳으로 `Buffer`를 생성하고, 슬라이스를 가져와 원본 `Buffer`에서 하나의 바이트를 수정합니다.
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`에서 하나의 바이트를 수정합니다.
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<정수> 새로운Buffer가 시작될 위치입니다. 기본값:0.end<정수> 새로운Buffer가 끝나는 위치(포함되지 않음)입니다. 기본값:buf.length.- 반환값: <Buffer>
[안정성: 0 - 더 이상 사용되지 않음]
안정성: 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())
// 출력: cuffer
console.log(buf.toString())
// 출력: buffer
// buf.slice()를 사용하면 원본 버퍼가 수정됩니다.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// 출력: cuffer
console.log(buf.toString())
// 출력: cuffer (!)const { Buffer } = require('node:buffer')
const buf = Buffer.from('buffer')
const copiedBuf = Uint8Array.prototype.slice.call(buf)
copiedBuf[0]++
console.log(copiedBuf.toString())
// 출력: cuffer
console.log(buf.toString())
// 출력: buffer
// buf.slice()를 사용하면 원본 버퍼가 수정됩니다.
const notReallyCopiedBuf = buf.slice()
notReallyCopiedBuf[0]++
console.log(notReallyCopiedBuf.toString())
// 출력: cuffer
console.log(buf.toString())
// 출력: cuffer (!)buf.swap16()
추가됨: v5.10.0
- 반환값: <Buffer>
buf에 대한 참조
buf를 부호 없는 16비트 정수 배열로 해석하고 바이트 순서를 제자리에서 바꿉니다. buf.length가 2의 배수가 아닌 경우 ERR_INVALID_BUFFER_SIZE를 throw합니다.
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// 출력: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap16()
console.log(buf1)
// 출력: <Buffer 02 01 04 03 06 05 08 07>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap16()
// ERR_INVALID_BUFFER_SIZE throw.const { Buffer } = require('node:buffer')
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// 출력: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap16()
console.log(buf1)
// 출력: <Buffer 02 01 04 03 06 05 08 07>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap16()
// ERR_INVALID_BUFFER_SIZE throw.buf.swap16()의 편리한 용도 중 하나는 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를 throw합니다.
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// 출력: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap32()
console.log(buf1)
// 출력: <Buffer 04 03 02 01 08 07 06 05>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap32()
// ERR_INVALID_BUFFER_SIZE throw.const { Buffer } = require('node:buffer')
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// 출력: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap32()
console.log(buf1)
// 출력: <Buffer 04 03 02 01 08 07 06 05>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap32()
// ERR_INVALID_BUFFER_SIZE throw.buf.swap64()
추가됨: v6.3.0
- 반환값: <Buffer>
buf에 대한 참조
buf를 64비트 숫자의 배열로 해석하고 바이트 순서를 현장에서 바꿉니다. buf.length가 8의 배수가 아닌 경우 ERR_INVALID_BUFFER_SIZE를 throw합니다.
import { Buffer } from 'node:buffer'
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// 출력: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap64()
console.log(buf1)
// 출력: <Buffer 08 07 06 05 04 03 02 01>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap64()
// ERR_INVALID_BUFFER_SIZE 발생.const { Buffer } = require('node:buffer')
const buf1 = Buffer.from([0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8])
console.log(buf1)
// 출력: <Buffer 01 02 03 04 05 06 07 08>
buf1.swap64()
console.log(buf1)
// 출력: <Buffer 08 07 06 05 04 03 02 01>
const buf2 = Buffer.from([0x1, 0x2, 0x3])
buf2.swap64()
// ERR_INVALID_BUFFER_SIZE 발생.buf.toJSON()
추가됨: v0.9.2
- 반환값: <Object>
buf의 JSON 표현을 반환합니다. Buffer 인스턴스를 문자열화할 때 JSON.stringify()가 암시적으로 이 함수를 호출합니다.
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)
// 출력: {"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)
// 출력: <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)
// 출력: {"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)
// 출력: <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'))
// 출력: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// 출력: abcde
const buf2 = Buffer.from('tést')
console.log(buf2.toString('hex'))
// 출력: 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// 출력: té
console.log(buf2.toString(undefined, 0, 3))
// 출력: 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'))
// 출력: abcdefghijklmnopqrstuvwxyz
console.log(buf1.toString('utf8', 0, 5))
// 출력: abcde
const buf2 = Buffer.from('tést')
console.log(buf2.toString('hex'))
// 출력: 74c3a97374
console.log(buf2.toString('utf8', 0, 3))
// 출력: té
console.log(buf2.toString(undefined, 0, 3))
// 출력: 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의 문자 인코딩에 따라 offset 위치의 buf에 string을 씁니다. length 매개변수는 쓸 바이트 수입니다. buf에 문자열 전체를 담을 공간이 충분하지 않으면 string의 일부만 쓰여집니다. 하지만 부분적으로 인코딩된 문자는 쓰여지지 않습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.alloc(256)
const len = buf.write('\u00bd + \u00bc = \u00be', 0)
console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`)
// 출력: 12 bytes: ½ + ¼ = ¾
const buffer = Buffer.alloc(10)
const length = buffer.write('abcd', 8)
console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`)
// 출력: 2 bytes : abconst { Buffer } = require('node:buffer')
const buf = Buffer.alloc(256)
const len = buf.write('\u00bd + \u00bc = \u00be', 0)
console.log(`${len} bytes: ${buf.toString('utf8', 0, len)}`)
// 출력: 12 bytes: ½ + ¼ = ¾
const buffer = Buffer.alloc(10)
const length = buffer.write('abcd', 8)
console.log(`${length} bytes: ${buffer.toString('utf8', 8, 10)}`)
// 출력: 2 bytes : abbuf.writeBigInt64BE(value[, offset])
추가됨: v12.0.0, v10.20.0
value<bigint>buf에 기록할 숫자.offset<integer> 쓰기 시작하기 전에 건너뛸 바이트 수. 다음 조건을 만족해야 함:0 \<= offset \<= buf.length - 8. 기본값:0.- 반환값: <integer>
offset더하기 기록된 바이트 수.
지정된 offset에 big-endian으로 value를 buf에 기록합니다.
value는 2의 보수 부호 있는 정수로 해석되고 기록됩니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeBigInt64BE(0x0102030405060708n, 0)
console.log(buf)
// 출력: <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)
// 출력: <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더하기 기록된 바이트 수.
지정된 offset에 little-endian으로 value를 buf에 기록합니다.
value는 2의 보수 부호 있는 정수로 해석되고 기록됩니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeBigInt64LE(0x0102030405060708n, 0)
console.log(buf)
// 출력: <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)
// 출력: <Buffer 08 07 06 05 04 03 02 01>buf.writeBigUInt64BE(value[, offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| 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와 쓰여진 바이트 수의 합.
빅 엔디안으로 지정된 offset에 value를 buf에 씁니다.
이 함수는 writeBigUint64BE 별칭으로도 사용 가능합니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeBigUInt64BE(0xdecafafecacefaden, 0)
console.log(buf)
// 출력: <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)
// 출력: <Buffer de ca fa fe ca ce fa de>buf.writeBigUInt64LE(value[, offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| 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와 쓰여진 바이트 수의 합.
리틀 엔디안으로 지정된 offset에 value를 buf에 씁니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeBigUInt64LE(0xdecafafecacefaden, 0)
console.log(buf)
// 출력: <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)
// 출력: <Buffer de fa ce ca fe fa ca de>이 함수는 writeBigUint64LE 별칭으로도 사용 가능합니다.
buf.writeDoubleBE(value[, offset])
[History]
| Version | Changes |
|---|---|
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 강제 변환 제거 |
| v0.11.15 | 추가됨: v0.11.15 |
value<number>buf에 쓰여질 숫자.offset<integer> 쓰기 시작하기 전에 건너뛸 바이트 수.0 <= offset <= buf.length - 8을 만족해야 합니다. 기본값:0.- 반환값: <integer>
offset와 쓰여진 바이트 수의 합.
지정된 offset에 big-endian으로 value를 buf에 씁니다. value는 JavaScript 숫자여야 합니다. value가 JavaScript 숫자가 아닌 경우 동작이 정의되지 않습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeDoubleBE(123.456, 0)
console.log(buf)
// 출력: <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)
// 출력: <Buffer 40 5e dd 2f 1a 9f be 77>buf.writeDoubleLE(value[, offset])
[History]
| Version | Changes |
|---|---|
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 강제 변환 제거 |
| v0.11.15 | 추가됨: v0.11.15 |
value<number>buf에 쓰여질 숫자.offset<integer> 쓰기 시작하기 전에 건너뛸 바이트 수.0 <= offset <= buf.length - 8을 만족해야 합니다. 기본값:0.- 반환값: <integer>
offset와 쓰여진 바이트 수의 합.
지정된 offset에 little-endian으로 value를 buf에 씁니다. value는 JavaScript 숫자여야 합니다. value가 JavaScript 숫자가 아닌 경우 동작이 정의되지 않습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(8)
buf.writeDoubleLE(123.456, 0)
console.log(buf)
// 출력: <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)
// 출력: <Buffer 77 be 9f 1a 2f dd 5e 40>buf.writeFloatBE(value[, offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 변환 제거 |
| v0.11.15 | 추가됨: v0.11.15 |
value<number>buf에 쓰일 숫자.offset<integer> 쓰기 시작 전 건너뛸 바이트 수.0 \<= offset \<= buf.length - 4를 만족해야 함. 기본값:0.- 반환값: <integer>
offset와 쓰여진 바이트 수의 합.
value를 지정된 offset에 big-endian으로 buf에 씁니다. value가 JavaScript 숫자 이외의 값일 경우 동작이 정의되지 않습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeFloatBE(0xcafebabe, 0)
console.log(buf)
// 출력: <Buffer 4f 4a fe bb>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeFloatBE(0xcafebabe, 0)
console.log(buf)
// 출력: <Buffer 4f 4a fe bb>buf.writeFloatLE(value[, offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 변환 제거 |
| v0.11.15 | 추가됨: v0.11.15 |
value<number>buf에 쓰일 숫자.offset<integer> 쓰기 시작 전 건너뛸 바이트 수.0 \<= offset \<= buf.length - 4를 만족해야 함. 기본값:0.- 반환값: <integer>
offset와 쓰여진 바이트 수의 합.
value를 지정된 offset에 little-endian으로 buf에 씁니다. value가 JavaScript 숫자 이외의 값일 경우 동작이 정의되지 않습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeFloatLE(0xcafebabe, 0)
console.log(buf)
// 출력: <Buffer bb fe 4a 4f>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeFloatLE(0xcafebabe, 0)
console.log(buf)
// 출력: <Buffer bb fe 4a 4f>buf.writeInt8(value[, offset])
[History]
| Version | Changes |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적 강제 변환 제거 |
| v0.5.0 | 추가됨: v0.5.0 |
value<정수>buf에 쓰여질 숫자.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수.0 \<= offset \<= buf.length - 1을 만족해야 합니다. 기본값:0.- 반환값: <정수>
offset에 쓰여진 바이트 수를 더한 값.
지정된 offset에 buf에 value를 씁니다. 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)
// 출력: <Buffer 02 fe>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(2)
buf.writeInt8(2, 0)
buf.writeInt8(-2, 1)
console.log(buf)
// 출력: <Buffer 02 fe>buf.writeInt16BE(value[, offset])
[History]
| Version | Changes |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
value<정수>buf에 쓰여질 숫자.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수.0 \<= offset \<= buf.length - 2를 만족해야 합니다. 기본값:0.- 반환값: <정수>
offset에 쓰여진 바이트 수를 더한 값.
지정된 offset에 big-endian으로 buf에 value를 씁니다. value는 유효한 16비트 부호 있는 정수여야 합니다. value가 16비트 부호 있는 정수가 아닌 경우 동작이 정의되지 않습니다.
value는 2의 보수 부호 있는 정수로 해석되고 쓰여집니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(2)
buf.writeInt16BE(0x0102, 0)
console.log(buf)
// 출력: <Buffer 01 02>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(2)
buf.writeInt16BE(0x0102, 0)
console.log(buf)
// 출력: <Buffer 01 02>buf.writeInt16LE(value[, offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
value<정수>buf에 쓰여질 숫자.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수.0 \<= offset \<= buf.length - 2를 만족해야 함. 기본값:0.- 반환값: <정수>
offset와 쓰여진 바이트 수의 합.
value를 지정된 offset에 리틀 엔디언으로 buf에 씁니다. value는 유효한 부호 있는 16비트 정수여야 합니다. value가 부호 있는 16비트 정수가 아닌 경우 동작이 정의되지 않습니다.
value는 보수 표현 부호 있는 정수로 해석되고 쓰여집니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(2)
buf.writeInt16LE(0x0304, 0)
console.log(buf)
// 출력: <Buffer 04 03>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(2)
buf.writeInt16LE(0x0304, 0)
console.log(buf)
// 출력: <Buffer 04 03>buf.writeInt32BE(value[, offset])
[History]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset을 uint32로 암시적 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
value<정수>buf에 쓰여질 숫자.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수.0 \<= offset \<= buf.length - 4를 만족해야 함. 기본값:0.- 반환값: <정수>
offset와 쓰여진 바이트 수의 합.
value를 지정된 offset에 빅 엔디언으로 buf에 씁니다. value는 유효한 부호 있는 32비트 정수여야 합니다. value가 부호 있는 32비트 정수가 아닌 경우 동작이 정의되지 않습니다.
value는 보수 표현 부호 있는 정수로 해석되고 쓰여집니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeInt32BE(0x01020304, 0)
console.log(buf)
// 출력: <Buffer 01 02 03 04>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeInt32BE(0x01020304, 0)
console.log(buf)
// 출력: <Buffer 01 02 03 04>buf.writeInt32LE(value[, offset])
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
value<정수>buf에 쓰여질 숫자.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수.0 \<= offset \<= buf.length - 4를 만족해야 함. 기본값:0.- 반환값: <정수>
offset와 쓰여진 바이트 수의 합.
리틀 엔디언으로 지정된 offset에 value를 buf에 씁니다. value는 유효한 부호 있는 32비트 정수여야 합니다. value가 부호 있는 32비트 정수가 아닌 경우 동작이 정의되지 않습니다.
value는 보수 표현 부호 있는 정수로 해석되고 쓰여집니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeInt32LE(0x05060708, 0)
console.log(buf)
// 출력: <Buffer 08 07 06 05>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeInt32LE(0x05060708, 0)
console.log(buf)
// 출력: <Buffer 08 07 06 05>buf.writeIntBE(value, offset, byteLength)
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset과 byteLength의 암시적 uint32 강제 변환 제거 |
| v0.11.15 | 추가됨: v0.11.15 |
value<정수>buf에 쓰여질 숫자.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수.0 \<= offset \<= buf.length - byteLength를 만족해야 함.byteLength<정수> 쓸 바이트 수.0 \< byteLength \<= 6을 만족해야 함.- 반환값: <정수>
offset와 쓰여진 바이트 수의 합.
빅 엔디언으로 지정된 offset에 value의 byteLength 바이트를 buf에 씁니다. 최대 48비트의 정확도를 지원합니다. value가 부호 있는 정수가 아닌 경우 동작이 정의되지 않습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(6)
buf.writeIntBE(0x1234567890ab, 0, 6)
console.log(buf)
// 출력: <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)
// 출력: <Buffer 12 34 56 78 90 ab>buf.writeIntLE(value, offset, byteLength)
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | noAssert 제거 및 offset 및 byteLength의 암시적 강제 변환을 uint32로 더 이상 수행하지 않음 |
| v0.11.15 | 추가됨: v0.11.15 |
value<정수>buf에 쓰여질 숫자.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수.0 <= offset <= buf.length - byteLength를 만족해야 함.byteLength<정수> 쓸 바이트 수.0 < byteLength <= 6을 만족해야 함.- 반환값: <정수>
offset와 쓰여진 바이트 수의 합.
지정된 offset에 리틀 엔디언으로 value의 byteLength 바이트를 buf에 씁니다. 최대 48비트의 정확도를 지원합니다. value가 부호 있는 정수가 아닌 경우 동작이 정의되지 않습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(6)
buf.writeIntLE(0x1234567890ab, 0, 6)
console.log(buf)
// 출력: <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)
// 출력: <Buffer ab 90 78 56 34 12>buf.writeUInt8(value[, offset])
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v14.9.0, v12.19.0 | 이 함수는 buf.writeUint8()로도 사용 가능합니다. |
| v10.0.0 | noAssert 제거 및 offset의 암시적 강제 변환을 uint32로 더 이상 수행하지 않음 |
| v0.5.0 | 추가됨: v0.5.0 |
value<정수>buf에 쓰여질 숫자.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수.0 <= offset <= buf.length - 1을 만족해야 함. 기본값:0.- 반환값: <정수>
offset와 쓰여진 바이트 수의 합.
지정된 offset에 value를 buf에 씁니다. 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)
// 출력: <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)
// 출력: <Buffer 03 04 23 42>buf.writeUInt16BE(value[, offset])
[History]
| Version | Changes |
|---|---|
| v14.9.0, v12.19.0 | buf.writeUint16BE()로도 사용 가능합니다. |
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
value<integer>buf에 쓰여질 숫자.offset<integer> 쓰기 시작하기 전에 건너뛸 바이트 수.0 \<= offset \<= buf.length - 2를 만족해야 합니다. 기본값:0.- 반환값: <integer>
offset더하기 쓰여진 바이트 수.
지정된 offset에 big-endian으로 value를 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)
// 출력: <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)
// 출력: <Buffer de ad be ef>buf.writeUInt16LE(value[, offset])
[History]
| Version | Changes |
|---|---|
| v14.9.0, v12.19.0 | buf.writeUint16LE()로도 사용 가능합니다. |
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 강제 변환 제거 |
| v0.5.5 | 추가됨: v0.5.5 |
value<integer>buf에 쓰여질 숫자.offset<integer> 쓰기 시작하기 전에 건너뛸 바이트 수.0 \<= offset \<= buf.length - 2를 만족해야 합니다. 기본값:0.- 반환값: <integer>
offset더하기 쓰여진 바이트 수.
지정된 offset에 little-endian으로 value를 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)
// 출력: <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)
// 출력: <Buffer ad de ef be>buf.writeUInt32BE(value[, offset])
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v14.9.0, v12.19.0 | 이 함수는 buf.writeUint32BE()로도 사용 가능합니다. |
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 강제 변환 제거 |
| v0.5.5 | 추가: v0.5.5 |
value<정수>buf에 기록할 숫자입니다.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수입니다.0 \<= offset \<= buf.length - 4를 만족해야 합니다. 기본값:0.- 반환값: <정수>
offset와 기록된 바이트 수의 합입니다.
빅 엔디언으로 지정된 offset에 value를 buf에 기록합니다. value는 유효한 부호 없는 32비트 정수여야 합니다. value가 부호 없는 32비트 정수가 아닌 경우 동작이 정의되지 않습니다.
이 함수는 writeUint32BE 별칭으로도 사용할 수 있습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeUInt32BE(0xfeedface, 0)
console.log(buf)
// 출력: <Buffer fe ed fa ce>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeUInt32BE(0xfeedface, 0)
console.log(buf)
// 출력: <Buffer fe ed fa ce>buf.writeUInt32LE(value[, offset])
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v14.9.0, v12.19.0 | 이 함수는 buf.writeUint32LE()로도 사용 가능합니다. |
| v10.0.0 | noAssert 제거 및 offset의 암시적 uint32 강제 변환 제거 |
| v0.5.5 | 추가: v0.5.5 |
value<정수>buf에 기록할 숫자입니다.offset<정수> 쓰기 시작하기 전에 건너뛸 바이트 수입니다.0 \<= offset \<= buf.length - 4를 만족해야 합니다. 기본값:0.- 반환값: <정수>
offset와 기록된 바이트 수의 합입니다.
리틀 엔디언으로 지정된 offset에 value를 buf에 기록합니다. value는 유효한 부호 없는 32비트 정수여야 합니다. value가 부호 없는 32비트 정수가 아닌 경우 동작이 정의되지 않습니다.
이 함수는 writeUint32LE 별칭으로도 사용할 수 있습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(4)
buf.writeUInt32LE(0xfeedface, 0)
console.log(buf)
// 출력: <Buffer ce fa ed fe>const { Buffer } = require('node:buffer')
const buf = Buffer.allocUnsafe(4)
buf.writeUInt32LE(0xfeedface, 0)
console.log(buf)
// 출력: <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<정수>buf에 기록할 숫자입니다.offset<정수> 쓰기를 시작하기 전에 건너뛸 바이트 수입니다.0 \<= offset \<= buf.length - byteLength를 만족해야 합니다.byteLength<정수> 쓸 바이트 수입니다.0 \< byteLength \<= 6을 만족해야 합니다.- 반환값: <정수>
offset에 기록된 바이트 수를 더한 값입니다.
지정된 offset에 big-endian으로 value의 byteLength 바이트를 buf에 씁니다. 최대 48비트의 정확도를 지원합니다. value가 부호 없는 정수가 아닌 경우 동작이 정의되지 않습니다.
이 함수는 writeUintBE 별칭으로도 사용할 수 있습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(6)
buf.writeUIntBE(0x1234567890ab, 0, 6)
console.log(buf)
// 출력: <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)
// 출력: <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<정수>buf에 기록할 숫자입니다.offset<정수> 쓰기를 시작하기 전에 건너뛸 바이트 수입니다.0 \<= offset \<= buf.length - byteLength를 만족해야 합니다.byteLength<정수> 쓸 바이트 수입니다.0 \< byteLength \<= 6을 만족해야 합니다.- 반환값: <정수>
offset에 기록된 바이트 수를 더한 값입니다.
지정된 offset에 little-endian으로 value의 byteLength 바이트를 buf에 씁니다. 최대 48비트의 정확도를 지원합니다. value가 부호 없는 정수가 아닌 경우 동작이 정의되지 않습니다.
이 함수는 writeUintLE 별칭으로도 사용할 수 있습니다.
import { Buffer } from 'node:buffer'
const buf = Buffer.allocUnsafe(6)
buf.writeUIntLE(0x1234567890ab, 0, 6)
console.log(buf)
// 출력: <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)
// 출력: <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 Stability: 0 - 사용 중단: Buffer.from(array)를 대신 사용하십시오.
array<integer[]> 복사할 바이트의 배열입니다.
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 Stability: 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 Stability: 0 - 사용 중지: Buffer.from(buffer)를 대신 사용하십시오.
buffer<Buffer> | <Uint8Array> 데이터를 복사할 기존Buffer또는Uint8Array.
new Buffer(size)
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v10.0.0 | node_modules 디렉토리 외부의 코드에서 이 생성자를 호출하면 사용 중지 경고가 발생합니다. |
| v8.0.0 | new Buffer(size)는 기본적으로 0으로 채워진 메모리를 반환합니다. |
| v7.2.1 | 이 생성자를 호출해도 더 이상 사용 중지 경고가 발생하지 않습니다. |
| v7.0.0 | 이 생성자를 호출하면 이제 사용 중지 경고가 발생합니다. |
| v6.0.0 | v6.0.0부터 사용 중지 |
[안정성: 0 - 사용 중지]
안정성: 0 Stability: 0 - 사용 중지: Buffer.alloc()를 대신 사용하십시오 ( Buffer.allocUnsafe()도 참조).
size<정수> 새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[]>File에 저장될 문자열, <ArrayBuffer>, <TypedArray>, <DataView>, <File> 또는 <Blob> 객체, 또는 이러한 객체의 조합 배열.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 객체는 전역적으로 사용 가능하지만, require('node:buffer')를 사용하여 액세스하는 node:buffer 모듈을 통해서만 사용할 수 있는 추가적인 Buffer 관련 API가 있습니다.
buffer.atob(data)
추가됨: v15.13.0, v14.17.0
data<any> Base64로 인코딩된 입력 문자열입니다.
Base64로 인코딩된 데이터 문자열을 바이트로 디코딩하고, 그 바이트를 Latin-1(ISO-8859-1)을 사용하여 문자열로 인코딩합니다.
data는 문자열로 강제 변환될 수 있는 JavaScript 값이면 됩니다.
이 함수는 레거시 웹 플랫폼 API와의 호환성을 위해서만 제공되며, 이진 데이터를 나타내는 데 문자열을 사용하고 JavaScript의 타입화된 배열이 도입되기 전의 것이므로 새로운 코드에서는 절대 사용해서는 안 됩니다. Node.js API를 사용하는 코드의 경우, Base64로 인코딩된 문자열과 이진 데이터 간의 변환은 <code>Buffer.from(str, 'base64')</code> 및 buf.toString('base64')를 사용하여 수행해야 합니다.
buffer.btoa(data)
추가됨: v15.13.0, v14.17.0
data<any> ASCII(Latin1) 문자열입니다.
Latin-1(ISO-8859)을 사용하여 문자열을 바이트로 디코딩하고, 그 바이트를 Base64를 사용하여 문자열로 인코딩합니다.
data는 문자열로 강제 변환될 수 있는 JavaScript 값이면 됩니다.
이 함수는 레거시 웹 플랫폼 API와의 호환성을 위해서만 제공되며, 이진 데이터를 나타내는 데 문자열을 사용하고 JavaScript의 타입화된 배열이 도입되기 전의 것이므로 새로운 코드에서는 절대 사용해서는 안 됩니다. Node.js API를 사용하는 코드의 경우, Base64로 인코딩된 문자열과 이진 데이터 간의 변환은 <code>Buffer.from(str, 'base64')</code> 및 buf.toString('base64')를 사용하여 수행해야 합니다.
buffer.isAscii(input)
추가됨: v19.6.0, v18.15.0
- input <Buffer> | <ArrayBuffer> | <TypedArray> 유효성 검사할 입력.
- 반환값: <boolean>
이 함수는 input이 빈 경우를 포함하여 유효한 ASCII로 인코딩된 데이터만 포함하는 경우 true를 반환합니다.
input이 분리된 배열 버퍼인 경우 예외를 throw합니다.
buffer.isUtf8(input)
추가됨: v19.4.0, v18.14.0
- input <Buffer> | <ArrayBuffer> | <TypedArray> 유효성 검사할 입력.
- 반환값: <boolean>
이 함수는 input이 빈 경우를 포함하여 유효한 UTF-8로 인코딩된 데이터만 포함하는 경우 true를 반환합니다.
input이 분리된 배열 버퍼인 경우 예외를 throw합니다.
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로의 변환이 허용되지 않으면 예외를 throw합니다.
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'))
// 출력: '?'const { Buffer, transcode } = require('node:buffer')
const newBuf = transcode(Buffer.from('€'), 'utf8', 'ascii')
console.log(newBuf.toString('ascii'))
// 출력: '?'유로(€) 기호는 US-ASCII로 표현할 수 없으므로 변환된 Buffer에서 ?로 바뀝니다.
클래스: SlowBuffer
v6.0.0부터 더 이상 사용되지 않음
[안정성: 0 - 더 이상 사용되지 않음]
안정성: 0 Stability: 0 - 더 이상 사용되지 않음: Buffer.allocUnsafeSlow()를 대신 사용하십시오.
Buffer.allocUnsafeSlow()를 참조하십시오. 이것은 생성자가 항상 SlowBuffer 인스턴스가 아닌 Buffer 인스턴스를 반환했기 때문에 클래스가 아니었습니다.
new SlowBuffer(size)
v6.0.0부터 더 이상 사용되지 않음
[안정성: 0 - 더 이상 사용되지 않음]
안정성: 0 Stability: 0 - 더 이상 사용되지 않음: Buffer.allocUnsafeSlow()를 대신 사용하십시오.
size<정수> 새SlowBuffer의 원하는 길이입니다.
Buffer.allocUnsafeSlow()를 참조하십시오.
버퍼 상수
v8.2.0에 추가됨
buffer.constants.MAX_LENGTH
[히스토리]
| 버전 | 변경 사항 |
|---|---|
| v22.0.0 | 64비트 아키텍처에서 값이 2 - 1로 변경되었습니다. |
| v15.0.0 | 64비트 아키텍처에서 값이 2로 변경되었습니다. |
| v14.0.0 | 64비트 아키텍처에서 값이 2 - 1에서 2 - 1로 변경되었습니다. |
| v8.2.0 | v8.2.0에 추가됨 |
- <정수> 단일
Buffer인스턴스에 허용되는 최대 크기입니다.
32비트 아키텍처에서는 현재 이 값이 2 - 1(약 1 GiB)입니다.
64비트 아키텍처에서는 현재 이 값이 2 - 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인스턴스는Buffer에서 데이터를 읽기 전에buf.fill(0)을 사용하거나 전체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부터는 데이터가 0으로 채워지므로 메모리 노출이 발생하지 않습니다. 그러나 서버에서 매우 큰 버퍼를 할당하도록 유도하여 성능 저하 또는 메모리 부족으로 인한 충돌을 일으키는 등 다른 공격이 여전히 가능합니다.
Buffer 인스턴스 생성을 더욱 안정적이고 오류가 적게 만들기 위해 new Buffer() 생성자의 다양한 형태가 deprecated되었으며 별도의 Buffer.from(), Buffer.alloc(), 및 Buffer.allocUnsafe() 메서드로 대체되었습니다.
개발자는 new Buffer() 생성자의 모든 기존 사용을 이러한 새 API 중 하나로 마이그레이션해야 합니다.
Buffer.from(array)는 제공된 octet의 복사본을 포함하는 새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 인스턴스가 기본적으로 생성 시 0으로 채워집니다. 이 옵션이 없으면 Buffer.allocUnsafe(), Buffer.allocUnsafeSlow(), 및 new SlowBuffer(size)로 생성된 버퍼는 0으로 채워지지 않습니다. 이 플래그를 사용하면 성능에 눈에 띄는 부정적인 영향을 미칠 수 있습니다. 새로 할당된 Buffer 인스턴스에 잠재적으로 중요한 이전 데이터가 포함될 수 없도록 하려는 경우에만 --zero-fill-buffers 옵션을 사용하십시오.
$ node --zero-fill-buffers
> Buffer.allocUnsafe(5);
<Buffer 00 00 00 00 00>Buffer.allocUnsafe() 및 Buffer.allocUnsafeSlow()를 "안전하지 않은" 것으로 만드는 요소는 무엇입니까?
Buffer.allocUnsafe() 및 Buffer.allocUnsafeSlow()를 호출할 때 할당된 메모리 세그먼트는 초기화되지 않습니다(0으로 지워지지 않습니다). 이 설계는 메모리 할당을 매우 빠르게 만들지만, 할당된 메모리 세그먼트에는 잠재적으로 중요한 이전 데이터가 포함될 수 있습니다. Buffer.allocUnsafe()로 생성된 Buffer를 메모리를 완전히 덮어쓰지 않고 사용하면 Buffer 메모리를 읽을 때 이 이전 데이터가 유출될 수 있습니다.
Buffer.allocUnsafe()를 사용하면 성능상 분명한 이점이 있지만, 애플리케이션에 보안 취약성을 도입하지 않도록 반드시 추가적인 주의를 기울여야 합니다.